import { NextRequest, NextResponse } from "next/server";
import { createSbServer } from "@/lib/supabaseServer";
import { sendUniversalEmailV2, EmailConfigV2 } from "@/lib/emailTemplateService";

// Fonction pour formater une date ISO au format DD/MM/AAAA
const formatDate = (isoDate: string) => {
  const date = new Date(isoDate);
  const day = String(date.getDate()).padStart(2, '0');
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const year = date.getFullYear();
  return `${day}/${month}/${year}`;
};

export async function POST(
  request: NextRequest,
  { params }: { params: { id: string } }
) {
  console.log("🚀 [REMIND-EMPLOYER-AVENANT] Début de la requête POST");
  console.log("📋 [REMIND-EMPLOYER-AVENANT] Paramètres reçus:", { 
    avenantId: params.id,
    method: request.method,
    url: request.url 
  });
  
  const sb = createSbServer();

  try {
    console.log("🔐 [REMIND-EMPLOYER-AVENANT] Vérification de l'authentification...");
    
    // Vérification de l'authentification
    const { data: { user }, error: authError } = await sb.auth.getUser();
    if (authError || !user) {
      console.log("❌ [REMIND-EMPLOYER-AVENANT] Échec de l'authentification:", { authError, hasUser: !!user });
      return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
    }
    
    console.log("✅ [REMIND-EMPLOYER-AVENANT] Utilisateur authentifié:", { 
      userId: user.id, 
      email: user.email 
    });

    console.log("👤 [REMIND-EMPLOYER-AVENANT] Vérification des droits staff...");
    
    // Vérification des droits staff
    const { data: staffUser } = await sb
      .from("staff_users")
      .select("is_staff")
      .eq("user_id", user.id)
      .maybeSingle();

    console.log("🔍 [REMIND-EMPLOYER-AVENANT] Résultat vérification staff:", { 
      staffUser, 
      isStaff: staffUser?.is_staff 
    });

    if (!staffUser?.is_staff) {
      console.log("❌ [REMIND-EMPLOYER-AVENANT] Accès refusé - utilisateur non staff");
      return NextResponse.json({ error: "Accès refusé - réservé au staff" }, { status: 403 });
    }

    console.log("📄 [REMIND-EMPLOYER-AVENANT] Récupération de l'avenant:", params.id);
    
    // Récupération de l'avenant avec les données du contrat associé
    const { data: avenant, error: avenantError } = await sb
      .from("avenants")
      .select(`
        id,
        contract_id,
        numero_avenant,
        date_effet,
        type_avenant,
        motif_avenant,
        docuseal_submission_id,
        cddu_contracts!inner(
          id,
          reference,
          contract_number,
          employee_name,
          employee_matricule,
          org_id,
          production_name,
          analytique,
          start_date,
          profession,
          role
        )
      `)
      .eq("id", params.id)
      .single();

    if (avenantError || !avenant) {
      console.log("❌ [REMIND-EMPLOYER-AVENANT] Avenant non trouvé:", { 
        avenantError, 
        avenantId: params.id,
        hasAvenant: !!avenant 
      });
      return NextResponse.json({ error: "Avenant non trouvé" }, { status: 404 });
    }

    const contract = avenant.cddu_contracts as any;

    console.log("✅ [REMIND-EMPLOYER-AVENANT] Avenant trouvé:", { 
      avenantId: avenant.id,
      numeroAvenant: avenant.numero_avenant,
      contractId: avenant.contract_id,
      employee: contract.employee_name,
      docusealId: avenant.docuseal_submission_id,
      orgId: contract.org_id
    });

    // Vérification que l'avenant a un DocuSeal submission ID
    if (!avenant.docuseal_submission_id) {
      console.log("❌ [REMIND-EMPLOYER-AVENANT] Pas d'ID DocuSeal:", { 
        avenantId: avenant.id,
        docusealSubmissionId: avenant.docuseal_submission_id 
      });
      return NextResponse.json({ 
        error: "Avenant sans ID DocuSeal - impossible d'envoyer une relance" 
      }, { status: 400 });
    }

    console.log("🏢 [REMIND-EMPLOYER-AVENANT] Récupération organisation:", contract.org_id);
    
    // Récupération des détails de l'organisation depuis organization_details
    const { data: orgDetails, error: orgError } = await sb
      .from("organization_details")
      .select("email_signature, code_employeur, prenom_signataire")
      .eq("org_id", contract.org_id)
      .single();

    if (orgError || !orgDetails) {
      console.log("❌ [REMIND-EMPLOYER-AVENANT] Organization_details non trouvée:", { 
        orgError, 
        orgId: contract.org_id 
      });
      return NextResponse.json({ 
        error: "Détails de l'organisation non trouvés" 
      }, { status: 404 });
    }

    // Récupération du nom de l'organisation depuis organizations
    const { data: org, error: orgNameError } = await sb
      .from("organizations")
      .select("name")
      .eq("id", contract.org_id)
      .single();

    if (orgNameError || !org) {
      console.log("❌ [REMIND-EMPLOYER-AVENANT] Organisation name non trouvée:", { 
        orgNameError, 
        orgId: contract.org_id 
      });
      return NextResponse.json({ 
        error: "Nom de l'organisation non trouvé" 
      }, { status: 404 });
    }

    console.log("✅ [REMIND-EMPLOYER-AVENANT] Organisation trouvée:", { 
      orgName: org.name,
      email: orgDetails.email_signature ? 'présent' : 'absent',
      code: orgDetails.code_employeur
    });

    if (!orgDetails.email_signature) {
      console.log("❌ [REMIND-EMPLOYER-AVENANT] Pas d'email employeur");
      return NextResponse.json({ 
        error: "Email de l'employeur manquant" 
      }, { status: 400 });
    }

    // Construction du lien de signature vers la page des signatures électroniques
    const signatureLink = 'https://paie.odentas.fr/signatures-electroniques';

    console.log("📧 [REMIND-EMPLOYER-AVENANT] Préparation de l'email...");

    // Préparation de la configuration pour l'email
    const emailConfig: EmailConfigV2 = {
      type: 'signature-request-employer',
      toEmail: orgDetails.email_signature,
      subject: `Relance : Signature de l'avenant ${avenant.numero_avenant || ''} - ${contract.employee_name}`,
      data: {
        firstName: orgDetails.prenom_signataire || 'Madame, Monsieur',
        customMessage: `Vous avez reçu un avenant au contrat de ${contract.employee_name}. Merci de le signer en cliquant sur le bouton ci-dessous.`,
        ctaUrl: signatureLink,
        organizationName: org.name || '',
        code_employeur: orgDetails.code_employeur || '',
        handlerName: 'Renaud BREVIERE-ABRAHAM',
        employeeName: contract.employee_name || 'Salarié',
        documentType: `Avenant ${avenant.numero_avenant || 'N/A'}`,
        contractReference: contract.reference || contract.contract_number || 'N/A',
        companyName: org.name || '',
      }
    };

    console.log("📤 [REMIND-EMPLOYER-AVENANT] Envoi de l'email de relance...");

    // Envoi de l'email
    const messageId = await sendUniversalEmailV2(emailConfig);

    console.log("✅ [REMIND-EMPLOYER-AVENANT] Email envoyé avec succès:", messageId);

    // Mise à jour du timestamp de dernière notification employeur
    const now = new Date().toISOString();
    const { error: updateError } = await sb
      .from("avenants")
      .update({ last_employer_notification_at: now })
      .eq("id", params.id);

    if (updateError) {
      console.warn("⚠️ [REMIND-EMPLOYER-AVENANT] Impossible de mettre à jour last_employer_notification_at:", updateError);
    } else {
      console.log("✅ [REMIND-EMPLOYER-AVENANT] Timestamp de notification enregistré:", now);
    }

    return NextResponse.json({ 
      success: true,
      message: "Relance employeur envoyée avec succès",
      messageId
    });

  } catch (error) {
    console.error("❌ [REMIND-EMPLOYER-AVENANT] Erreur:", error);
    return NextResponse.json({ 
      error: "Erreur lors de l'envoi de la relance" 
    }, { status: 500 });
  }
}
