<?php

namespace App\Services;

use App\Models\User;
use App\Services\InsForge\InsForgeAuthService;
use App\Services\InsForge\InsForgeClient;
use App\Services\InsForge\InsForgeException;
use App\Services\InsForge\InsForgeTableService;
use Illuminate\Auth\Access\AuthorizationException;
use Illuminate\Support\Facades\Session;
use Illuminate\Validation\ValidationException;

class OrderService extends InsForgeTableService
{
    public const STATUS_PENDING = 'pending';

    public const STATUS_PROCESSING = 'processing';

    public const STATUS_DELIVERING = 'delivering';

    public const STATUS_COMPLETED = 'completed';

    public const STATUS_CANCELLED = 'cancelled';

    /** @var array<string, list<string>> */
    protected const TRANSITIONS = [
        self::STATUS_PENDING => [self::STATUS_PROCESSING, self::STATUS_CANCELLED],
        self::STATUS_PROCESSING => [self::STATUS_DELIVERING, self::STATUS_CANCELLED],
        self::STATUS_DELIVERING => [self::STATUS_COMPLETED],
        self::STATUS_COMPLETED => [],
        self::STATUS_CANCELLED => [],
    ];

    public function __construct(
        InsForgeClient $client,
        private readonly ProductService $products,
        private readonly ActivityLogger $activity,
    ) {
        parent::__construct($client);
    }

    protected function table(): string
    {
        return 'orders';
    }

    protected function select(): string
    {
        return '*,customers(code,name),drivers(code,name),order_items(quantity,unit_price,subtotal)';
    }

    protected function searchableColumns(): array
    {
        return ['order_number'];
    }

    protected function sortableColumns(): array
    {
        return ['order_number', 'order_date', 'order_status', 'created_at'];
    }

    public function findWithRelations(string $id): ?array
    {
        [$client, $asUser] = $this->scoped();

        return collect($client->listRecords($this->table(), [
            'select' => '*,customers(*),drivers(*),order_items(quantity,unit_price,subtotal,cost_price,products(code,name))',
            'id' => 'eq.'.$id,
            'limit' => 1,
        ], asUser: $asUser))[0] ?? null;
    }

    /**
     * @param  list<array{product_id: string, quantity: int|string, unit_price: int|string|float}>  $items
     */
    public function createOrder(array $attributes, array $items, ?User $actor = null): array
    {
        $items = $this->normalizeItems($items);

        if ($items === []) {
            throw ValidationException::withMessages(['items' => 'Order minimal memiliki satu item.']);
        }

        $this->assertStockAvailable($items);

        [$client, $asUser] = $this->scoped();

        $number = $this->nextOrderNumber();

        $order = array_filter([
            'order_number' => $number,
            'order_date' => $attributes['order_date'] ?? now()->toDateString(),
            'delivery_date' => $attributes['delivery_date'] ?? null,
            'customer_id' => $attributes['customer_id'],
            'driver_id' => $attributes['driver_id'] ?? null,
            'payment_method' => $attributes['payment_method'] ?? 'cash',
            'payment_status' => $attributes['payment_status'] ?? 'unpaid',
            'notes' => $attributes['notes'] ?? null,
            'order_status' => self::STATUS_PENDING,
        ], fn ($value) => $value !== null && $value !== '');

        $created = $client->insertRecord($this->table(), [$order], asUser: $asUser);
        $orderId = is_array($created) ? data_get($created, '0.id') : null;

        $stored = $client->listRecords($this->table(), [
            'select' => 'id',
            'order_number' => 'eq.'.$number,
            'order' => 'created_at.desc',
            'limit' => 1,
        ], asUser: $asUser)[0] ?? null;

        $orderId = $orderId ?? ($stored['id'] ?? null);

        if ($orderId === null) {
            throw new \RuntimeException('Gagal mengambil id order yang baru dibuat.');
        }

        $client->insertRecord('order_items', $this->itemPayloads($orderId, $items), asUser: false);

        $client->insertRecord('order_status_histories', [[
            'order_id' => $orderId,
            'old_status' => null,
            'new_status' => self::STATUS_PENDING,
            'changed_by' => $actor?->id,
        ]], asUser: false);

        $this->activity->log('order_created', 'orders', $orderId, "Order {$number} dibuat.", $actor);

        return ['id' => $orderId, 'order_number' => $number];
    }

    public function replaceItems(string $orderId, array $items, ?User $actor = null): void
    {
        [$client, $asUser] = $this->scoped();

        $order = $this->findWithRelations($orderId) ?? throw ValidationException::withMessages(['order' => 'Order tidak ditemukan.']);

        if (($order['order_status'] ?? '') !== self::STATUS_PENDING) {
            throw ValidationException::withMessages(['order' => 'Item hanya dapat diubah saat status masih pending.']);
        }

        $items = $this->normalizeItems($items);
        $this->assertStockAvailable($items);

        $client->deleteRecords('order_items', ['order_id' => $orderId], asUser: false);
        $client->insertRecord('order_items', $this->itemPayloads($orderId, $items), asUser: false);

        $this->activity->log('order_items_updated', 'orders', $orderId, "Item order {$order['order_number']} diperbarui.", $actor);
    }

    public function updateDetails(string $orderId, array $attributes, ?User $actor = null): void
    {
        [$client, $asUser] = $this->scoped();

        $order = $this->findWithRelations($orderId) ?? throw ValidationException::withMessages(['order' => 'Order tidak ditemukan.']);

        if (in_array($order['order_status'], [self::STATUS_COMPLETED, self::STATUS_CANCELLED], true)) {
            throw ValidationException::withMessages(['order' => 'Order yang sudah selesai atau dibatalkan tidak dapat diubah.']);
        }

        $patch = array_filter([
            'customer_id' => $attributes['customer_id'] ?? null,
            'driver_id' => $attributes['driver_id'] ?? null,
            'order_date' => $attributes['order_date'] ?? null,
            'delivery_date' => $attributes['delivery_date'] ?? null,
            'payment_method' => $attributes['payment_method'] ?? null,
            'payment_status' => $attributes['payment_status'] ?? null,
            'survey_status' => $attributes['survey_status'] ?? null,
            'notes' => $attributes['notes'] ?? null,
        ], fn ($value) => $value !== null);

        if ($patch !== []) {
            $client->updateRecords($this->table(), ['id' => $orderId], $patch, asUser: false);
        }
    }

    public function transition(string $orderId, string $to, ?string $notes = null, ?User $actor = null): void
    {
        [$client, $asUser] = $this->scoped();

        $order = $client->getRecord($this->table(), $orderId, asUser: $asUser)
            ?? throw ValidationException::withMessages(['order' => 'Order tidak ditemukan.']);

        $from = $order['order_status'] ?? '';

        if (! in_array($to, self::TRANSITIONS[$from] ?? [], true)) {
            throw ValidationException::withMessages([
                'order' => "Transisi status {$from} ke {$to} tidak valid.",
            ]);
        }

        if ($to === self::STATUS_CANCELLED) {
            $isOwner = $actor !== null && $actor->id === ($order['created_by'] ?? null);

            if (! ($actor?->isAdmin() ?? false) && ! $isOwner) {
                throw new AuthorizationException('Hanya admin atau operator pembuat yang dapat membatalkan order.');
            }
        }

        if ($to === self::STATUS_COMPLETED) {
            $token = Session::get(InsForgeAuthService::SESSION_ACCESS_TOKEN);
            $rpcClient = $token ? $this->client->withToken($token) : $this->client;

            try {
                $rpcClient->rpc('complete_order', [
                    'p_order_id' => $orderId,
                    'p_actor' => $actor?->id,
                ], asUser: filled($token));
            } catch (InsForgeException $exception) {
                $message = $exception->getMessage();

                if (str_starts_with($message, 'INSUFFICIENT_STOCK:')) {
                    throw ValidationException::withMessages(['order' => 'Stok tidak mencukupi untuk menyelesaikan order ini.']);
                }

                if ($message === 'INVALID_TRANSITION') {
                    throw ValidationException::withMessages(['order' => 'Transisi status tidak valid.']);
                }

                throw $exception;
            }

            return;
        }

        $client->updateRecords($this->table(), ['id' => $orderId], ['order_status' => $to], asUser: false);

        $history = array_filter([
            'order_id' => $orderId,
            'old_status' => $from,
            'new_status' => $to,
            'changed_by' => $actor?->id,
            'notes' => $notes,
        ], fn ($value) => $value !== null && $value !== '');

        $client->insertRecord('order_status_histories', [$history], asUser: false);

        $this->activity->log("order_{$to}", 'orders', $orderId, "Order {$order['order_number']} berstatus {$to}.", $actor);
    }

    public function softDelete(string $orderId, ?User $actor = null): void
    {
        if (! ($actor?->isAdmin() ?? false)) {
            throw new AuthorizationException('Hanya admin yang dapat menghapus order.');
        }

        [$client, $asUser] = $this->scoped();

        $order = $client->getRecord($this->table(), $orderId, asUser: $asUser)
            ?? throw ValidationException::withMessages(['order' => 'Order tidak ditemukan.']);

        if (($order['deleted_at'] ?? null) !== null) {
            return;
        }

        $client->updateRecords($this->table(), ['id' => $orderId], [
            'deleted_at' => now()->toISOString(),
        ], asUser: false);

        $this->activity->log('order_deleted', 'orders', $orderId, "Order {$order['order_number']} dihapus.", $actor);
    }

    public function canCancel(array $record, ?User $actor): bool
    {
        $status = $record['order_status'] ?? '';

        if (! in_array($status, [self::STATUS_PENDING, self::STATUS_PROCESSING], true)) {
            return false;
        }

        return $actor !== null && ($actor->isAdmin() || $actor->id === ($record['created_by'] ?? null));
    }

    public function deliveryNoteData(string $orderId): array
    {
        [$client, $asUser] = $this->scoped();

        $order = collect($client->listRecords($this->table(), [
            'select' => '*,customers(*),drivers(*),order_items(quantity,unit_price,subtotal,products(code,name,unit))',
            'id' => 'eq.'.$orderId,
            'limit' => 1,
        ], asUser: $asUser))[0] ?? null;

        if ($order === null || ($order['deleted_at'] ?? null) !== null) {
            abort(404);
        }

        if (! in_array($order['order_status'], [self::STATUS_DELIVERING, self::STATUS_COMPLETED], true)) {
            abort(403, 'Surat jalan tersedia saat status delivering atau completed.');
        }

        $order['note_number'] = $this->deliveryNoteNumber((string) $order['order_number']);

        return $order;
    }

    public function deliveryNoteNumber(string $orderNumber): string
    {
        if (preg_match('/^ORD-(\d{4})(\d{2})(\d{2})-/', $orderNumber, $m) === 1) {
            return sprintf('SJL-%s/%s/%s-%s', $m[1], $m[2], $m[3], $orderNumber);
        }

        return 'SJL-'.now()->format('Y/m/d').'-'.$orderNumber;
    }

    private function nextOrderNumber(): string
    {
        [$client, $asUser] = $this->scoped();

        $prefix = 'ORD-'.now()->format('Ymd').'-';

        $last = $client->listRecords($this->table(), [
            'select' => 'order_number',
            'order_number' => 'like.'.$prefix.'*',
            'order' => 'order_number.desc',
            'limit' => 1,
        ], asUser: $asUser)[0]['order_number'] ?? null;

        preg_match('/(\d+)$/', (string) $last, $matches);

        return $prefix.sprintf('%04d', ((int) ($matches[1] ?? 0)) + 1);
    }

    private function normalizeItems(array $items): array
    {
        $normalized = [];

        foreach ($items as $item) {
            $productId = (string) ($item['product_id'] ?? '');
            $quantity = max(1, (int) ($item['quantity'] ?? 0));
            $unitPrice = (int) round((float) ($item['unit_price'] ?? 0));

            if ($productId === '' || $unitPrice < 0) {
                continue;
            }

            $normalized[$productId] = [
                'product_id' => $productId,
                'quantity' => ($normalized[$productId]['quantity'] ?? 0) + $quantity,
                'unit_price' => $unitPrice,
            ];
        }

        return array_values($normalized);
    }

    private function assertStockAvailable(array $items): void
    {
        [$client, $asUser] = $this->scoped();

        $ids = implode(',', array_map(fn (string $id): string => '"'.$id.'"', array_column($items, 'product_id')));

        $stocks = $client->listRecords('stocks', [
            'select' => 'product_id,quantity',
            'product_id' => 'in.('.$ids.')',
        ], asUser: $asUser);

        $balances = [];
        foreach ($stocks as $stock) {
            $balances[$stock['product_id']] = ($balances[$stock['product_id']] ?? 0) + (int) $stock['quantity'];
        }

        $codes = $this->products->codeMap();

        $shortages = [];

        foreach ($items as $item) {
            $available = $balances[$item['product_id']] ?? 0;

            if ($item['quantity'] > $available) {
                $shortages[] = sprintf('%s (sisa %d)', $codes[$item['product_id']] ?? $item['product_id'], $available);
            }
        }

        if ($shortages !== []) {
            throw ValidationException::withMessages([
                'items' => 'Stok tidak cukup untuk: '.implode(', ', $shortages),
            ]);
        }
    }

    private function itemPayloads(string $orderId, array $items): array
    {
        $costs = $this->products->costMap();

        return array_map(fn (array $item): array => [
            'order_id' => $orderId,
            'product_id' => $item['product_id'],
            'quantity' => $item['quantity'],
            'unit_price' => $item['unit_price'],
            'subtotal' => $item['quantity'] * $item['unit_price'],
            'cost_price' => $costs[$item['product_id']] ?? 0,
        ], $items);
    }
}