import { NextResponse } from "next/server";
import { createClient } from "@/utils/supabase/server";
import { gerarDescricaoProduto, getIAProvider } from "@/lib/iaService";
import { canCompany, getCompanyContext } from "@/lib/company-context";

const DEFAULT_MAX_TENTATIVAS_DIA = 20;

function getTodayIsoDate() {
  return new Date().toISOString().slice(0, 10);
}

function getMaxTentativasDia() {
  const raw = process.env.IA_MAX_TENTATIVAS_DIA;
  const n = raw ? Number(raw) : DEFAULT_MAX_TENTATIVAS_DIA;
  if (!Number.isFinite(n) || n <= 0) return DEFAULT_MAX_TENTATIVAS_DIA;
  return Math.floor(n);
}

export async function POST(req: Request) {
  try {
    const supabase = await createClient();
    const {
      data: { user },
      error: userError,
    } = await supabase.auth.getUser();

    if (userError || !user) {
      return NextResponse.json({ error: "Não autenticado." }, { status: 401 });
    }

    const ctx = await getCompanyContext(supabase, user);
    const writeUserId = ctx.ownerId ?? ctx.companyId;
    if (!canCompany(ctx, user.id, "ia.write")) {
      return NextResponse.json({ error: "Sem permissão." }, { status: 403 });
    }

    const body = (await req.json().catch(() => null)) as
      | { nome?: unknown; categoria?: unknown; caracteristicas?: unknown }
      | null;

    const nome =
      typeof body?.nome === "string" ? body.nome.trim() : "";
    const categoria =
      typeof body?.categoria === "string" ? body.categoria.trim() : "";
    const caracteristicas =
      typeof body?.caracteristicas === "string" ? body.caracteristicas.trim() : "";

    if (!nome) {
      return NextResponse.json(
        { error: "Campo 'nome' é obrigatório." },
        { status: 400 }
      );
    }

    const hoje = getTodayIsoDate();
    const maxTentativasDia = getMaxTentativasDia();

    const { data: consumoAtual, error: consumoSelectError } = await supabase
      .from("ia_consumo")
      .select("tentativas")
      .eq("user_id", writeUserId)
      .eq("data", hoje)
      .maybeSingle();

    if (consumoSelectError) {
      return NextResponse.json(
        { error: "Falha ao verificar consumo de IA." },
        { status: 500 }
      );
    }

    const tentativasAtuais = consumoAtual?.tentativas ?? 0;
    if (tentativasAtuais >= maxTentativasDia) {
      return NextResponse.json(
        { error: "Limite diário de tentativas de IA atingido." },
        { status: 429 }
      );
    }

    const { error: consumoWriteError } =
      tentativasAtuais === 0
        ? await supabase.from("ia_consumo").insert({
            user_id: writeUserId,
            data: hoje,
            tentativas: 1,
          })
        : await supabase
            .from("ia_consumo")
            .update({ tentativas: tentativasAtuais + 1 })
            .eq("user_id", writeUserId)
            .eq("data", hoje);

    if (consumoWriteError) {
      return NextResponse.json(
        { error: "Falha ao registrar consumo de IA." },
        { status: 500 }
      );
    }

    const descricao = await gerarDescricaoProduto(
      nome,
      categoria,
      caracteristicas
    );

    return NextResponse.json({ descricao });
  } catch (err: unknown) {
    console.error("Erro em /api/ia/gerar-descricao:", err);

    const status =
      typeof (err as { status?: unknown })?.status === "number"
        ? ((err as { status?: number }).status ?? undefined)
        : undefined;
    const message = err instanceof Error ? err.message : "";

    if (message.includes("GEMINI_API_KEY")) {
      return NextResponse.json(
        { error: "GEMINI_API_KEY não configurada no backend." },
        { status: 500 }
      );
    }

    if (message.includes("OPENAI_API_KEY")) {
      return NextResponse.json(
        { error: "OPENAI_API_KEY não configurada no backend." },
        { status: 500 }
      );
    }

    if (status === 401 || status === 403) {
      return NextResponse.json(
        { error: "Chave do provedor de IA inválida ou sem permissão." },
        { status: 502 }
      );
    }

    if (
      status === 429 ||
      message.toLowerCase().includes("resource_exhausted") ||
      message.includes("429")
    ) {
      return NextResponse.json(
        { error: "Limite do provedor de IA atingido. Tente novamente mais tarde." },
        { status: 429 }
      );
    }

    if (message.toLowerCase().includes("not found") || message.includes("404")) {
      const provider = getIAProvider();
      return NextResponse.json(
        { error: `Modelo do provedor de IA não encontrado (${provider}).` },
        { status: 502 }
      );
    }

    return NextResponse.json({ error: "Falha ao gerar descrição." }, { status: 500 });
  }
}