<?php

namespace App\Data\Pagarme\Response\PagarmeOrderResponseData;

use App\Data\Pagarme\Response\PagarmeCustomerResponseData\PagarmeCustomerResponseData;
use App\Data\Pagarme\Response\PagarmeOrderResponseData\PagarmeOrderChargeResponseData\PagarmeOrderChargeResponseData;
use App\Data\Pagarme\Response\PagarmeOrderResponseData\PagarmeOrderChargeResponseData\PagarmeOrderTransactionResponseData;
use App\Enums\PaymentStatusEnum;

/**
 * @param  PagarmeOrderItemResponseData[]  $items
 * @param  PagarmeOrderChargeResponseData[]  $charges
 * @param  PagarmeOrderCheckoutResponseData[]  $checkouts
 */
final readonly class PagarmeOrderResponseData
{
    public function __construct(
        public ?string                        $id,
        public ?string                        $code,
        public ?int                           $amount,
        public ?string                        $currency,
        public ?bool                          $closed,
        public ?string                        $status,
        public array                          $items,
        public ?PagarmeCustomerResponseData   $customer,
        public array                          $charges,
        public array                          $checkouts,
        public array                          $metadata,
        public ?string                        $createdAt = null,
        public ?string                        $updatedAt = null,
        public ?string                        $closedAt  = null,
    ) {}

    public function authorizedAt(): ?string
    {
        $transaction = $this->lastTransaction();

        if (! $transaction) {
            return null;
        }

        if (in_array($transaction->status, ['authorized_pending_capture', 'captured', 'partial_capture'], true)) {
            return $transaction->createdAt;
        }

        return null;
    }

    public function failureCode(): ?string
    {
        $transaction = $this->lastTransaction();

        if (! $transaction) {
            return null;
        }

        return $this->filledValue($transaction->gatewayResponse['code'] ?? null);
    }

    public function failureMessage(): ?string
    {
        $transaction = $this->lastTransaction();

        if (! $transaction) {
            return null;
        }

        $acquirerMessage = $this->filledValue($transaction->acquirerMessage);

        if ($acquirerMessage) {
            return $acquirerMessage;
        }

        $gatewayErrors = $transaction->gatewayResponse['errors'] ?? [];

        if (! is_array($gatewayErrors) || empty($gatewayErrors)) {
            return null;
        }

        $message = collect($gatewayErrors)
            ->pluck('message')
            ->filter()
            ->implode('; ') ?: null;

        if ($message && str_contains($message, 'Sem ambiente configurado')) {
            return 'Pix não esta habilitado ou configurado neste ambiente do Pagar.me.';
        }

        return $message;
    }

    public function firstCharge(): ?PagarmeOrderChargeResponseData
    {
        return $this->charges[0] ?? null;
    }

    public function gatewayEntityLabel(): string
    {
        $charge = $this->firstCharge();

        return $charge?->id ? 'charge' : 'order';
    }

    public function gatewayEntityReference(): ?string
    {
        $charge = $this->firstCharge();

        return $charge?->id ?? $this->id;
    }

    public function gatewayOperationLabel(): string
    {
        $charge      = $this->firstCharge();
        $transaction = $this->lastTransaction();

        return $transaction?->id ? 'transaction' : ($charge?->id ? 'charge' : 'order');
    }

    public function gatewayOperationReference(): ?string
    {
        $charge      = $this->firstCharge();
        $transaction = $this->lastTransaction();

        return $transaction?->id ?? $charge?->id ?? $this->id;
    }

    public function id(): ?string
    {
        return $this->id;
    }

    public function lastTransaction(): ?PagarmeOrderTransactionResponseData
    {
        return $this->firstCharge()?->transaction();
    }

    public function paymentStatus(): PaymentStatusEnum
    {
        $charge      = $this->firstCharge();
        $transaction = $this->lastTransaction();
        $status      = strtolower((string) ($transaction?->status ?: $charge?->status));

        return match ($status) {
            'captured', 'paid', 'overpaid'                  => PaymentStatusEnum::PAID,
            'authorized_pending_capture', 'waiting_capture' => PaymentStatusEnum::AUTHORIZED,
            'pending', 'waiting_payment'                    => PaymentStatusEnum::PENDING,
            'processing'                                    => PaymentStatusEnum::PROCESSING,

            'not_authorized', 'with_error', 'failed',
            'underpaid', 'chargedback' => PaymentStatusEnum::FAILED,

            'voided', 'partial_void', 'canceled',
            'cancelled', 'refunded', 'partial_refunded',
            'partial_canceled' => PaymentStatusEnum::CANCELLED,
            default            => PaymentStatusEnum::PENDING,
        };
    }

    public function paidAt(): ?string
    {
        return $this->firstCharge()?->paidAt;
    }

    public function requireId(): string
    {
        if (! $this->id) {
            throw new \RuntimeException('Pagar.me order creation returned an empty id.');
        }

        return $this->id;
    }

    //

    public static function fromArray(array $payload): self
    {
        return new self(
            id:        $payload['id']   ?? null,
            code:      $payload['code'] ?? null,
            amount:    isset($payload['amount']) ? (int) $payload['amount'] : null,
            currency:  $payload['currency'] ?? null,
            closed:    $payload['closed']   ?? null,
            status:    $payload['status']   ?? null,

            items: array_map(
                static fn (array $item) => PagarmeOrderItemResponseData::fromArray($item),
                $payload['items'] ?? [],
            ),

            customer: ! empty($payload['customer'])
                ? PagarmeCustomerResponseData::fromArray($payload['customer'])
                : null,

            charges: array_map(
                static fn (array $charge) => PagarmeOrderChargeResponseData::fromArray($charge),
                $payload['charges'] ?? [],
            ),

            checkouts: array_map(
                static fn (array $checkout) => PagarmeOrderCheckoutResponseData::fromArray($checkout),
                $payload['checkouts'] ?? [],
            ),

            metadata:  $payload['metadata']   ?? [],
            createdAt: $payload['created_at'] ?? null,
            updatedAt: $payload['updated_at'] ?? null,
            closedAt:  $payload['closed_at']  ?? null,
        );
    }

    public function toArray(): array
    {
        return [
            'id'       => $this->id,
            'code'     => $this->code,
            'amount'   => $this->amount,
            'currency' => $this->currency,
            'closed'   => $this->closed,

            'items' => array_map(
                static fn (PagarmeOrderItemResponseData $item) => $item->toArray(),
                $this->items,
            ),

            'customer'   => $this->customer?->toArray(),
            'status'     => $this->status,
            'created_at' => $this->createdAt,
            'updated_at' => $this->updatedAt,
            'closed_at'  => $this->closedAt,

            'charges' => array_map(
                static fn (PagarmeOrderChargeResponseData $charge) => $charge->toArray(),
                $this->charges,
            ),

            'checkouts' => array_map(
                static fn (PagarmeOrderCheckoutResponseData $checkout) => $checkout->toArray(),
                $this->checkouts,
            ),

            'metadata'   => $this->metadata,
        ];
    }

    //

    private function filledValue(mixed $value): ?string
    {
        if ($value === null || $value === '' || $value === []) {
            return null;
        }

        return (string) $value;
    }
}