import { cookies } from "next/headers";
import { NextResponse } from "next/server";
import { createAdminClient } from "@/lib/supabase-admin";
import { reconcileCatalogPaymentWithProvider } from "@/lib/catalog-payment-reconcile";

type SessionPayload = {
  client?: {
    id: string;
  } | null;
};

function normalizeText(value: unknown) {
  return String(value || "").trim();
}

export async function GET(request: Request) {
  try {
    const { searchParams } = new URL(request.url);
    const slug = normalizeText(searchParams.get("slug"));
    const orderId = normalizeText(searchParams.get("orderId"));
    if (!slug || !orderId) {
      return NextResponse.json({ error: "Pedido invalido." }, { status: 400 });
    }

    const cookieStore = await cookies();
    const token = cookieStore.get("ks_client_portal")?.value || "";
    if (!token) {
      return NextResponse.json({ error: "Faça login para continuar." }, { status: 401 });
    }

    const admin = createAdminClient();
    const sessionResult = await admin.rpc("client_portal_get_session", {
      p_slug: slug,
      p_session_token: token,
    });
    const sessionPayload = (sessionResult.data || null) as SessionPayload | null;
    if (sessionResult.error || !sessionPayload?.client?.id) {
      return NextResponse.json({ error: "Sessao invalida. Faca login novamente." }, { status: 401 });
    }

    // eslint-disable-next-line prefer-const -- `order` e reatribuido apos a conciliacao
    let { data: order, error: orderError } = await admin
      .from("catalog_orders")
      .select("id,client_id,number,status,payment_status,payment_method,payment_reference,paid_at,approved_order_id")
      .eq("id", orderId)
      .maybeSingle();

    /* So o dono do pedido acompanha o pagamento (a mesma regra do envio). */
    if (orderError || !order?.id || String(order.client_id || "") !== String(sessionPayload.client.id)) {
      return NextResponse.json({ error: "Pedido nao encontrado." }, { status: 404 });
    }

    const colunasDoPagamento =
      "id,user_id,catalog_order_id,amount,integration_id,status,provider_status,provider_status_detail,payment_method,provider_payment_id,qr_code,qr_code_base64,ticket_url,approved_at,applied_payment_id,updated_at";

    const lerPagamento = () =>
      admin
        .from("catalog_order_payments")
        .select(colunasDoPagamento)
        .eq("catalog_order_id", orderId)
        .order("created_at", { ascending: false })
        .limit(1)
        .maybeSingle();

    // eslint-disable-next-line prefer-const -- `payment` e reatribuido apos a conciliacao
    let { data: payment, error: paymentError } = await lerPagamento();

    /* Conciliacao ativa: se o pagamento ainda esta em aberto, pergunta ao
       provedor como ele esta em vez de esperar o aviso automatico. Sem isso, um
       Pix pago sem o aviso chegar deixava a tela em "aguarde a confirmacao"
       para sempre e o pedido pendente. Falha de rede aqui nao pode derrubar a
       consulta: no pior caso a tela segue mostrando o estado gravado. */
    if (!paymentError && payment) {
      try {
        const resultado = await reconcileCatalogPaymentWithProvider(admin as never, payment as never);
        if (resultado.atualizado) {
          const novaLeitura = await lerPagamento();
          if (!novaLeitura.error && novaLeitura.data) {
            payment = novaLeitura.data;
          }
          const pedidoAtualizado = await admin
            .from("catalog_orders")
            .select("id,client_id,number,status,payment_status,payment_method,payment_reference,paid_at,approved_order_id")
            .eq("id", orderId)
            .maybeSingle();
          if (!pedidoAtualizado.error && pedidoAtualizado.data) {
            order = pedidoAtualizado.data;
          }
        }
      } catch (reconciliationError) {
        console.error("Falha ao conciliar pagamento com o provedor:", reconciliationError);
      }
    }

    if (paymentError) {
      return NextResponse.json({ error: paymentError.message || "Nao foi possivel consultar o pagamento." }, { status: 500 });
    }

    return NextResponse.json({
      ok: true,
      order: {
        id: order.id,
        number: order.number,
        status: order.status,
        payment_status: order.payment_status,
        payment_method: order.payment_method,
        payment_reference: order.payment_reference,
        paid_at: order.paid_at,
        approved_order_id: order.approved_order_id,
      },
      payment: payment
        ? {
            id: payment.id,
            status: payment.status,
            provider_status: payment.provider_status,
            provider_status_detail: payment.provider_status_detail,
            payment_method: payment.payment_method,
            provider_payment_id: payment.provider_payment_id,
            qr_code: payment.qr_code,
            qr_code_base64: payment.qr_code_base64,
            ticket_url: payment.ticket_url,
            approved_at: payment.approved_at,
            applied_payment_id: payment.applied_payment_id,
            updated_at: payment.updated_at,
          }
        : null,
    });
  } catch (error) {
    const message = error instanceof Error ? error.message : "Nao foi possivel consultar o pagamento.";
    return NextResponse.json({ error: message }, { status: 500 });
  }
}