const AWS = require('aws-sdk');
const axios = require('axios');
const dynamoDB = new AWS.DynamoDB.DocumentClient();

// Supabase (option 1 - REST avec service role)
const SUPABASE_URL = process.env.SUPABASE_URL; // ex: https://xxxxx.supabase.co
const SUPABASE_SERVICE_ROLE = process.env.SUPABASE_SERVICE_ROLE; // secret service role JWT

// Fonction principale de gestion du webhook
exports.handler = async (event) => {
    console.log("Webhook reçu :", JSON.stringify(event, null, 2));

    try {
        const body = JSON.parse(event.body);
        const submissionId = body.data.submission_id;
        const documentName = body.data.documents[0].name;

        // Récupération des détails de la soumission depuis DocuSeal
        const docusealResponse = await axios.get(`https://api.docuseal.eu/submissions/${submissionId}`, {
            headers: {
                'X-Auth-Token': process.env.DOCUSEAL_API_TOKEN
            }
        });
        
        console.log("Réponse de l'API DocuSeal :", JSON.stringify(docusealResponse.data, null, 2));

        // Récupération du slug du salarié
        const employeeSlug = extractEmployeeSlug(docusealResponse.data);
        if (!employeeSlug) throw new Error("Slug pour le salarié introuvable dans la réponse de DocuSeal");

        // Récupération des données du document dans DynamoDB
        const dynamoData = await retrieveDynamoData(documentName);
        if (!dynamoData) {
            console.log("Aucune donnée trouvée dans DynamoDB pour la clé :", documentName);
            return {
                statusCode: 404,
                body: JSON.stringify({ message: "Aucune donnée trouvée" })
            };
        }

        // Extraire les champs utiles (dont la référence) depuis DynamoDB
        const { 
            employeeEmail, 
            reference, 
            salarie, 
            date, 
            poste, 
            analytique, 
            structure, 
            prenom_salarie, 
            prenom_signataire, 
            code_employeur, 
            matricule, 
            typecontrat,
            organization_id,
            contract_id
        } = dynamoData;

        // Met à jour Supabase: contrat signé par employeur = "Oui" pour le contract_number = reference
        try {
            await updateSupabaseEmployerSigned(reference);
        } catch (err) {
            // Ne pas bloquer complètement le flux d'envoi d'email, mais journaliser clairement l'erreur
            console.error("Echec de mise à jour Supabase (contrat_signe_par_employeur):", err.message);
        }

        // Formater la date au format JJ/MM/AAAA
        let formattedDate;
        if (dynamoData.date) {
            const parsedDate = new Date(dynamoData.date);
            if (!isNaN(parsedDate)) {
                formattedDate = parsedDate.toLocaleDateString('fr-FR'); // Résultat au format JJ/MM/AAAA
            } else {
                console.warn("La date fournie n'est pas valide. Utilisation de la valeur brute.");
                formattedDate = dynamoData.date; // Utiliser la valeur brute si la date est invalide
            }
        } else {
            formattedDate = ''; // Valeur par défaut si la date n'est pas définie
        }

        // Génération du lien de signature
        const signatureLink = `https://paie.odentas.fr/signature-salarie/?docuseal_id=${employeeSlug}`;

        // ============================================
        // NOUVEAU : Appel API Espace Paie au lieu d'envoi direct SES
        // ============================================
        console.log("📤 Appel de l'API Espace Paie pour envoi email...");
        
        const emailPayload = {
            employeeEmail: employeeEmail,
            signatureLink: signatureLink,
            reference: reference,
            firstName: prenom_salarie,
            organizationName: structure,
            matricule: matricule,
            typecontrat: typecontrat,
            startDate: formattedDate,
            profession: poste,
            productionName: analytique,
            organizationId: organization_id,
            contractId: contract_id
        };

        // Appel de l'API Espace Paie et du webhook Zapier en parallèle
        const apiPromise = axios.post(
            `${process.env.ESPACE_PAIE_URL}/api/emails/signature-salarie`,
            emailPayload,
            {
                headers: {
                    'X-API-Key': process.env.ESPACE_PAIE_API_KEY,
                    'Content-Type': 'application/json'
                },
                timeout: 10000
            }
        );

        const zapierPromise = axios.post(process.env.ZAPIER_WEBHOOK_URL, {
            Contrat: reference,
            Type: "autosignature"
        }).catch(error => {
            console.error("Erreur lors de l'appel au webhook Zapier :", error);
        });

        const [espacePaieResponse, _] = await Promise.all([apiPromise, zapierPromise]);
        
        console.log("✅ E-mail envoyé via l'API Espace Paie:", espacePaieResponse.data);

        return {
            statusCode: 200,
            body: JSON.stringify({ 
                message: "Traitement du webhook terminé.",
                emailSent: true,
                messageId: espacePaieResponse.data.messageId
            })
        };
    } catch (error) {
        console.error("Erreur lors du traitement du webhook :", error);
        return {
            statusCode: 500,
            body: JSON.stringify({ 
                message: "Erreur lors du traitement du webhook", 
                error: error.toString() 
            })
        };
    }
};

// Fonction pour extraire le slug du salarié
function extractEmployeeSlug(data) {
    if (Array.isArray(data) && data.length > 0) {
        const employeeData = data.find(sub => sub.role === "Salarié");
        return employeeData ? employeeData.slug : null;
    } else if (data.submitters && Array.isArray(data.submitters)) {
        const employeeData = data.submitters.find(sub => sub.role === "Salarié");
        return employeeData ? employeeData.slug : null;
    }
    return null;
}

// Fonction pour récupérer les données dans DynamoDB
async function retrieveDynamoData(documentName) {
    const params = {
        TableName: 'DocuSealNotification',
        Key: { submission_id: documentName }
    };

    try {
        const result = await dynamoDB.get(params).promise();
        return result.Item;
    } catch (error) {
        console.error("Erreur lors de la récupération des données de DynamoDB :", error);
        return null;
    }
}

// Mise à jour Supabase: cddu_contracts (contrat_signe_par_employeur = "Oui") en filtrant par contract_number = reference
async function updateSupabaseEmployerSigned(reference) {
    if (!SUPABASE_URL || !SUPABASE_SERVICE_ROLE) {
        console.error("SUPABASE_URL ou SUPABASE_SERVICE_ROLE manquant(s) dans les variables d'environnement.");
        throw new Error("Configuration Supabase incomplète.");
    }
    if (!reference) {
        console.error("Référence vide ou invalide pour la mise à jour Supabase.");
        throw new Error("Reference manquante pour update Supabase.");
    }

    const endpoint =
        `${SUPABASE_URL}/rest/v1/cddu_contracts?contract_number=eq.${encodeURIComponent(reference)}&contrat_signe_par_employeur=neq.Oui`;

    try {
        const { data, status } = await axios.patch(
            endpoint,
            { contrat_signe_par_employeur: "Oui" },
            {
                headers: {
                    apikey: SUPABASE_SERVICE_ROLE,
                    Authorization: `Bearer ${SUPABASE_SERVICE_ROLE}`,
                    'Content-Type': 'application/json',
                    Prefer: 'return=representation'
                },
                timeout: 8000
            }
        );

        console.log("Mise à jour Supabase (employeur signé) statut:", status, "data:", JSON.stringify(data));
        return data;
    } catch (err) {
        // Log étendu mais sans secrets
        const status = err.response?.status;
        const respData = err.response?.data;
        console.error("Erreur update Supabase:", status, respData || err.message);
        throw new Error(`Echec update Supabase: ${status || ''} ${respData ? JSON.stringify(respData) : err.message}`);
    }
}
