import { NextRequest, NextResponse } from "next/server";
import { createSbServiceRole } from "@/lib/supabaseServer";
import { sendUniversalEmailV2, EmailDataV2 } from "@/lib/emailTemplateService";
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
import { checkAndMarkWebhookProcessed } from "@/lib/webhookDeduplication";

const s3Client = new S3Client({
  region: process.env.AWS_REGION || "eu-west-3",
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID || "",
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || "",
  },
});

const BUCKET = (process.env.AWS_S3_BUCKET || "odentas-docs").trim();

export const dynamic = "force-dynamic";

/**
 * Webhook appelé quand le SALARIÉ signe un avenant
 * Télécharge le PDF signé, l'uploade sur S3, et met à jour le statut
 * 
 * Flux :
 * 1. Employeur signe → Lambda postDocuSealAvenantSalarie → /api/webhooks/docuseal-amendment
 * 2. Salarié signe → DocuSeal webhook → Cette route
 * 3. Téléchargement PDF + Upload S3 + Mise à jour statut
 */
export async function POST(request: NextRequest) {
  console.log("🎉 [WEBHOOK AVENANT COMPLETED] Début du traitement");

  try {
    const body = await request.json();
    console.log("📦 [WEBHOOK AVENANT COMPLETED] Body reçu:", JSON.stringify(body, null, 2));

    // Extraire les données du webhook DocuSeal
    const eventType = body.event_type;
    const role = body.data?.role;
    const templateName = body.data?.template?.name;
    const submissionId = body.data?.submission?.id;
    const documentUrl = body.data?.documents?.[0]?.url;

    console.log("🔍 [WEBHOOK AVENANT COMPLETED] Event type:", eventType);
    console.log("🔍 [WEBHOOK AVENANT COMPLETED] Role:", role);
    console.log("🔍 [WEBHOOK AVENANT COMPLETED] Template name:", templateName);
    console.log("🔍 [WEBHOOK AVENANT COMPLETED] Submission ID:", submissionId);
    console.log("🔍 [WEBHOOK AVENANT COMPLETED] Document URL:", documentUrl);

    // Vérifier que c'est bien un événement de complétion
    if (eventType !== "form.completed") {
      console.log("ℹ️ [WEBHOOK AVENANT COMPLETED] Event type non géré (attendu: form.completed):", eventType);
      return NextResponse.json({ message: "Event type ignoré - attendu form.completed" }, { status: 200 });
    }

    // 🔍 FILTRAGE 1 : Vérifier que c'est un avenant (template commence par "AVENANT")
    if (!templateName || !templateName.toUpperCase().startsWith("AVENANT")) {
      console.log("ℹ️ [WEBHOOK AVENANT COMPLETED] Ce n'est pas un avenant, ignoré");
      return NextResponse.json({ message: "Non-avenant ignoré" }, { status: 200 });
    }

    // 🔍 FILTRAGE 2 : Vérifier que c'est bien le SALARIÉ qui a signé
    if (role !== "Salarié") {
      console.log("ℹ️ [WEBHOOK AVENANT COMPLETED] Signature employeur ignorée (attendu: Salarié)");
      return NextResponse.json({ message: "Signature employeur ignorée" }, { status: 200 });
    }

    console.log("✅ [WEBHOOK AVENANT COMPLETED] C'est bien un avenant signé par le salarié !");

    if (!submissionId) {
      console.error("❌ [WEBHOOK AVENANT COMPLETED] submission_id manquant");
      return NextResponse.json(
        { error: "submission_id requis" },
        { status: 400 }
      );
    }

    // 🔒 DÉDUPLICATION : Vérifier si ce webhook a déjà été traité
    const isNew = await checkAndMarkWebhookProcessed(
      submissionId,
      "avenant_employee_signed",
      undefined,
      body
    );

    if (!isNew) {
      console.log("⚠️ [WEBHOOK AVENANT COMPLETED] Webhook déjà traité, ignoré pour éviter doublon");
      return NextResponse.json(
        { message: "Webhook déjà traité" },
        { status: 200 }
      );
    }

    console.log("✅ [WEBHOOK AVENANT COMPLETED] Nouveau webhook, traitement...");

    if (!documentUrl) {
      console.error("❌ [WEBHOOK AVENANT COMPLETED] document URL manquante");
      return NextResponse.json(
        { error: "document URL requise" },
        { status: 400 }
      );
    }

    const supabase = createSbServiceRole();

    // 1. Récupérer l'avenant depuis Supabase via le docuseal_submission_id
    console.log("🔍 [WEBHOOK AVENANT COMPLETED] Recherche de l'avenant...");
    const { data: avenant, error: avenantError } = await supabase
      .from("avenants")
      .select(`
        *,
        cddu_contracts (
          *,
          salaries (
            prenom,
            nom,
            adresse_mail
          ),
          organizations (
            id,
            name
          )
        )
      `)
      .eq("docuseal_submission_id", submissionId)
      .maybeSingle();

    if (avenantError || !avenant) {
      console.error("❌ [WEBHOOK AVENANT COMPLETED] Avenant non trouvé:", avenantError);
      return NextResponse.json(
        { error: "Avenant non trouvé", details: avenantError?.message },
        { status: 404 }
      );
    }

    console.log("✅ [WEBHOOK AVENANT COMPLETED] Avenant trouvé:", {
      id: avenant.id,
      numero: avenant.numero_avenant,
      contract_id: avenant.contract_id,
    });

    // 2. Télécharger le PDF signé depuis DocuSeal
    console.log("⬇️ [WEBHOOK AVENANT COMPLETED] Téléchargement du PDF signé...");
    let pdfBuffer: Buffer;
    try {
      const pdfResponse = await fetch(documentUrl);
      if (!pdfResponse.ok) {
        throw new Error(`Erreur téléchargement PDF: ${pdfResponse.status}`);
      }
      const arrayBuffer = await pdfResponse.arrayBuffer();
      pdfBuffer = Buffer.from(arrayBuffer);
      console.log("✅ [WEBHOOK AVENANT COMPLETED] PDF téléchargé:", pdfBuffer.length, "bytes");
    } catch (error: any) {
      console.error("❌ [WEBHOOK AVENANT COMPLETED] Erreur téléchargement PDF:", error);
      return NextResponse.json(
        { error: "Erreur téléchargement PDF", details: error.message },
        { status: 500 }
      );
    }

    // 3. Uploader le PDF sur S3
    console.log("⬆️ [WEBHOOK AVENANT COMPLETED] Upload du PDF sur S3...");
    const s3Key = `avenants/${avenant.numero_avenant}_signed_${Date.now()}.pdf`;
    try {
      const uploadCommand = new PutObjectCommand({
        Bucket: BUCKET,
        Key: s3Key,
        Body: pdfBuffer,
        ContentType: "application/pdf",
      });
      await s3Client.send(uploadCommand);
      console.log("✅ [WEBHOOK AVENANT COMPLETED] PDF uploadé sur S3:", s3Key);
    } catch (error: any) {
      console.error("❌ [WEBHOOK AVENANT COMPLETED] Erreur upload S3:", error);
      return NextResponse.json(
        { error: "Erreur upload S3", details: error.message },
        { status: 500 }
      );
    }

    // 4. Mettre à jour le statut de l'avenant
    console.log("🔄 [WEBHOOK AVENANT COMPLETED] Mise à jour du statut...");
    const { error: updateError } = await supabase
      .from("avenants")
      .update({
        signature_status: "signed",
        statut: "signed",
        signed_pdf_s3_key: s3Key, // Nouveau champ pour le PDF signé
      })
      .eq("id", avenant.id);

    if (updateError) {
      console.error("❌ [WEBHOOK AVENANT COMPLETED] Erreur mise à jour avenant:", updateError);
    } else {
      console.log("✅ [WEBHOOK AVENANT COMPLETED] Statut avenant mis à jour: signed + PDF signé S3");
    }

    // 5. Mettre à jour le contrat pour marquer l'avenant comme signé
    if (avenant.contract_id) {
      console.log("🔄 [WEBHOOK AVENANT COMPLETED] Mise à jour du contrat...");
      const { error: contractUpdateError } = await supabase
        .from("cddu_contracts")
        .update({
          avenant_signe: true,
          avenant_signe_date: new Date().toISOString(),
        })
        .eq("id", avenant.contract_id);

      if (contractUpdateError) {
        console.error("❌ [WEBHOOK AVENANT COMPLETED] Erreur mise à jour contrat:", contractUpdateError);
      } else {
        console.log("✅ [WEBHOOK AVENANT COMPLETED] Contrat mis à jour: avenant_signe = true");
      }
    }

    // 6. Préparer les données pour les emails de confirmation
    const contract = avenant.cddu_contracts;
    const salarie = contract?.salaries;
    const organization = contract?.organizations;

    if (!contract || !salarie || !organization) {
      console.error("❌ [WEBHOOK AVENANT COMPLETED] Données manquantes:", {
        hasContract: !!contract,
        hasSalarie: !!salarie,
        hasOrganization: !!organization,
      });
      return NextResponse.json(
        { error: "Données du contrat/salarié/organisation manquantes" },
        { status: 400 }
      );
    }

    // Formater la date
    const formatDate = (dateStr?: string | null) => {
      if (!dateStr) return "-";
      try {
        const parts = dateStr.split("-");
        if (parts.length === 3) {
          const [y, m, d] = parts;
          return `${d}/${m}/${y}`;
        }
        return dateStr;
      } catch {
        return dateStr;
      }
    };

    const startDate = formatDate(contract.start_date);
    const employeeEmail = salarie.adresse_mail;

    // Récupérer les infos employeur depuis organization_details
    let employerCode = "Non spécifié";
    let employerFirstName = "Employeur";
    let employerEmail = "hello@odentas.fr";
    
    if (organization.id) {
      const { data: orgDetails } = await supabase
        .from("organization_details")
        .select("code_employeur, prenom_signataire, email_signature")
        .eq("org_id", organization.id)
        .maybeSingle();
      
      if (orgDetails) {
        if (orgDetails.code_employeur) {
          employerCode = orgDetails.code_employeur;
        }
        if (orgDetails.prenom_signataire) {
          employerFirstName = orgDetails.prenom_signataire;
        }
        if (orgDetails.email_signature) {
          employerEmail = orgDetails.email_signature;
        }
      }
    }

    // 4. Envoyer l'email à l'EMPLOYEUR
    console.log("📧 [WEBHOOK AVENANT COMPLETED] Envoi email employeur...");
    
    const employerEmailData: EmailDataV2 = {
      firstName: employerFirstName,
      organizationName: organization.name || "Votre structure",
      employerCode: employerCode,
      handlerName: "Renaud BREVIERE-ABRAHAM",
      contractReference: contract.contract_number || "Non spécifié",
      startDate: startDate,
      profession: contract.profession || "Non spécifié",
      productionName: contract.analytique || contract.production_name || "Non spécifié",
      ctaUrl: "https://paie.odentas.fr/",
      ctaText: "Accès à l'Espace Paie",
      numeroAvenant: avenant.numero_avenant,
      employeeName: `${salarie.prenom} ${salarie.nom}`,
      matricule: contract.matricule || contract.employee_matricule || "Non spécifié",
      contractType: "CDDU (contrat intermittent)",
    };

    try {
      const employerMessageId = await sendUniversalEmailV2({
        type: "amendment-completed-employer",
        toEmail: employerEmail,
        data: employerEmailData,
      });
      console.log("✅ [WEBHOOK AVENANT COMPLETED] Email employeur envoyé:", employerMessageId);
    } catch (emailError: any) {
      console.error("❌ [WEBHOOK AVENANT COMPLETED] Erreur email employeur:", emailError);
    }

    // 5. Envoyer l'email au SALARIÉ
    console.log("📧 [WEBHOOK AVENANT COMPLETED] Envoi email salarié...");
    
    // Récupérer le slug DocuSeal du salarié depuis l'avenant (stocké lors de la signature employeur)
    const employeeDocusealSlug = avenant.employee_docuseal_slug || "";
    
    console.log("🔑 [WEBHOOK AVENANT COMPLETED] Slug salarié:", employeeDocusealSlug);
    
    const employeeEmailData: EmailDataV2 = {
      firstName: salarie.prenom || "Salarié",
      organizationName: organization.name || "Votre employeur",
      matricule: contract.matricule || contract.employee_matricule || "Non spécifié",
      contractReference: contract.contract_number || "Non spécifié",
      startDate: startDate,
      profession: contract.profession || "Non spécifié",
      productionName: contract.analytique || contract.production_name || "Non spécifié",
      ctaUrl: employeeDocusealSlug 
        ? `https://paie.odentas.fr/signature-salarie/?docuseal_id=${employeeDocusealSlug}`
        : `https://paie.odentas.fr/`,
      ctaText: "Télécharger l'avenant",
      numeroAvenant: avenant.numero_avenant,
      contractType: "CDDU (contrat intermittent)",
    };

    try {
      const employeeMessageId = await sendUniversalEmailV2({
        type: "amendment-completed-employee",
        toEmail: employeeEmail,
        data: employeeEmailData,
      });
      console.log("✅ [WEBHOOK AVENANT COMPLETED] Email salarié envoyé:", employeeMessageId);
    } catch (emailError: any) {
      console.error("❌ [WEBHOOK AVENANT COMPLETED] Erreur email salarié:", emailError);
    }

    return NextResponse.json({
      success: true,
      message: "Avenant signé, PDF uploadé sur S3 et emails de confirmation envoyés",
      avenantId: avenant.id,
      numeroAvenant: avenant.numero_avenant,
      s3Key: s3Key,
    });

  } catch (error: any) {
    console.error("❌ [WEBHOOK AVENANT COMPLETED] Erreur:", error);
    return NextResponse.json(
      {
        error: "Erreur lors du traitement",
        details: error.message,
      },
      { status: 500 }
    );
  }
}
