// app/api/staff/cotisations/[id]/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;
  }
}

// PATCH - Mettre à jour une cotisation
export async function PATCH(
  req: NextRequest,
  { params }: { params: { id: string } }
) {
  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 }
      );
    }

    const { id } = params;

    // Vérifier que la cotisation existe
    const { data: existing, error: fetchError } = await supabase
      .from("monthly_contributions")
      .select("*")
      .eq("id", id)
      .single();

    if (fetchError || !existing) {
      return NextResponse.json(
        { error: "Cotisation introuvable" },
        { status: 404 }
      );
    }

    // Récupérer les données du body
    const body = await req.json();
    const updates: any = {};
    
    // Extraire le flag mark_as_notified avant de traiter les autres champs
    const markAsNotified = body.mark_as_notified === true;

    // Permettre la mise à jour de tous les champs (sauf id, org_id pour sécurité)
    const allowedFields = [
      'fund',
      'contrib_type',
      'reference',
      'period_label',
      'due_date',
      'paid_date',
      'status',
      'amount_due',
      'amount_paid',
      'amount_diff',
      'notes'
    ];

    for (const field of allowedFields) {
      if (body[field] !== undefined) {
        updates[field] = body[field];
      }
    }

    // Mettre à jour la cotisation
    const { data: cotisation, error } = await supabase
      .from("monthly_contributions")
      .update(updates)
      .eq("id", id)
      .select()
      .single();

    if (error) {
      console.error("[api/staff/cotisations/[id]] Update error:", error.message);
      return NextResponse.json(
        { error: "Erreur lors de la mise à jour", detail: error.message },
        { status: 500 }
      );
    }

    // Si mark_as_notified est true, créer une entrée dans contribution_notifications
    if (markAsNotified && cotisation) {
      try {
        // Récupérer l'organisation pour avoir l'email
        const { data: orgDetails } = await supabase
          .from("organization_details")
          .select("email_notifs, email_notifs_cc")
          .eq("org_id", existing.org_id)
          .single();

        const emailSentTo = orgDetails?.email_notifs || "notification-manuelle@odentas.com";
        const emailCC = orgDetails?.email_notifs_cc || null;

        // Vérifier si une notification existe déjà pour cette période
        const { data: existingNotif } = await supabase
          .from("contribution_notifications")
          .select("id")
          .eq("org_id", existing.org_id)
          .eq("period_label", cotisation.period_label)
          .maybeSingle();

        // Ne créer la notification que si elle n'existe pas déjà
        if (!existingNotif) {
          const { error: notifError } = await supabase
            .from("contribution_notifications")
            .insert({
              org_id: existing.org_id,
              period_label: cotisation.period_label,
              notified_at: new Date().toISOString(),
              notified_by: session.user.id,
              email_sent_to: emailSentTo,
              email_cc: emailCC,
            });

          if (notifError) {
            console.error("[api/staff/cotisations/[id]] Notification creation error:", notifError);
            // On ne fait pas échouer la requête si la notification échoue
          }
        }
      } catch (notifError) {
        console.error("[api/staff/cotisations/[id]] Error handling notification:", notifError);
        // On continue même si la notification échoue
      }
    }

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

// DELETE - Supprimer une cotisation
export async function DELETE(
  req: NextRequest,
  { params }: { params: { id: string } }
) {
  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 }
      );
    }

    const { id } = params;

    // Vérifier que la cotisation existe
    const { data: existing, error: fetchError } = await supabase
      .from("monthly_contributions")
      .select("id")
      .eq("id", id)
      .single();

    if (fetchError || !existing) {
      return NextResponse.json(
        { error: "Cotisation introuvable" },
        { status: 404 }
      );
    }

    // Supprimer la cotisation
    const { error } = await supabase
      .from("monthly_contributions")
      .delete()
      .eq("id", id);

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

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