<?php

namespace App\Domains\Purchase\Services\Checkout;

use App\Domains\Catalog\Models\StockReservation;
use App\Domains\Catalog\Services\StockReservationService;
use App\Domains\Purchase\Models\Purchase;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;

class ReleaseCheckoutService
{
    public function __construct(
        private readonly StockReservationService $reservations,
        private readonly SourceCartService $sourceCart,
    ) {}

    public function cancel(Purchase $purchase): Purchase
    {
        return $this->release($purchase, Purchase::STATUS_CANCELLED, restoreCart: true);
    }

    public function cancelWithoutRestoringCart(Purchase $purchase): Purchase
    {
        return $this->release($purchase, Purchase::STATUS_CANCELLED, restoreCart: false);
    }

    public function expire(Purchase $purchase): Purchase
    {
        return $this->release($purchase, Purchase::STATUS_EXPIRED, restoreCart: true);
    }

    public function expireOverdue(): int
    {
        $expiredCount = 0;

        Purchase::query()
            ->whereIn('status', [Purchase::STATUS_CREATED, Purchase::STATUS_PENDING_PAYMENT])
            ->whereNotNull('expires_at')
            ->where('expires_at', '<=', now())
            ->orderBy('id')
            ->eachById(function (Purchase $purchase) use (&$expiredCount): void {
                $purchase = $this->expire($purchase);

                if ($purchase->status === Purchase::STATUS_EXPIRED) {
                    $expiredCount++;
                }
            });

        return $expiredCount;
    }

    private function release(Purchase $purchase, string $targetStatus, bool $restoreCart): Purchase
    {
        return DB::transaction(function () use ($purchase, $targetStatus, $restoreCart): Purchase {
            $purchase = $this->lockPurchase($purchase);

            if ($purchase->status === Purchase::STATUS_PAID) {
                if ($targetStatus === Purchase::STATUS_EXPIRED) {
                    return $this->loadPurchase($purchase);
                }

                throw ValidationException::withMessages([
                    'purchase' => __('api.purchase.paid_cannot_cancel'),
                ]);
            }

            if ($this->isAlreadyReleased($purchase)) {
                return $this->loadPurchase($purchase);
            }

            if (
                $targetStatus === Purchase::STATUS_EXPIRED
                && ($purchase->expires_at === null || $purchase->expires_at->isFuture())
            ) {
                return $this->loadPurchase($purchase);
            }

            if ($purchase->items()->exists()) {
                throw ValidationException::withMessages([
                    'items' => __('api.purchase.inconsistent_reservation'),
                ]);
            }

            $reservationReturnedToCart = $restoreCart && $this->sourceCart->restore($purchase);
            $this->releaseCartReservations($purchase, $reservationReturnedToCart, $targetStatus);

            $purchase->update(['status' => $targetStatus]);

            return $this->loadPurchase($purchase);
        });
    }

    private function releaseCartReservations(
        Purchase $purchase,
        bool $reservationReturnedToCart,
        string $targetStatus,
    ): void {
        if ($reservationReturnedToCart) {
            $this->reservations->detachFromPurchase($purchase);

            return;
        }

        $cart = $purchase->cart()->withTrashed()->lockForUpdate()->first();
        if ($cart === null) {
            return;
        }

        $cartItems = $cart->items()->orderBy('id')->lockForUpdate()->get();
        $cartItems->load([
            'catalogItem.inventory',
            'catalogItem.bundleComponents.catalogItem.inventory',
            'catalogItem.bundleComponents.variant.inventory',
            'variant.inventory',
            'variant.catalogItem',
        ]);

        foreach ($cartItems as $cartItem) {
            $selection = $cartItem->selectedItem();
            if ($selection === null) {
                continue;
            }

            try {
                $this->reservations->release(
                    $cartItem,
                    $selection,
                    (int) $cartItem->cantidad,
                    $targetStatus === Purchase::STATUS_EXPIRED
                        ? StockReservation::STATUS_EXPIRED
                        : StockReservation::STATUS_RELEASED,
                );
            } catch (\InvalidArgumentException) {
                throw ValidationException::withMessages([
                    'items' => __('api.purchase.inconsistent_reservation'),
                ]);
            }
        }

        if (! $cart->trashed()) {
            $cart->update(['status' => 'converted']);
            $cart->delete();
        }
    }

    private function isAlreadyReleased(Purchase $purchase): bool
    {
        return in_array($purchase->status, [
            Purchase::STATUS_CANCELLED,
            Purchase::STATUS_REJECTED,
            Purchase::STATUS_EXPIRED,
        ], true);
    }

    private function lockPurchase(Purchase $purchase): Purchase
    {
        /** @var Purchase */
        return Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
    }

    private function loadPurchase(Purchase $purchase): Purchase
    {
        return $purchase->load([
            'items.imageAttachment',
            'cart.items.catalogItem.inventory',
            'cart.items.catalogItem.attachments',
            'cart.items.variant.inventory',
            'cart.items.variant.attachments',
            'cart.items.variant.definitions.itemAttribute.attribute',
            'cart.items.variant.eventDates',
            'cart.items.variant.eventDate',
        ]);
    }
}