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 selfOnly = searchParams.get("self_only") === "1";

  const effectiveSellerId = selfOnly || (!canRead && canReadSelf) ? user.id : requestedSellerId;

  let statementQuery = supabase
    .from("commission_statement_items")
    .select("id,period_id,seller_user_id,event_id,statement_type,amount,included_in_payout,created_at")
    .eq("company_id", ctx.companyId)
    .order("created_at", { ascending: false })
    .limit(300);

  if (effectiveSellerId) {
    statementQuery = statementQuery.eq("seller_user_id", effectiveSellerId);
  }

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

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

  const statementItems = items ?? [];
  const periodIds = Array.from(new Set(statementItems.map((item) => item.period_id).filter(Boolean)));
  const eventIds = Array.from(new Set(statementItems.map((item) => item.event_id).filter(Boolean)));
  const sellerIds = Array.from(new Set(statementItems.map((item) => item.seller_user_id).filter(Boolean)));

  const [{ data: periods }, { data: events }, { data: sellers }] = await Promise.all([
    periodIds.length
      ? supabase.from("commission_periods").select("id,period_label,start_date,end_date,status").in("id", periodIds)
      : Promise.resolve({ data: [] }),
    eventIds.length
      ? supabase
          .from("commission_events")
          .select("id,order_id,payment_id,source_date,status,commission_percent,commission_amount,notes")
          .in("id", eventIds)
      : Promise.resolve({ data: [] }),
    sellerIds.length
      ? supabase.from("company_users").select("user_id,email,role").eq("company_id", ctx.companyId).in("user_id", sellerIds)
      : Promise.resolve({ data: [] }),
  ]);

  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 eventMap = new Map(
    ((events ?? []) as Array<{
      id: string;
      order_id: string | null;
      payment_id: string | null;
      source_date: string;
      status: string;
      commission_percent: number | null;
      commission_amount: number;
      notes: string | null;
    }>).map((event) => [event.id, event])
  );
  const sellerMap = new Map(
    ((sellers ?? []) as Array<{ user_id: string; email: string; role: string }>).map((seller) => [seller.user_id, seller])
  );

  const totalAmount = statementItems.reduce((sum, item) => sum + Number(item.amount || 0), 0);
  const payoutEligibleAmount = statementItems
    .filter((item) => item.included_in_payout)
    .reduce((sum, item) => sum + Number(item.amount || 0), 0);

  return NextResponse.json({
    summary: {
      total_amount: totalAmount,
      payout_eligible_amount: payoutEligibleAmount,
      item_count: statementItems.length,
    },
    items: statementItems.map((item) => ({
      ...item,
      period: periodMap.get(item.period_id) || null,
      event: item.event_id ? eventMap.get(item.event_id) || null : null,
      seller_email: sellerMap.get(item.seller_user_id)?.email || null,
      seller_role: sellerMap.get(item.seller_user_id)?.role || null,
    })),
  });
}