import { NextRequest, NextResponse } from 'next/server';
import { createRouteHandlerClient } from '@supabase/auth-helpers-nextjs';
import { cookies } from 'next/headers';
import { sendUniversalEmailV2, EmailConfigV2 } from '@/lib/emailTemplateService';
import { ENV } from '@/lib/cleanEnv';
import { detectDemoModeFromHeaders } from '@/lib/demo-detector';

// POST /api/staff/avenants/relance-salarie
// Envoie un email de relance pour la signature d'un avenant par le salarié
export async function POST(req: NextRequest) {
  // Bloquer l'envoi de relances en mode démo
  if (detectDemoModeFromHeaders(req.headers)) {
    console.log('Mode démo détecté - envoi de relance avenant bloqué');
    return NextResponse.json({ error: 'Action non disponible en mode démo' }, { status: 403 });
  }

  try {
    const { avenantId } = await req.json();

    if (!avenantId) {
      return NextResponse.json({ error: 'Avenant ID manquant' }, { status: 400 });
    }

    // Vérification de l'authentification
    const sb = createRouteHandlerClient({ cookies });
    const { data: { user } } = await sb.auth.getUser();
    if (!user) {
      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
    }

    // Vérifier staff pour lire la cible via cookie active_org_id
    let isStaff = false;
    try {
      const { data } = await sb.from('staff_users').select('is_staff').eq('user_id', user.id).maybeSingle();
      isStaff = !!data?.is_staff;
    } catch {}

    let orgId: string | null = null;
    try {
      if (isStaff) {
        const c = cookies();
        orgId = c.get('active_org_id')?.value || null;
      } else {
        const { data, error } = await sb
          .from('organization_members')
          .select('org_id')
          .eq('user_id', user.id)
          .single();
        if (error || !data?.org_id) {
          return NextResponse.json({ error: 'Aucune organisation active' }, { status: 403 });
        }
        orgId = data.org_id;
      }
    } catch {}

    // Récupération des données de l'avenant depuis Supabase (avenants)
    let query = 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,
          production_name,
          start_date,
          org_id,
          structure,
          profession,
          role,
          multi_mois,
          type_de_contrat
        )
      `)
      .eq('id', avenantId);

    // Pour les utilisateurs staff, ne filtrez pas par org_id via le cookie pour éviter les faux négatifs.
    // Laissez les policies RLS déterminer l'accès. Pour les clients (non-staff), forcez l'org_id.
    if (!isStaff && orgId) {
      // Note: avenants n'a pas directement org_id, mais on peut filtrer via cddu_contracts
      // On laisse RLS gérer cela
    }

    const { data: avenant, error: avenantError } = await query.single();

    if (avenantError || !avenant) {
      console.error('Erreur récupération avenant:', avenantError);
      return NextResponse.json({ error: 'Avenant non trouvé' }, { status: 404 });
    }

    const contract = avenant.cddu_contracts as any;

    // Récupération du slug du salarié via DocuSeal API
    let employeeSlug: string | null = null;
    let docusealEmail: string | null = null;
    if (avenant.docuseal_submission_id) {
      try {
        const docusealResponse = await fetch(`https://api.docuseal.eu/submissions/${avenant.docuseal_submission_id}`, {
          method: 'GET',
          headers: {
            'X-Auth-Token': ENV.DOCUSEAL_TOKEN,
            'Content-Type': 'application/json',
          },
        });
        
        if (docusealResponse.ok) {
          const docusealData = await docusealResponse.json();
          const submitters = docusealData?.submitters || [];
          const employeeSubmitter = submitters.find((s: any) => s.role === 'Salarié');
          employeeSlug = employeeSubmitter?.slug || null;
          if (employeeSubmitter?.email) {
            docusealEmail = String(employeeSubmitter.email);
          }
        } else {
          console.error('DocuSeal API error:', docusealResponse.status, await docusealResponse.text());
        }
      } catch (error) {
        console.error('Erreur récupération DocuSeal:', error);
      }
    }

    // Construction du lien de signature
    let signatureLink: string | null = null;
    if (employeeSlug) {
      const siteBase = process.env.NEXT_PUBLIC_SITE_URL || 'https://paie.odentas.fr';
      signatureLink = `${siteBase}/signature-salarie?docuseal_id=${employeeSlug}`;
    }
    
    if (!signatureLink) {
      return NextResponse.json({ error: 'Lien de signature indisponible' }, { status: 400 });
    }

    // Formatage des données pour l'email
    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}`;
    };
    
    const formattedDateEffet = avenant.date_effet ? formatDate(avenant.date_effet) : 'N/A';
    
    // Récupérer le nom d'employeur depuis organizations.name
    let employerName = 'Employeur';
    try {
      const targetOrgId = contract.org_id || orgId;
      if (targetOrgId) {
        const { data: org } = await sb
          .from('organizations')
          .select('name')
          .eq('id', targetOrgId)
          .maybeSingle();
        employerName = org?.name || contract.structure || 'Employeur';
      } else {
        employerName = contract.structure || 'Employeur';
      }
    } catch (e) {
      employerName = contract.structure || 'Employeur';
    }
    
    // Récupérer le prénom du salarié depuis la base de données
    let prenom_salarie = '';
    if (contract.employee_matricule) {
      try {
        const { data: salData } = await sb
          .from('salaries')
          .select('prenom')
          .or(`code_salarie.eq.${contract.employee_matricule},num_salarie.eq.${contract.employee_matricule}`)
          .limit(1);
        
        if (salData && salData[0]?.prenom) {
          prenom_salarie = salData[0].prenom;
        }
      } catch (e) {
        console.error('Erreur lors de la récupération du prénom depuis salaries:', e);
      }
    }
    
    if (!prenom_salarie) {
      console.error('Prénom du salarié manquant pour l\'avenant:', avenant.id);
      return NextResponse.json({ 
        error: 'Le prénom du salarié est manquant dans la base de données. Veuillez le renseigner avant de relancer la signature.' 
      }, { status: 400 });
    }

    // Récupérer l'email du salarié depuis salaries.adresse_mail
    let toEmail: string | null = null;
    if (contract.employee_matricule) {
      try {
        let salQ = sb
          .from('salaries')
          .select('adresse_mail')
          .or(`code_salarie.eq.${contract.employee_matricule},num_salarie.eq.${contract.employee_matricule}`)
          .limit(1);
        // Pour les utilisateurs staff, ne restreignez pas par employer_id afin de permettre la recherche cross-org
        if (!isStaff && orgId) salQ = salQ.eq('employer_id', orgId);
        const { data: salData, error: salErr } = await salQ;
        if (!salErr && salData && salData[0]?.adresse_mail) {
          toEmail = salData[0].adresse_mail as string;
        }
      } catch (e) {
        console.warn('Impossible de récupérer adresse_mail depuis salaries:', e);
      }
    }
    
    // Fallback via DocuSeal si disponible
    if (!toEmail && docusealEmail) {
      toEmail = docusealEmail;
    }
    
    if (!toEmail) {
      return NextResponse.json({ 
        error: 'Email du salarié manquant' 
      }, { status: 400 });
    }

    console.log('📧 [RELANCE-SALARIE-AVENANT] Préparation email:', {
      to: toEmail,
      avenant_id: avenant.id,
      prenom: prenom_salarie,
      employer: employerName
    });

    // Formatage de la date de début
    const formattedStartDate = contract.start_date ? formatDate(contract.start_date) : 'N/A';
    
    // Détermination du type de contrat
    const isCDDU = contract.type_de_contrat === "CDD d'usage";
    const isMultiMois = contract.multi_mois === "Oui";
    const contractType = isCDDU 
      ? (isMultiMois ? 'CDDU multi-mois' : 'CDDU mono-mois')
      : (contract.type_de_contrat || 'Régime Général');

    // Préparation de la configuration pour l'email
    const emailConfig: EmailConfigV2 = {
      type: 'signature-request-employee-amendment',
      toEmail,
      subject: `Relance : Signature de votre avenant ${avenant.numero_avenant || ''} - ${employerName}`,
      data: {
        firstName: prenom_salarie,
        customMessage: `Vous avez reçu un avenant à votre contrat. Merci de le signer en cliquant sur le bouton ci-dessous.`,
        ctaUrl: signatureLink,
        organizationName: employerName,
        matricule: contract.employee_matricule || 'N/A',
        contractReference: avenant.numero_avenant || 'N/A',
        contractType: contractType,
        profession: contract.profession || contract.role || 'N/A',
        startDate: formattedStartDate,
        productionName: contract.production_name || '',
        companyName: employerName,
      }
    };

    console.log('📤 [RELANCE-SALARIE-AVENANT] Envoi email relance salarié...');

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

    console.log('Email de relance salarié avenant envoyé:', {
      messageId,
      to: toEmail,
      avenant_id: avenant.id
    });

    // Mise à jour du timestamp de dernière notification salarié
    const now = new Date().toISOString();
    const { error: updateError } = await sb
      .from('avenants')
      .update({ last_employee_notification_at: now })
      .eq('id', avenantId);

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

    return NextResponse.json({ 
      success: true,
      message: 'Email de relance envoyé avec succès',
      messageId
    });

  } catch (error) {
    console.error('Erreur envoi relance avenant salarié:', error);
    return NextResponse.json({ 
      error: 'Erreur lors de l\'envoi de la relance', 
      details: error instanceof Error ? error.message : String(error) 
    }, { status: 500 });
  }
}
