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

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

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

  const ctx = await getCompanyContext(supabase, user);
  const canRead = canCompany(ctx, user.id, "commissions.read");
  const canReadSelf = canCompany(ctx, user.id, "commissions.self");
  if (!canRead && !canReadSelf) {
    return NextResponse.json({ error: "Sem permissão." }, { status: 403 });
  }

  const { searchParams } = new URL(req.url);
  const requestedSellerId = searchParams.get("seller_user_id")?.trim() || "";
  const requestedPeriodId = searchParams.get("period_id")?.trim() || "";
  const requestedStatus = searchParams.get("status")?.trim() || "";
  const selfOnly = searchParams.get("self_only") === "1";

  let query = supabase
    .from("commission_payouts")
    .select(
      "id,period_id,seller_user_id,gross_amount,adjustments_amount,net_amount,status,accounts_payable_id,employee_payout_profile_snapshot,created_at,updated_at"
    )
    .eq("company_id", ctx.companyId)
    .order("created_at", { ascending: false })
    .limit(200);

  if (selfOnly || (!canRead && canReadSelf)) {
    query = query.eq("seller_user_id", user.id);
  } else if (requestedSellerId) {
    query = query.eq("seller_user_id", requestedSellerId);
  }

  if (requestedPeriodId) {
    query = query.eq("period_id", requestedPeriodId);
  }

  if (requestedStatus) {
    query = query.eq("status", requestedStatus);
  }

  const { data: payouts, error: payoutsError } = await query;
  if (payoutsError) {
    return NextResponse.json({ error: "Falha ao listar payouts de comissão." }, { status: 500 });
  }

  const payoutList = payouts ?? [];
  const sellerIds = Array.from(new Set(payoutList.map((item) => item.seller_user_id).filter(Boolean)));
  const periodIds = Array.from(new Set(payoutList.map((item) => item.period_id).filter(Boolean)));
  const payableIds = Array.from(new Set(payoutList.map((item) => item.accounts_payable_id).filter(Boolean)));

  const [{ data: sellers }, { data: periods }, { data: payables }] = await Promise.all([
    sellerIds.length
      ? supabase
          .from("company_users")
          .select("user_id,email,role")
          .eq("company_id", ctx.companyId)
          .in("user_id", sellerIds)
      : Promise.resolve({ data: [] }),
    periodIds.length
      ? supabase
          .from("commission_periods")
          .select("id,period_label,start_date,end_date,status")
          .in("id", periodIds)
      : Promise.resolve({ data: [] }),
    payableIds.length
      ? supabase
          .from("accounts_payable")
          .select("id,description,due_date,payment_date,status,amount")
          .in("id", payableIds)
      : Promise.resolve({ data: [] }),
  ]);

  const sellerMap = new Map(
    ((sellers ?? []) as Array<{ user_id: string; email: string; role: string }>).map((seller) => [seller.user_id, seller])
  );
  const periodMap = new Map(
    ((periods ?? []) as Array<{ id: string; period_label: string; start_date: string; end_date: string; status: string }>).map(
      (period) => [period.id, period]
    )
  );
  const payableMap = new Map(
    ((payables ?? []) as Array<{ id: string; description: string; due_date: string | null; payment_date: string | null; status: string; amount: number }>).map(
      (payable) => [payable.id, payable]
    )
  );

  return NextResponse.json({
    payouts: payoutList.map((payout) => ({
      ...payout,
      seller_email: sellerMap.get(payout.seller_user_id)?.email || null,
      seller_role: sellerMap.get(payout.seller_user_id)?.role || null,
      period: periodMap.get(payout.period_id) || null,
      payable: payout.accounts_payable_id ? payableMap.get(payout.accounts_payable_id) || null : null,
    })),
  });
}