{{--
    O DETALHE DE UMA COMANDA, em modal.

    O card da grade ficou reduzido ao nome do cliente e aos nomes dos itens — é
    um índice visual, não um extrato. Tudo o que ficou de fora (situação, id,
    abertura, quantidades, subtotais, total e o pagamento) vive AQUI, e é aqui
    que o operador confere antes de cobrar.

    Este arquivo é incluído dentro de `orders/_results.blade.php`, FORA da `.row`
    de cards. Dentro de um `.col` o backdrop do Bootstrap seria recortado pelo
    card em vez de cobrir a página — o mesmo motivo que mantém o modal de nova
    comanda no fim da index.

    Ele é trocado junto com a grade a cada busca ao vivo, e isso é intencional:
    o detalhe precisa refletir a comanda que está na tela. Diferente do modal de
    nova comanda, não há Tom Select nem estado de carrinho para se perder aqui.

    @param \App\Models\Order $order
--}}
<div class="modal fade" id="order-detail-{{ $order->id }}" tabindex="-1"
     aria-labelledby="order-detail-{{ $order->id }}-title" aria-hidden="true">
    <div class="modal-dialog modal-dialog-centered modal-dialog-scrollable">
        <div class="modal-content">
            <div class="modal-header">
                <div>
                    <h2 class="modal-title h5 mb-1" id="order-detail-{{ $order->id }}-title">
                        {{ $order->customer?->name ?? '—' }}
                    </h2>

                    {{-- O id aparece porque é por ele que o balcão se refere à
                         comanda ao telefone e no fechamento. --}}
                    <p class="mb-0 small text-body-secondary">
                        Comanda #{{ $order->id }}
                        <span class="mx-1">·</span>
                        {{ $order->created_at->format('d/m/Y H:i') }}
                    </p>
                </div>

                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Fechar"></button>
            </div>

            <div class="modal-body">
                {{-- TRÊS ESTADOS, e o terceiro é o que importa: a comanda que
                     atravessou a virada do dia vira VERMELHA e diz há quantos
                     dias está aberta. Amarelo para a do dia é normal — o cliente
                     ainda está consumindo. Vermelho é cobrança esquecida, e o
                     número diz o tamanho do esquecimento. --}}
                @if ($order->isArchived() && $order->isReceivable())
                    {{-- ARQUIVADA E NÃO PAGA: o acerto foi combinado para outro
                         dia, e a comanda veio para o histórico com o consumo
                         encerrado. A badge diz PARA QUANDO e não "Arquivada" —
                         cinza sozinho faria parecer conta resolvida, e ela é o
                         contrário disso: é dinheiro que a arena ainda tem a
                         receber. Quem cobra é o financeiro. --}}
                    <span class="badge text-bg-info">A receber em {{ $order->payment_due_date->format('d/m/Y') }}</span>
                @elseif ($order->isArchived())
                    {{-- Arquivada e paga — o fechamento no balcão, que grava os
                         dois campos de uma vez. Uma badge só basta: "Arquivada"
                         e "Paga" lado a lado diriam a mesma coisa ocupando o
                         dobro, e a data do pagamento aparece no rodapé. --}}
                    <span class="badge text-bg-secondary">Arquivada</span>
                @elseif ($order->isPaid())
                    <span class="badge text-bg-success">Paga</span>
                @elseif ($order->isReceivable())
                    {{-- ACERTO COMBINADO EM COMANDA NÃO ARQUIVADA — hoje só as
                         LEGADAS, combinadas antes de o acerto passar a arquivar.
                         O caminho novo cai na primeira condição lá em cima.

                         Fica antes do vermelho de propósito: "Em aberto 4 dias"
                         numa conta cujo acerto foi combinado para sexta cobraria
                         o operador por um esquecimento que não existe. --}}
                    <span class="badge text-bg-info">Pagamento em {{ $order->payment_due_date->format('d/m/Y') }}</span>
                @elseif ($order->daysOpen() > 0)
                    {{-- O rótulo sai de UMA expressão, e não de duas linhas de
                         Blade: quebrado, o HTML nasceria com um fim de linha no
                         meio de "1 · dia" — invisível na tela, mas o bastante
                         para qualquer busca por esse texto (teste, leitor de
                         tela) não o encontrar. --}}
                    <span class="badge text-bg-danger">{{ 'Em aberto '.$order->daysOpen().($order->daysOpen() === 1 ? ' dia' : ' dias') }}</span>
                @else
                    <span class="badge text-bg-warning">Em aberto</span>
                @endif

                {{-- Lista, não tabela: são duas colunas curtas, e uma tabela
                     traria cabeçalho e bordas que competem com a moldura do
                     próprio modal. `mx-0` desfaz o recuo do modal-body para a
                     lista encostar nas laterais, como no card. --}}
                <ul class="list-group list-group-flush mt-3">
                    @forelse ($order->items as $item)
                        <li class="list-group-item d-flex justify-content-between align-items-center gap-2 px-0">
                            <span>
                                {{-- `withTrashed` na relação garante que o
                                     produto excluído ainda apareça: a venda
                                     aconteceu, e um item sem nome seria pior que
                                     um nome de produto que saiu do catálogo. --}}
                                <span class="fw-semibold">{{ $item->quantity }}×</span>
                                {{ $item->product?->name ?? 'Produto removido' }}
                            </span>

                            <span class="text-body-secondary text-nowrap">
                                {{ $item->formattedSubtotal() }}
                            </span>
                        </li>
                    @empty
                        <li class="list-group-item text-center text-body-secondary py-4 px-0">
                            Nenhum item lançado.
                        </li>
                    @endforelse
                </ul>
            </div>

            <div class="modal-footer d-block">
                <div class="d-flex justify-content-between align-items-center">
                    <span class="text-body-secondary">Total</span>
                    <span class="fs-5 fw-semibold">{{ $order->formattedTotal() }}</span>
                </div>

                {{-- O GATE DOS BOTÕES É O ARQUIVAMENTO, não o pagamento. Os dois
                     deixaram de andar juntos quando o acerto combinado passou a
                     mandar a comanda para o histórico ainda não paga: perguntar
                     `isPaid()` aqui deixaria justamente essas com "Adicionar
                     itens" e "Pagar" à mostra dentro do Histórico, oferecendo
                     duas ações que o servidor recusa (ver
                     `OrderController::syncItems()`).

                     ARQUIVADA É SÓ LEITURA — as três variações abaixo trocam o
                     texto, nunca a existência dos botões. --}}
                @if ($order->isArchived())
                    @if ($order->isReceivable())
                        {{-- A COBRANÇA MUDOU DE TELA, e o rodapé diz para onde:
                             sem isso, quem abre a comanda no histórico e vê que
                             ela não está paga nem tem botão concluiria que o
                             dinheiro se perdeu no caminho. --}}
                        <p class="small text-body-secondary mb-0 mt-2">
                            <i class="bi bi-clock-history me-1"></i>
                            Acerto combinado para {{ $order->payment_due_date->format('d/m/Y') }}.
                            A cobrança está em <strong>Lançamentos</strong>, e é lá que a baixa é dada.
                        </p>
                    @elseif ($order->isPaid())
                        <p class="small text-body-secondary mb-0 mt-2">
                            <i class="bi bi-check-circle me-1"></i>
                            Paga em {{ $order->paid_at->format('d/m/Y \à\s H:i') }}
                        </p>
                    @else
                        {{-- Arquivada, sem pagamento e sem data combinada. Sobra
                             da comanda que teve o lançamento REABERTO no
                             financeiro ({@see OrderBilling::unsettle()}): a
                             quitação foi desfeita, e a data do combinado o
                             pagamento já havia apagado. Dizer "sem pagamento
                             registrado" é honesto; herdar o texto de "paga"
                             afirmaria o que o caixa acabou de negar. --}}
                        <p class="small text-body-secondary mb-0 mt-2">
                            <i class="bi bi-dash-circle me-1"></i>
                            Encerrada sem pagamento registrado. Confira em <strong>Lançamentos</strong>.
                        </p>
                    @endif
                @elseif ($order->isPaid())
                    {{-- Paga mas NÃO arquivada não deveria existir — `markPaid()`
                         grava os dois campos de uma vez. Se aparecer, é dado
                         inconsistente, e mostrar a data de pagamento sem oferecer
                         botão é a saída segura. --}}
                    <p class="small text-body-secondary mb-0 mt-2">
                        <i class="bi bi-check-circle me-1"></i>
                        Paga em {{ $order->paid_at->format('d/m/Y \à\s H:i') }}
                    </p>
                @else
                    @if ($order->isReceivable())
                        {{-- Comanda LEGADA: acerto combinado antes de a regra
                             passar a arquivar, então ela ainda está no balcão e
                             ainda tem os botões. O de pagar fecha a conta pelo
                             caminho normal e reaproveita a previsão. --}}
                        <p class="small text-body-secondary mb-0 mt-2">
                            <i class="bi bi-clock-history me-1"></i>
                            Pagamento em  {{ $order->payment_due_date->format('d/m/Y') }}.
                        </p>
                    @endif

                    @can('update', $order)
                        {{-- ADICIONAR ITENS: só para comanda em aberto — depois de
                             paga o valor já virou lançamento no financeiro, e
                             mexer nos itens mudaria o total de uma conta que o
                             extrato do dia já contou.

                             O par `data-bs-dismiss` + `data-bs-toggle` é a troca
                             de modais do Bootstrap: este fecha, o do catálogo
                             abre. Empilhar os dois deixaria dois backdrops e a
                             rolagem do fundo solta ao fechar o de cima.

                             TRÊS DADOS VÃO NO BOTÃO porque o modal de itens é um
                             só para a página inteira: para onde enviar, de quem
                             é a comanda e — o que importa aqui — O QUE JÁ ESTÁ
                             LANÇADO, para o carrinho abrir preenchido.

                             O PREÇO QUE VIAJA É O `unit_price` DO ITEM, e não o
                             do catálogo: é ele que a comanda cobra, e usar o
                             preço atual faria o total do carrinho não bater com
                             o total mostrado logo acima, no mesmo modal. Ele
                             serve só para somar na tela — quem grava valor é o
                             servidor, que nem lê este número. --}}
                        <button type="button" class="btn btn-outline-primary w-100 mt-2"
                                data-bs-dismiss="modal"
                                data-bs-toggle="modal" data-bs-target="#order-add-items"
                                data-order-sync-url="{{ route('orders.items.update', $order) }}"
                                data-order-sync-label="Comanda #{{ $order->id }} · {{ $order->customer?->name ?? '—' }}"
                                data-order-sync-items="{{ $order->items->map(fn ($item) => [
                                    'id' => (string) $item->product_id,
                                    'name' => $item->product?->name ?? 'Produto removido',
                                    'price' => $item->unit_price,
                                    'quantity' => $item->quantity,
                                ])->toJson() }}">
                            <i class="bi bi-plus-lg me-1"></i> Adicionar itens
                        </button>

                        {{-- PAGAR ABRE UM MODAL, e não confirma direto. O
                             fechamento deixou de ser uma pergunta de sim ou não:
                             o operador precisa dizer em que conta o dinheiro
                             entra, por qual meio e em que data — e é isso que o
                             `#order-pay` pergunta.

                             O modal genérico de confirmação (partials/confirm-
                             modal) NÃO serve aqui: ele é um elemento só,
                             compartilhado por toda a aplicação, e enfiar select
                             de conta e forma de pagamento nele espalharia
                             assunto de comanda por todas as telas que confirmam
                             qualquer coisa.

                             `data-bs-dismiss` + `data-bs-toggle` é a troca de
                             modais do Bootstrap: este fecha, o de pagamento
                             abre. Empilhados, ficariam dois backdrops e a
                             rolagem do fundo solta ao fechar o de cima. --}}
                        {{-- PAGAR e DESCARTAR dividem a linha: são os dois
                             desfechos de uma comanda em aberto, e empilhados um
                             sobre o outro sugeririam ordem entre eles. O
                             `flex-fill` dá a mesma largura aos dois quando o
                             Descartar aparece, e o Pagar ocupa a linha inteira
                             quando não aparece — sem duas variantes de classe no
                             Blade. --}}
                        <div class="d-flex gap-2 mt-2">
                            @can('delete', $order)
                                {{-- DESCARTAR é para o ENGANO DO BALCÃO: cliente
                                     trocado, comanda aberta em duplicidade, teste
                                     que ficou na tela. Só aparece em comanda EM
                                     ABERTO — este bloco inteiro já está no
                                     `@else` do arquivamento —, porque comanda
                                     encerrada tem lançamento no financeiro e
                                     apagá-la deixaria receita sem origem (ver
                                     `OrderController::destroy()`).

                                     PERMISSÃO PRÓPRIA (`orders.delete`), e não a
                                     mesma do Pagar: quem corrige itens não
                                     necessariamente pode fazer consumo
                                     desaparecer.

                                     ABRE UM MODAL, e não o confirm-modal
                                     genérico: o descarte PERGUNTA O MOTIVO, e um
                                     textarea obrigatório dentro do elemento de
                                     confirmação compartilhado por toda a
                                     aplicação espalharia assunto de comanda por
                                     todas as telas que confirmam qualquer coisa.
                                     Mesmo raciocínio do botão de pagar.

                                     `data-bs-dismiss` + `data-bs-toggle` é a
                                     troca de modais do Bootstrap: este fecha, o
                                     do descarte abre. Empilhados, ficariam dois
                                     backdrops e a rolagem do fundo solta ao
                                     fechar o de cima. --}}
                                <button type="button" class="btn btn-outline-danger flex-fill"
                                        data-bs-dismiss="modal"
                                        data-bs-toggle="modal" data-bs-target="#order-discard"
                                        data-order-discard-url="{{ route('orders.destroy', $order) }}"
                                        data-order-discard-label="Comanda #{{ $order->id }} · {{ $order->customer?->name ?? '—' }}">
                                    <i class="bi bi-trash me-1"></i> Descartar
                                </button>
                            @endcan

                            <button type="button" class="btn btn-success flex-fill"
                                    data-bs-dismiss="modal"
                                    data-bs-toggle="modal" data-bs-target="#order-pay"
                                    data-order-pay-url="{{ route('orders.payment', $order) }}"
                                    data-order-pay-label="Comanda #{{ $order->id }} · {{ $order->customer?->name ?? '—' }}"
                                    data-order-pay-total="{{ $order->formattedTotal() }}">
                                <i class="bi bi-cash-coin me-1"></i> Pagar
                            </button>
                        </div>
                    @endcan
                @endif
            </div>
        </div>
    </div>
</div>