// app/api/staff/cotisations/route.ts
import { NextResponse, NextRequest } from "next/server";
import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs";
import { cookies } from "next/headers";

export const dynamic = "force-dynamic";
export const revalidate = 0;
export const runtime = "nodejs";

// Fonction helper pour vérifier si l'utilisateur est staff
async function isStaffUser(supabase: any, userId: string): Promise<boolean> {
  try {
    const { data: staffRow } = await supabase
      .from("staff_users")
      .select("is_staff")
      .eq("user_id", userId)
      .maybeSingle();
    return !!staffRow?.is_staff;
  } catch {
    return false;
  }
}

// GET - Lister toutes les cotisations (avec filtres optionnels)
export async function GET(req: NextRequest) {
  try {
    const supabase = createRouteHandlerClient({ cookies });
    const { data: { session } } = await supabase.auth.getSession();
    
    if (!session) {
      return NextResponse.json({ error: "unauthorized" }, { status: 401 });
    }

    // Vérifier que l'utilisateur est staff
    const isStaff = await isStaffUser(supabase, session.user.id);
    if (!isStaff) {
      return NextResponse.json(
        { error: "forbidden", message: "Staff access required" },
        { status: 403 }
      );
    }

    // Paramètres de filtrage
    const url = new URL(req.url);
    const orgId = url.searchParams.get("org_id");
    const fund = url.searchParams.get("fund");
    const status = url.searchParams.get("status");
    const year = url.searchParams.get("year");

    // Construire la requête
    let query = supabase
      .from("monthly_contributions")
      .select(`
        *,
        organizations!monthly_contributions_org_id_fkey (
          id,
          name,
          structure_api
        )
      `)
      .order("due_date", { ascending: false });

    // Filtrer par organisation si spécifié
    if (orgId) {
      query = query.eq("org_id", orgId);
    }

    // Filtrer par caisse si spécifié
    if (fund) {
      query = query.eq("fund", fund);
    }

    // Filtrer par statut si spécifié
    if (status) {
      query = query.eq("status", status);
    }
    
    // Filtrer par année si spécifié (via period_label qui contient l'année)
    if (year) {
      query = query.ilike("period_label", `%${year}%`);
    }

    const { data: cotisations, error } = await query;

    if (error) {
      console.error("[api/staff/cotisations] Supabase error:", error.message);
      return NextResponse.json(
        { error: "supabase_error", detail: error.message },
        { status: 500 }
      );
    }

    return NextResponse.json({ cotisations: cotisations || [] });
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error);
    return NextResponse.json(
      { error: "internal_server_error", message },
      { status: 500 }
    );
  }
}

// POST - Créer une nouvelle cotisation
export async function POST(req: NextRequest) {
  try {
    const supabase = createRouteHandlerClient({ cookies });
    const { data: { session } } = await supabase.auth.getSession();
    
    if (!session) {
      return NextResponse.json({ error: "unauthorized" }, { status: 401 });
    }

    // Vérifier que l'utilisateur est staff
    const isStaff = await isStaffUser(supabase, session.user.id);
    if (!isStaff) {
      return NextResponse.json(
        { error: "forbidden", message: "Staff access required" },
        { status: 403 }
      );
    }

    // Récupérer les données du body
    const body = await req.json();
    const { 
      org_id, 
      fund,
      contrib_type,
      reference,
      period_label,
      due_date,
      paid_date,
      status,
      amount_due,
      amount_paid,
      amount_diff,
      notes
    } = body;

    // Validation
    if (!org_id) {
      return NextResponse.json(
        { error: "L'organisation est requise" },
        { status: 400 }
      );
    }

    if (!fund) {
      return NextResponse.json(
        { error: "La caisse est requise" },
        { status: 400 }
      );
    }

    if (!period_label) {
      return NextResponse.json(
        { error: "Le libellé de période est requis" },
        { status: 400 }
      );
    }

    // Vérifier que l'organisation existe
    const { data: orgExists, error: orgError } = await supabase
      .from("organizations")
      .select("id")
      .eq("id", org_id)
      .single();

    if (orgError || !orgExists) {
      return NextResponse.json(
        { error: "Organisation introuvable" },
        { status: 400 }
      );
    }

    // Créer la cotisation
    const { data: cotisation, error } = await supabase
      .from("monthly_contributions")
      .insert({
        org_id,
        fund,
        contrib_type: contrib_type || null,
        reference: reference || null,
        period_label,
        due_date: due_date || null,
        paid_date: paid_date || null,
        status: status || "À payer",
        amount_due: amount_due || 0,
        amount_paid: amount_paid || null,
        amount_diff: amount_diff || null,
        notes: notes || null,
      })
      .select()
      .single();

    if (error) {
      console.error("[api/staff/cotisations] Insert error:", error.message);
      return NextResponse.json(
        { error: "Erreur lors de la création", detail: error.message },
        { status: 500 }
      );
    }

    return NextResponse.json({ cotisation }, { status: 201 });
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error);
    return NextResponse.json(
      { error: "internal_server_error", message },
      { status: 500 }
    );
  }
}
