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

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

export async function POST(
  _req: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  // Autenticar usuário via Supabase Auth
  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 });
  }

  // Carregar contexto da empresa e validar permissão financeira
  const ctx = await getCompanyContext(supabase, user);
  if (!canCompany(ctx, user.id, "financial.payables.settle")) {
    return NextResponse.json({ error: "Sem permissão." }, { status: 403 });
  }

  // Validar parâmetro de rota
  const resolvedParams = await params;
  const accountId = typeof resolvedParams?.id === "string" ? resolvedParams.id : "";
  if (!accountId) {
    return NextResponse.json({ error: "Id inválido." }, { status: 400 });
  }

  // Buscar a conta a pagar e validar empresa e status
  const { data: account, error: accountError } = await supabase
    .from("accounts_payable")
    .select("id,company_id,status,bank_account_id,description,amount")
    .eq("id", accountId)
    .eq("company_id", ctx.companyId)
    .maybeSingle();

  if (accountError) {
    return NextResponse.json({ error: "Falha ao buscar conta a pagar." }, { status: 500 });
  }

  if (!account) {
    return NextResponse.json({ error: "Conta a pagar não encontrada." }, { status: 404 });
  }

  if (account.status !== "PENDING") {
    return NextResponse.json({ error: "Conta a pagar não está pendente." }, { status: 400 });
  }

  // Executar atualização e criação de lançamento mantendo consistência
  const today = getTodayIsoDate();
  let updated = false;

  try {
    // Atualizar a conta para PAID e definir payment_date
    const { data: updatedAccount, error: updateError } = await supabase
      .from("accounts_payable")
      .update({
        status: "PAID",
        payment_date: today,
      })
      .eq("id", accountId)
      .eq("company_id", ctx.companyId)
      .eq("status", "PENDING")
      .select("id,company_id,status,payment_date,bank_account_id,description,amount")
      .maybeSingle();

    if (updateError) {
      return NextResponse.json({ error: "Falha ao atualizar conta a pagar." }, { status: 500 });
    }

    if (!updatedAccount) {
      return NextResponse.json({ error: "Pagamento já foi processado." }, { status: 409 });
    }

    updated = true;

    // Criar lançamento no fluxo de caixa
    const { error: cashFlowError } = await supabase.from("cash_flow").insert({
      company_id: updatedAccount.company_id,
      bank_account_id: updatedAccount.bank_account_id,
      type: "OUT",
      origin: "PAGAR",
      reference_id: updatedAccount.id,
      description: `Pagamento: ${updatedAccount.description ?? ""}`.trim(),
      amount: updatedAccount.amount,
      date: today,
    });

    if (cashFlowError) {
      throw cashFlowError;
    }

    // Resposta de sucesso
    return NextResponse.json({
      ok: true,
      account: {
        id: updatedAccount.id,
        status: "PAID",
        payment_date: updatedAccount.payment_date,
      },
    });
  } catch {
    // Rollback manual em caso de falha ao inserir cash_flow
    if (updated) {
      await supabase
        .from("accounts_payable")
        .update({ status: "PENDING", payment_date: null })
        .eq("id", accountId)
        .eq("company_id", ctx.companyId);
    }

    return NextResponse.json({ error: "Falha ao pagar conta a pagar." }, { status: 500 });
  }
}