import { NextRequest, NextResponse } from 'next/server';
import { createSbServiceRole } from '@/lib/supabaseServer';

/**
 * GET /api/signature-salarie/check-status?docuseal_id=xxx
 * 
 * Vérifie si un contrat OU un avenant est déjà signé par le salarié
 * Retourne les infos du document et l'URL de téléchargement si signé
 */
export async function GET(request: NextRequest) {
  console.log('=== API Check Signature Status ===');
  
  try {
    const { searchParams } = new URL(request.url);
    const docuseal_id = searchParams.get('docuseal_id');

    if (!docuseal_id) {
      console.error('Paramètre manquant: docuseal_id');
      return NextResponse.json(
        { error: 'Paramètre docuseal_id requis' },
        { status: 400 }
      );
    }

    console.log('Vérification du statut pour slug:', docuseal_id);

    // Créer le client Supabase avec service role
    const supabase = createSbServiceRole();

    // ÉTAPE 1: Chercher d'abord dans les CONTRATS
    console.log('🔍 Recherche dans cddu_contracts...');
    const { data: contract, error: contractError } = await supabase
      .from('cddu_contracts')
      .select(`
        id, 
        contract_number, 
        employee_id,
        org_id,
        contract_pdf_s3_key,
        type_de_contrat,
        type_d_embauche,
        multi_mois,
        start_date,
        end_date,
        net,
        gross_pay,
        production_name,
        structure,
        profession,
        role,
        docuseal_submission_id,
        employee_docuseal_slug
      `)
      .eq('employee_docuseal_slug', docuseal_id)
      .maybeSingle();

    // ÉTAPE 2: Si pas trouvé dans contrats, chercher dans les AVENANTS
    let avenant = null;
    if (!contract) {
      console.log('🔍 Pas trouvé dans contrats, recherche dans avenants...');
      const { data: avenantData, error: avenantError } = await supabase
        .from('avenants')
        .select(`
          *,
          cddu_contracts (
            id,
            contract_number,
            employee_id,
            org_id,
            start_date,
            end_date,
            net,
            gross_pay,
            production_name,
            structure,
            profession,
            role,
            type_d_embauche,
            multi_mois
          )
        `)
        .eq('employee_docuseal_slug', docuseal_id)
        .maybeSingle();

      if (avenantError) {
        console.error('❌ Erreur recherche avenant:', avenantError);
      } else if (avenantData) {
        console.log('✅ Avenant trouvé:', avenantData.numero_avenant);
        avenant = avenantData;
      }
    }

    // ÉTAPE 3: Si rien trouvé dans les deux tables
    if (!contract && !avenant) {
      console.error('❌ Aucun document trouvé avec employee_docuseal_slug:', docuseal_id);
      return NextResponse.json(
        { error: 'Document introuvable' },
        { status: 404 }
      );
    }

    // ÉTAPE 4: Déterminer le type de document et préparer les données
    const isAvenant = !!avenant;
    const documentType = isAvenant ? 'avenant' : 'contrat';
    console.log(`📄 Type de document: ${documentType}`);

    let documentData: any;
    let employeeId: string;
    let orgId: string;
    let docusealSubmissionId: string | null;
    let pdfS3Key: string | null;
    let documentId: string;

    if (isAvenant && avenant) {
      const contractData = avenant.cddu_contracts;
      documentData = {
        numero: avenant.numero_avenant,
        contract_number: contractData.contract_number,
        start_date: contractData.start_date,
        end_date: contractData.end_date,
        gross_amount: contractData.gross_pay || contractData.net || 0,
        production_name: contractData.production_name || contractData.structure,
        profession: contractData.profession || contractData.role,
        type_d_embauche: contractData.type_d_embauche,
        multi_mois: contractData.multi_mois,
      };
      employeeId = contractData.employee_id;
      orgId = contractData.org_id;
      docusealSubmissionId = avenant.docuseal_submission_id;
      // Utiliser signed_pdf_s3_key en priorité (PDF signé), sinon pdf_s3_key (PDF préliminaire)
      pdfS3Key = avenant.signed_pdf_s3_key || avenant.pdf_s3_key;
      documentId = avenant.id;
    } else if (contract) {
      documentData = {
        numero: contract.contract_number,
        contract_number: contract.contract_number,
        start_date: contract.start_date,
        end_date: contract.end_date,
        gross_amount: contract.gross_pay || contract.net || 0,
        production_name: contract.production_name || contract.structure,
        profession: contract.profession || contract.role,
        type_d_embauche: contract.type_de_contrat,
        multi_mois: contract.multi_mois,
      };
      employeeId = contract.employee_id;
      orgId = contract.org_id;
      docusealSubmissionId = contract.docuseal_submission_id;
      pdfS3Key = contract.contract_pdf_s3_key;
      documentId = contract.id;
    } else {
      // Ne devrait jamais arriver ici car on a déjà vérifié plus haut
      return NextResponse.json(
        { error: 'Document introuvable' },
        { status: 404 }
      );
    }

    console.log('📋 Document:', {
      type: documentType,
      numero: documentData.numero,
      docuseal_submission_id: docusealSubmissionId
    });

    // ÉTAPE 5: Récupérer les infos de la submission DocuSeal si elle existe
    let submission: any = null;
    let employeeSubmitter: any = null;
    
    if (docusealSubmissionId) {
      try {
        console.log('🔍 Récupération de la submission DocuSeal:', docusealSubmissionId);
        const docusealResponse = await fetch(
          `${process.env.NEXT_PUBLIC_SITE_URL || 'http://localhost:3000'}/api/docuseal/submissions/${docusealSubmissionId}`,
          {
            method: 'GET',
            cache: 'no-store',
          }
        );

        if (docusealResponse.ok) {
          submission = await docusealResponse.json();
          console.log('✅ Submission récupérée');
          
          // Trouver le submitter salarié avec ce slug
          const submitters = submission.submitters || [];
          employeeSubmitter = submitters.find((s: any) => s.slug === docuseal_id);
          
          if (employeeSubmitter) {
            console.log('📝 Statut signature salarié:', {
              status: employeeSubmitter.status,
              completed_at: employeeSubmitter.completed_at
            });
          }
        } else {
          console.warn('⚠️ Impossible de récupérer la submission DocuSeal');
        }
      } catch (error) {
        console.warn('⚠️ Erreur lors de la récupération DocuSeal (non bloquant):', error);
      }
    }

    // ÉTAPE 6: Récupérer les infos du salarié
    const { data: employee, error: employeeError } = await supabase
      .from('salaries')
      .select('prenom, nom, adresse_mail, date_naissance')
      .eq('id', employeeId)
      .maybeSingle();

    if (employeeError || !employee) {
      console.error('❌ Erreur lors de la récupération du salarié:', employeeError);
    }

    // ÉTAPE 7: Récupérer les infos de l'organisation
    const { data: organization, error: organizationError } = await supabase
      .from('organizations')
      .select('name')
      .eq('id', orgId)
      .maybeSingle();

    if (organizationError || !organization) {
      console.error('❌ Erreur lors de la récupération de l\'organisation:', organizationError);
    }

    // ÉTAPE 8: Vérifier si le salarié a déjà signé
    const isSigned = employeeSubmitter && employeeSubmitter.status === 'completed';
    console.log('🖊️ Statut signature salarié:', {
      status: employeeSubmitter?.status,
      completed_at: employeeSubmitter?.completed_at,
      isSigned
    });

    // ÉTAPE 9: Si signé, récupérer l'URL de téléchargement du PDF
    let downloadUrl = null;
    if (isSigned && pdfS3Key) {
      console.log('🔗 Génération URL pré-signée pour:', pdfS3Key);
      
      try {
        const { getS3SignedUrlIfExists } = await import('@/lib/aws-s3');
        downloadUrl = await getS3SignedUrlIfExists(pdfS3Key, 3600);
        
        if (downloadUrl) {
          console.log('✅ URL pré-signée générée');
        } else {
          console.warn('⚠️ PDF non trouvé dans S3');
        }
      } catch (s3Error) {
        console.error('❌ Erreur lors de la génération de l\'URL S3:', s3Error);
      }
    }

    // ÉTAPE 10: Calculer le régime (comme dans /api/contrats/[id]/route.ts)
    const isMulti = documentData.multi_mois === "Oui" || documentData.multi_mois === true;
    const td = String(documentData.type_d_embauche || "").toLowerCase();
    const isRG = td.includes("régime général") || td.includes("regime general") || td === "rg";
    const regime = isRG ? "RG" : (isMulti ? "CDDU_MULTI" : "CDDU_MONO");

    // ÉTAPE 11: Retourner les infos
    return NextResponse.json({
      isSigned,
      documentType, // Nouveau: type de document (contrat ou avenant)
      employee_birthdate: employee?.date_naissance || null,
      contract: {
        contract_number: documentData.contract_number,
        regime: regime,
        start_date: documentData.start_date,
        end_date: documentData.end_date,
        gross_amount: documentData.gross_amount,
        employee_name: employee ? `${employee.prenom} ${employee.nom}` : null,
        organization_name: organization?.name || null,
        production_name: documentData.production_name,
        profession: documentData.profession,
      },
      signed_at: employeeSubmitter?.completed_at || null,
      downloadUrl: isSigned ? downloadUrl : null,
    });

  } catch (error) {
    console.error('Erreur lors de la vérification du statut:', error);
    return NextResponse.json(
      { 
        error: 'Erreur serveur lors de la vérification',
        details: error instanceof Error ? error.message : 'Unknown error'
      },
      { status: 500 }
    );
  }
}
