import { NextResponse } from "next/server";

import { disposicaoDoArquivo } from "@/lib/digitais/nome-do-arquivo";
import { configuracaoDoR2, enderecoParaBaixar } from "@/lib/digitais/r2";
import { arquivoDoAcesso, lerAcessoParaUsar, situacaoDoAcesso } from "@/lib/digitais/servidor/acessos";
import { linkMarcadoValido, TETO_PARA_MARCAR } from "@/lib/digitais/servidor/link-marcado";
import { marcarPdf } from "@/lib/digitais/servidor/marca-no-pdf";
import { createAdminClient } from "@/lib/supabase-admin";

/*
 * O PDF com a marca do comprador. Chega aqui pelo link assinado que o
 * "Baixar" devolve (2 minutos; o download já foi contado lá). PDF que não dá
 * para marcar (protegido por senha, defeituoso, grande ou lento demais) segue
 * sem a marca: a marca roda à parte e nunca prende o servidor da loja.
 */

function texto(mensagem: string, status: number) {
  return new NextResponse(mensagem, { status, headers: { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" } });
}

export async function GET(request: Request, { params }: { params: Promise<{ acessoId: string }> }) {
  const { acessoId } = await params;
  const endereco = new URL(request.url);
  if (!linkMarcadoValido(acessoId, Number(endereco.searchParams.get("ate")), String(endereco.searchParams.get("k") || ""))) {
    return texto("Este link de download venceu. Volte e toque em Baixar de novo.", 403);
  }

  const admin = createAdminClient();
  const acesso = await lerAcessoParaUsar(admin, acessoId);
  if (!acesso) return texto("Acesso não encontrado.", 404);
  const { situacao, motivo } = situacaoDoAcesso(acesso);
  if (situacao !== "liberado") return texto(motivo ?? "Acesso fechado.", 403);
  const arquivo = arquivoDoAcesso(acesso);
  if (!arquivo || arquivo.status !== "pronto") return texto("O arquivo ainda está sendo preparado pela loja.", 409);
  const cfg = configuracaoDoR2();
  if (!cfg) return texto("Os downloads estão indisponíveis agora. Tente em alguns minutos.", 503);
  const direto = enderecoParaBaixar(cfg, arquivo.storage_key, { nome: arquivo.nome, segundos: 900, tipo: arquivo.mime });

  try {
    /* Antes de baixar tudo, o fim do arquivo diz se é um PDF inteiro: senão vai direto, sem esperar. */
    const rabo = await fetch(direto, { cache: "no-store", headers: { range: "bytes=-2048" } });
    if (!rabo.ok) throw new Error(`depósito ${rabo.status}`);
    let bytes: Uint8Array;
    if (rabo.status === 206) {
      const fim = Buffer.from(await rabo.arrayBuffer()).toString("latin1");
      if (!fim.includes("%%EOF") || !fim.includes("startxref")) return NextResponse.redirect(direto);
      const inteiro = await fetch(direto, { cache: "no-store" });
      if (!inteiro.ok) throw new Error(`depósito ${inteiro.status}`);
      bytes = new Uint8Array(await inteiro.arrayBuffer());
    } else {
      bytes = new Uint8Array(await rabo.arrayBuffer());
    }
    if (bytes.byteLength > TETO_PARA_MARCAR) return NextResponse.redirect(direto);

    const [cliente, compra, pedido, perfil] = await Promise.all([
      admin.from("clients").select("name,email").eq("id", acesso.client_id).maybeSingle(),
      acesso.catalog_order_id ? admin.from("catalog_orders").select("number").eq("id", acesso.catalog_order_id).maybeSingle() : Promise.resolve({ data: null }),
      acesso.order_id ? admin.from("orders").select("number").eq("id", acesso.order_id).maybeSingle() : Promise.resolve({ data: null }),
      admin.from("profiles").select("catalog_name,store_name").eq("id", acesso.user_id).maybeSingle(),
    ]);
    const linhaDoCliente = cliente.data as { name?: string | null; email?: string | null } | null;
    const numero = (compra.data as { number?: number | null } | null)?.number ?? (pedido.data as { number?: number | null } | null)?.number ?? null;
    const linhaDoPerfil = perfil.data as { catalog_name?: string | null; store_name?: string | null } | null;
    const nome = String(linhaDoCliente?.name || "").trim() || "o comprador";
    const email = String(linhaDoCliente?.email || "").trim();
    const linha = [
      `Licenciado para ${nome}${email ? ` (${email})` : ""}`,
      numero ? `pedido #${numero}` : "",
      String(linhaDoPerfil?.catalog_name || linhaDoPerfil?.store_name || "").trim(),
      "não compartilhe",
    ]
      .filter(Boolean)
      .join(" · ");
    const marcado = await marcarPdf(bytes, linha);
    /* Não deu para marcar (PDF protegido, defeituoso, lento demais ou muitos ao mesmo tempo): vai como está. */
    if (!marcado) return NextResponse.redirect(direto);
    return new NextResponse(Buffer.from(marcado), {
      headers: {
        "content-type": "application/pdf",
        "content-disposition": disposicaoDoArquivo(arquivo.nome),
        "cache-control": "private, no-store",
        "x-content-type-options": "nosniff",
      },
    });
  } catch (erro) {
    /* Não deu para marcar (PDF protegido, com defeito, depósito lento): vai como está. */
    console.error("[digitais] marca no pdf", erro instanceof Error ? erro.message : erro);
    return NextResponse.redirect(direto);
  }
}