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

/*
  Compras do catalogo esperando pagamento.

  A lista "Minhas compras" do portal so mostra pedido ja criado no admin, e o
  pedido do catalogo so vira pedido depois que o pagamento e aprovado. Ou seja:
  quem gerou um Pix ou um boleto e fechou a pagina nao encontrava mais a compra
  em lugar nenhum — teria de refazer tudo. Boleto entao, que leva dias para
  compensar, ficava invisivel o tempo inteiro.

  Esta rota devolve essas compras em aberto com o codigo que ja foi gerado, para
  o cliente terminar de pagar de onde parou.
*/

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

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

    const cookieStore = await cookies();
    const token = cookieStore.get("ks_client_portal")?.value || "";
    if (!token) return NextResponse.json({ ok: true, pedidos: [] });

    const admin = createAdminClient();
    const sessao = await admin.rpc("client_portal_get_session", {
      p_slug: slug,
      p_session_token: token,
    });
    const clientId = (sessao.data as SessionPayload | null)?.client?.id || "";
    if (sessao.error || !clientId) return NextResponse.json({ ok: true, pedidos: [] });

    /* Trinta dias para tras: mais velho que isso o codigo ja expirou em qualquer
       provedor, e a compra vira historico morto. */
    const desdeQuando = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();

    const { data: pedidos } = await admin
      .from("catalog_orders")
      .select("id,number,total,status,payment_status,payment_method,created_at")
      .eq("client_id", clientId)
      .eq("status", "pending")
      .neq("payment_status", "approved")
      .gte("created_at", desdeQuando)
      .order("created_at", { ascending: false })
      .limit(5);

    if (!Array.isArray(pedidos) || pedidos.length === 0) {
      return NextResponse.json({ ok: true, pedidos: [] });
    }

    const { data: pagamentos } = await admin
      .from("catalog_order_payments")
      .select("catalog_order_id,status,payment_method,qr_code,ticket_url,expires_at,created_at")
      .in(
        "catalog_order_id",
        pedidos.map((pedido) => pedido.id)
      )
      .order("created_at", { ascending: false });

    /* Nome e foto dos itens: sem isso o aviso era um numero de pedido e um valor,
       e a pessoa nao lembrava do que se tratava a compra. */
    const { data: itens } = await admin
      .from("catalog_order_items")
      .select("catalog_order_id,title,quantity,product_id,products(image_url)")
      .in(
        "catalog_order_id",
        pedidos.map((pedido) => pedido.id)
      );

    const itensPorPedido = new Map<string, Array<{ titulo: string; quantidade: number; imagem: string | null }>>();
    for (const item of itens || []) {
      const chave = String(item.catalog_order_id || "");
      if (!chave) continue;
      const produto = Array.isArray(item.products) ? item.products[0] : item.products;
      const lista = itensPorPedido.get(chave) || [];
      lista.push({
        titulo: String(item.title || "Item"),
        quantidade: Number(item.quantity || 0),
        imagem: String((produto as { image_url?: string | null } | null)?.image_url || "") || null,
      });
      itensPorPedido.set(chave, lista);
    }

    const ultimoPagamentoPorPedido = new Map<string, Record<string, unknown>>();
    for (const pagamento of pagamentos || []) {
      const chave = String(pagamento.catalog_order_id || "");
      if (!chave || ultimoPagamentoPorPedido.has(chave)) continue;
      ultimoPagamentoPorPedido.set(chave, pagamento as Record<string, unknown>);
    }

    return NextResponse.json({
      ok: true,
      pedidos: pedidos.map((pedido) => {
        const pagamento = ultimoPagamentoPorPedido.get(String(pedido.id)) || null;
        const texto = (valor: unknown) => (String(valor || "").trim() ? String(valor).trim() : null);
        return {
          id: pedido.id,
          numero: pedido.number,
          total: Number(pedido.total || 0),
          criado_em: pedido.created_at,
          metodo: texto(pagamento?.payment_method) || texto(pedido.payment_method),
          situacao: texto(pagamento?.status) || texto(pedido.payment_status) || "pending",
          codigo_pix: texto(pagamento?.qr_code),
          link_boleto: texto(pagamento?.ticket_url),
          expira_em: texto(pagamento?.expires_at),
          itens: itensPorPedido.get(String(pedido.id)) || [],
        };
      }),
    });
  } catch (error) {
    const message = error instanceof Error ? error.message : "Nao foi possivel consultar os pagamentos pendentes.";
    return NextResponse.json({ error: message }, { status: 500 });
  }
}