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

// GET /api/signatures-electroniques/contrats
// Retourne les contrats à signer par l'employeur ou salarié depuis Supabase
export async function GET(req: NextRequest) {
  // 🎭 Vérifier le mode démo - retourner des données vides pour sécuriser
  if (detectDemoModeFromHeaders(req.headers)) {
    console.log('🎭 [SIGNATURES API] Mode démo détecté - retour de données vides');
    return NextResponse.json({ records: [] }, { status: 200 });
  }

  const reqUrl = new URL(req.url);
  const scope = (reqUrl.searchParams.get('scope') || 'employeur').toLowerCase();
  const orgIdParam = reqUrl.searchParams.get('org_id'); // Paramètre org_id pour les staff

  // Récupération de l'organisation active
  const sb = createRouteHandlerClient({ cookies });
  const { data: { user } } = await sb.auth.getUser();
  if (!user) {
    return NextResponse.json({ error: 'unauthorized' }, { status: 401 });
  }

  // Vérifier staff pour lire la cible via cookie active_org_id ou paramètre 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) {
      // Si un org_id est fourni en paramètre, l'utiliser (priorité pour les staff)
      if (orgIdParam) {
        orgId = orgIdParam;
      } else {
        // Sinon utiliser le cookie active_org_id
        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: 'no_active_org' }, { status: 403 });
      }
      orgId = data.org_id;
    }
  } catch {}

  // Si pas d'organisation trouvée :
  // - pour les utilisateurs normaux on retourne une erreur
  // - pour le staff on permet l'accès global
  if (!orgId && !isStaff) {
    return NextResponse.json({ error: 'no_active_org' }, { status: 403 });
  }

  // Construction de la requête Supabase
  try {
    let query = sb
      .from('cddu_contracts')
      .select(`
        id,
        reference,
        contract_number,
        employee_name,
        employee_matricule,
        production_name,
        role,
        start_date,
        etat_de_la_demande,
        contrat_signe_par_employeur,
        contrat_signe,
        docuseal_template_id,
        docuseal_submission_id,
        signature_link,
        org_id
      `);

    // Filtrer par organisation si applicable
    if (orgId) {
      query = query.eq('org_id', orgId);
    }

    // Filtrer par état de la demande = "Traitée" (essayer plusieurs variantes)
    query = query.in('etat_de_la_demande', ['traitee', 'Traitée', 'Traitee', 'TRAITEE']);

    // Filtrer selon le scope demandé
    if (scope === 'salarie') {
      // Contrats signés par employeur mais pas par salarié
      // Essayer plusieurs variantes de valeurs
      query = query
        .in('contrat_signe_par_employeur', ['oui', 'Oui', 'OUI', 'true', true])
        .in('contrat_signe', ['non', 'Non', 'NON', 'false', false, null]);
    } else {
      // Contrats en attente de signature employeur
      // Essayer plusieurs variantes de valeurs
      query = query.in('contrat_signe_par_employeur', ['non', 'Non', 'NON', 'false', false, null]);
    }

    const { data: contracts, error } = await query;

    if (error) {
      console.error('❌ Erreur Supabase signatures-electroniques:', error);
      return NextResponse.json({ error: 'Erreur base de données' }, { status: 500 });
    }

    // Debug logging
    console.log(`🔍 [signatures-electroniques] Requête pour scope: ${scope}, orgId: ${orgId}`);
    console.log(`📊 [signatures-electroniques] Contrats trouvés: ${contracts?.length || 0}`);
    if (contracts && contracts.length > 0) {
      console.log(`📋 [signatures-electroniques] Échantillon:`, contracts.slice(0, 3).map(c => ({
        id: c.id,
        reference: c.reference || c.contract_number,
        employee_name: c.employee_name,
        etat_de_la_demande: c.etat_de_la_demande,
        contrat_signe_par_employeur: c.contrat_signe_par_employeur,
        contrat_signe: c.contrat_signe
      })));
    }

    // Adapter le format pour correspondre à l'attente de la page (format Airtable-like)
    // et récupérer les signatures des organisations
    const records = await Promise.all((contracts || []).map(async (contract) => {
      // Récupérer la signature de l'organisation si disponible
      let signatureB64 = null;
      if (contract.org_id) {
        try {
          const { data: orgDetails } = await sb
            .from('organization_details')
            .select('signature_b64')
            .eq('org_id', contract.org_id)
            .maybeSingle();
          
          if (orgDetails?.signature_b64) {
            signatureB64 = orgDetails.signature_b64;
            console.log(`✅ [signatures-electroniques] Signature trouvée pour org_id: ${contract.org_id}`);
          }
        } catch (err) {
          console.warn(`⚠️ [signatures-electroniques] Erreur récupération signature pour org_id: ${contract.org_id}`, err);
        }
      }
      
      return {
        id: contract.id,
        fields: {
          'Reference': contract.reference || contract.contract_number,
          'reference': contract.reference || contract.contract_number,
          'Nom salarié': contract.employee_name,
          'employee_name': contract.employee_name,
          'Prénom Salarié': contract.employee_name, // Full name (pas de séparation prénom/nom)
          'Nom Salarié': contract.employee_name,
          'Matricule API': contract.employee_matricule,
          'Production': contract.production_name,
          'role': contract.role,
          'Profession': contract.role,
          'start_date': contract.start_date,
          'Date de début': contract.start_date,
          'État de la demande': contract.etat_de_la_demande || 'Traitée',
          'Contrat signé par employeur': ['oui', 'Oui', 'OUI', 'true', true].includes(contract.contrat_signe_par_employeur) ? 'Oui' : 'Non',
          'Contrat signé': ['oui', 'Oui', 'OUI', 'true', true].includes(contract.contrat_signe) ? 'Oui' : 'Non',
          'signature_employeur': ['oui', 'Oui', 'OUI', 'true', true].includes(contract.contrat_signe_par_employeur),
          'employer_signed': ['oui', 'Oui', 'OUI', 'true', true].includes(contract.contrat_signe_par_employeur),
          'signature_salarie': ['oui', 'Oui', 'OUI', 'true', true].includes(contract.contrat_signe),
          'employee_signed': ['oui', 'Oui', 'OUI', 'true', true].includes(contract.contrat_signe),
          'docuseal_template_id': contract.docuseal_template_id,
          'docuseal_submission_id': contract.docuseal_submission_id,
          'signature_link': contract.signature_link,
          'embed_src_employeur': contract.signature_link,
          'org_id': contract.org_id,
          'signature_b64': signatureB64
        }
      };
    }));

    return NextResponse.json({ records });

  } catch (e: any) {
    console.error('❌ Erreur lors de la récupération des contrats:', e);
    return NextResponse.json({ error: e?.message || 'Erreur inconnue' }, { status: 500 });
  }
}
