import { NextRequest, NextResponse } from "next/server";
import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs";
import { cookies } from "next/headers";
import { sendUniversalEmailV2 } from "@/lib/emailTemplateService";

export async function POST(
  request: NextRequest,
  { params }: { params: { id: string } }
) {
  try {
    const supabase = createRouteHandlerClient({ cookies });

    // 1) Authentification
    const {
      data: { session },
      error: sessionError,
    } = await supabase.auth.getSession();
    
    if (sessionError || !session) {
      return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
    }
    
    const user = session.user;

    // 2) Vérifier que l'utilisateur est staff
    const { data: staffData } = await supabase
      .from("staff_users")
      .select("is_staff")
      .eq("user_id", user.id)
      .maybeSingle();
      
    const isStaff = staffData?.is_staff || false;
    
    if (!isStaff) {
      return NextResponse.json(
        { error: "Accès refusé : réservé au staff" },
        { status: 403 }
      );
    }

    // 3) Récupérer le virement de salaire
    const { data: salaryTransfer, error: stError } = await supabase
      .from("salary_transfers")
      .select("*")
      .eq("id", params.id)
      .single();

    if (stError || !salaryTransfer) {
      return NextResponse.json(
        { error: "Virement de salaire introuvable" },
        { status: 404 }
      );
    }

    // 4) Vérifier que le virement a bien été reçu (client_wire_received_at doit être défini)
    if (!salaryTransfer.client_wire_received_at) {
      return NextResponse.json(
        { error: "Le virement client n'a pas encore été reçu. Veuillez d'abord confirmer la réception du virement." },
        { status: 400 }
      );
    }

    // 5) Vérifier que les salaires ont bien été payés
    if (!salaryTransfer.salaires_payes) {
      return NextResponse.json(
        { error: "Les salaires n'ont pas encore été marqués comme payés. Veuillez d'abord marquer les salaires comme payés." },
        { status: 400 }
      );
    }

    // 6) Récupérer l'organisation et ses détails
    const { data: organization, error: orgError } = await supabase
      .from("organizations")
      .select("*")
      .eq("id", salaryTransfer.org_id)
      .single();

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

    const { data: orgDetails, error: orgDetailsError } = await supabase
      .from("organization_details")
      .select("*")
      .eq("org_id", salaryTransfer.org_id)
      .single();

    if (orgDetailsError || !orgDetails) {
      return NextResponse.json(
        { error: "Détails de l'organisation introuvables" },
        { status: 404 }
      );
    }

    // 7) Vérifier les emails de notification
    const cleanEmail = (email: string | null | undefined): string | undefined => {
      if (!email) return undefined;
      const cleaned = email.replace(/\s+/g, '').trim();
      if (cleaned.length === 0) return undefined;
      return cleaned;
    };

    const isValidEmail = (email: string | null | undefined): boolean => {
      if (!email) return false;
      const cleaned = cleanEmail(email);
      if (!cleaned) return false;
      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
      return emailRegex.test(cleaned);
    };

    const emailNotifs = cleanEmail(orgDetails.email_notifs);
    const emailNotifsCC = cleanEmail(orgDetails.email_notifs_cc);

    console.log("[notify-payment-sent] Email brut:", JSON.stringify(orgDetails.email_notifs));
    console.log("[notify-payment-sent] Email nettoyé:", emailNotifs);
    console.log("[notify-payment-sent] CC brut:", JSON.stringify(orgDetails.email_notifs_cc));
    console.log("[notify-payment-sent] CC nettoyé:", emailNotifsCC);

    if (!emailNotifs || !isValidEmail(emailNotifs)) {
      return NextResponse.json(
        { error: "Email de notification non configuré ou invalide pour cette organisation" },
        { status: 400 }
      );
    }

    // Valider l'email CC s'il existe
    const validatedCcEmail = (emailNotifsCC && isValidEmail(emailNotifsCC)) ? emailNotifsCC : undefined;

    // 8) Récupérer le prénom du contact depuis organization_details
    const firstName = orgDetails.prenom_contact || "Cher client";

    // 9) Formater les données pour l'email
    const formatDate = (dateStr: string | null) => {
      if (!dateStr) return "—";
      const date = new Date(dateStr);
      return date.toLocaleDateString("fr-FR", {
        day: "2-digit",
        month: "long",
        year: "numeric"
      });
    };

    const formatAmount = (amount: number | null) => {
      if (amount === null || amount === undefined) return "0,00 €";
      return amount.toLocaleString("fr-FR", {
        minimumFractionDigits: 2,
        maximumFractionDigits: 2
      }) + " €";
    };

    // Date de paiement = date actuelle ou client_wire_received_at
    const paymentDate = formatDate(salaryTransfer.client_wire_received_at);

    // 10) Préparer les données du template
    const templateData = {
      firstName,
      organizationName: organization.name,
      employerCode: orgDetails.code_employeur || "UNKNOWN",
      handlerName: "Renaud BREVIERE-ABRAHAM",
      totalAmount: formatAmount(salaryTransfer.total_net),
      periodLabel: salaryTransfer.period_label || formatDate(salaryTransfer.period_month),
      paymentDate,
    };

    // 11) Envoyer l'email via le système universel V2
    console.log("[notify-payment-sent] Envoi de l'email à:", emailNotifs);
    console.log("[notify-payment-sent] CC:", validatedCcEmail || "Aucun");
    
    await sendUniversalEmailV2({
      type: 'salary-transfer-payment-confirmation',
      toEmail: emailNotifs!,
      ccEmail: validatedCcEmail,
      data: templateData
    });

    // 12) Mettre à jour la table pour tracker l'envoi de cette notification
    const { error: updateError } = await supabase
      .from("salary_transfers")
      .update({
        payment_notification_sent: true,
        payment_notification_sent_at: new Date().toISOString(),
        updated_at: new Date().toISOString()
      })
      .eq("id", params.id);

    if (updateError) {
      console.error("[notify-payment-sent] Erreur lors de la mise à jour:", updateError);
      // On ne retourne pas d'erreur car l'email a été envoyé
    }

    return NextResponse.json({
      success: true,
      message: "Notification de paiement envoyée avec succès",
      emailSentTo: emailNotifs,
      emailCc: validatedCcEmail || null
    });

  } catch (error: any) {
    console.error("[notify-payment-sent] Erreur:", error);
    return NextResponse.json(
      { error: "Erreur lors de l'envoi de la notification", details: error.message },
      { status: 500 }
    );
  }
}
