server.js

// Charger les variables d'environnement
require('dotenv').config();

const express = require('express');
const axios = require('axios');
const createCsvWriter = require('csv-writer').createObjectCsvWriter;
const fs = require('fs');
const path = require('path');
const http = require('http');
const socketIo = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

// Configuration depuis les variables d'environnement
const port = process.env.PORT || 3000;

// Configuration API INSEE Sirene
const API_BASE_URL = process.env.INSEE_API_BASE_URL || 'https://api.insee.fr/api-sirene/3.11';
const INSEE_API_KEY = process.env.INSEE_API_KEY;

if (!INSEE_API_KEY) {
    console.error('❌ ERREUR: INSEE_API_KEY n\'est pas définie dans les variables d\'environnement');
    console.error('   Veuillez créer un fichier .env avec votre clé API INSEE');
    process.exit(1);
}

// Configuration DeepSeek (optionnel)
const DEEPSEEK_BASE_URL = process.env.DEEPSEEK_BASE_URL || 'https://api.deepseek.com/v1';
const DEEPSEEK_API_KEY = process.env.DEEPSEEK_API_KEY;
const DEEPSEEK_MODEL = process.env.DEEPSEEK_MODEL || 'deepseek-chat';

// Variable globale pour désactiver temporairement DeepSeek en cas de problème
let DEEPSEEK_TEMPORARILY_DISABLED = process.env.DEEPSEEK_ENABLED === 'false' || !DEEPSEEK_API_KEY;

// Limites de sécurité configurables
const MAX_COMPANIES_LIMIT = parseInt(process.env.MAX_COMPANIES) || 50000;
const MAX_PAGES_LIMIT = parseInt(process.env.MAX_PAGES) || 50;
const WARN_THRESHOLD = parseInt(process.env.WARN_THRESHOLD) || 10000;

// Configuration du traitement par lots DeepSeek
const DEEPSEEK_BATCH_SIZE = parseInt(process.env.DEEPSEEK_BATCH_SIZE) || 50;
const DEEPSEEK_DELAY_MS = parseInt(process.env.DEEPSEEK_DELAY_MS) || 1000;
const DEEPSEEK_MAX_RETRIES = parseInt(process.env.DEEPSEEK_MAX_RETRIES) || 3;

// Configuration du cache
const CACHE_MAX_AGE_HOURS = parseInt(process.env.CACHE_MAX_AGE_HOURS) || 24;

// Système de cache
const cache = {
    data: new Map(), // Cache en mémoire
    metadata: new Map(), // Métadonnées (date, nombre d'entreprises, etc.)
    cacheDir: path.join(__dirname, 'cache'),
    deepseekCache: new Map() // Cache spécifique pour les enrichissements DeepSeek
};

// Créer les dossiers nécessaires
const exportsDir = path.join(__dirname, 'exports');
if (!fs.existsSync(exportsDir)) {
    fs.mkdirSync(exportsDir);
}
if (!fs.existsSync(cache.cacheDir)) {
    fs.mkdirSync(cache.cacheDir);
}

// Middleware
app.use(express.json());
app.use(express.static('public'));

// Route d'accueil de l'API
app.get('/', (req, res) => {
    res.json({
        name: 'ProspectIQ API',
        version: '2.0.0',
        description: 'API de recherche et d\'enrichissement d\'entreprises françaises via INSEE + DeepSeek',
        endpoints: {
            documentation: {
                'GET /': 'Page d\'accueil de l\'API',
                'GET /search-optimized': 'Documentation de l\'endpoint optimisé'
            },
            search: {
                'POST /search': 'Recherche standard',
                'POST /search-advanced': 'Recherche avec filtres avancés',
                'POST /search-optimized': '🔥 Recherche optimisée (recommandé pour interface)',
                'POST /search-stream': 'Recherche avec streaming WebSocket'
            },
            enrichment: {
                'POST /enrich-deepseek': 'Enrichissement IA avec DeepSeek'
            },
            management: {
                'GET /exports': 'Liste des fichiers CSV générés',
                'GET /download/:filename': 'Télécharger un fichier CSV',
                'GET /stats/:filename': 'Statistiques d\'un fichier',
                'GET /cache/info': 'Informations sur le cache',
                'DELETE /cache/clear': 'Vider le cache',
                'GET /deepseek/stats': 'Statistiques DeepSeek',
                'GET /limits': 'Limites de sécurité'
            }
        },
        features: [
            '🏢 Recherche d\'entreprises via API INSEE officielle',
            '💰 Enrichissement automatique avec scores financiers',
            '🤖 Enrichissement IA optionnel avec DeepSeek',
            '📊 Export CSV avec jusqu\'à 25 colonnes',
            '⚡ Système de cache intelligent',
            '🔄 Streaming temps réel',
            '🛡️ Limites de sécurité configurables'
        ],
        status: 'Opérationnel ✅'
    });
});

// Gestion des connexions WebSocket
io.on('connection', (socket) => {
    console.log('🔌 Client connecté:', socket.id);
    
    socket.on('disconnect', () => {
        console.log('🔌 Client déconnecté:', socket.id);
    });
});

// Fonction pour générer une clé de cache
function generateCacheKey(location, filters = {}) {
    const normalizedLocation = location.toLowerCase().trim()
        .replace(/[^a-z0-9]/g, '_');
    const filterKey = Object.keys(filters)
        .sort()
        .map(key => `${key}_${filters[key]}`)
        .join('_')
        .replace(/[^a-z0-9_]/gi, '_');
    return `${normalizedLocation}${filterKey ? `_${filterKey}` : ''}`;
}

// Fonction pour sauvegarder le cache sur disque
async function saveCacheToFile(cacheKey, data, metadata) {
    try {
        const cacheFile = path.join(cache.cacheDir, `${cacheKey}.json`);
        const cacheData = {
            metadata,
            data: data.slice(0, 1000) // Limiter à 1000 pour éviter des fichiers trop volumineux
        };
        await fs.promises.writeFile(cacheFile, JSON.stringify(cacheData, null, 2));
        console.log(`💾 Cache sauvegardé: ${cacheFile}`);
    } catch (error) {
        console.error('❌ Erreur sauvegarde cache:', error.message);
    }
}

// Fonction pour charger le cache depuis le disque
async function loadCacheFromFile(cacheKey) {
    try {
        const cacheFile = path.join(cache.cacheDir, `${cacheKey}.json`);
        if (fs.existsSync(cacheFile)) {
            const cacheData = JSON.parse(await fs.promises.readFile(cacheFile, 'utf8'));
            return cacheData;
        }
    } catch (error) {
        console.error('❌ Erreur chargement cache:', error.message);
    }
    return null;
}

// Fonction pour vérifier si le cache est valide
function isCacheValid(metadata) {
    if (!metadata || !metadata.timestamp) return false;
    const cacheAge = Date.now() - metadata.timestamp;
    const maxAge = CACHE_MAX_AGE_HOURS * 60 * 60 * 1000; // Convertir heures en millisecondes
    return cacheAge < maxAge;
}

// Fonction pour simuler des données financières enrichies
function enrichWithFinancialData(etablissement) {
    const siret = etablissement.siret;
    const effectif = etablissement.uniteLegale?.trancheEffectifsUniteLegale || 'NN';
    const secteur = etablissement.activitePrincipaleEtablissement || '';
    const dateCreation = etablissement.uniteLegale?.dateCreationUniteLegale || '';
    
    // Simulation de scores basés sur des critères réalistes
    const scoreBase = Math.random() * 100;
    
    // Ajustement du score selon l'effectif
    let scoreEffectif = 0;
    switch(effectif) {
        case '00': scoreEffectif = 30; break;
        case '01': scoreEffectif = 45; break;
        case '02': scoreEffectif = 55; break;
        case '03': scoreEffectif = 65; break;
        case '11': scoreEffectif = 70; break;
        case '12': scoreEffectif = 75; break;
        case '21': scoreEffectif = 80; break;
        case '22': scoreEffectif = 85; break;
        case '31': scoreEffectif = 88; break;
        case '32': scoreEffectif = 90; break;
        case '41': scoreEffectif = 92; break;
        case '42': scoreEffectif = 95; break;
        case '51': scoreEffectif = 97; break;
        case '52': scoreEffectif = 98; break;
        case '53': scoreEffectif = 99; break;
        default: scoreEffectif = 40;
    }
    
    // Ajustement selon l'ancienneté
    let scoreAnciennete = 50;
    if (dateCreation) {
        const anneeCreation = parseInt(dateCreation.substring(0, 4));
        const anciennete = new Date().getFullYear() - anneeCreation;
        if (anciennete > 20) scoreAnciennete = 85;
        else if (anciennete > 10) scoreAnciennete = 75;
        else if (anciennete > 5) scoreAnciennete = 65;
        else if (anciennete > 2) scoreAnciennete = 55;
        else scoreAnciennete = 40;
    }
    
    // Score de solvabilité (moyenne pondérée)
    const scoreSolvabilite = Math.round((scoreBase * 0.3 + scoreEffectif * 0.4 + scoreAnciennete * 0.3));
    
    // Classification du risque
    let classeRisque, noteCredit;
    if (scoreSolvabilite >= 85) {
        classeRisque = 'TRÈS FAIBLE';
        noteCredit = 'AAA';
    } else if (scoreSolvabilite >= 70) {
        classeRisque = 'FAIBLE';
        noteCredit = 'AA';
    } else if (scoreSolvabilite >= 55) {
        classeRisque = 'MODÉRÉ';
        noteCredit = 'A';
    } else if (scoreSolvabilite >= 40) {
        classeRisque = 'ÉLEVÉ';
        noteCredit = 'BBB';
    } else {
        classeRisque = 'TRÈS ÉLEVÉ';
        noteCredit = 'BB';
    }
    
    // Simulation de croissance
    const secteursCroissance = ['62', '63', '72', '58', '61'];
    const isSecteurCroissance = secteursCroissance.some(s => secteur.startsWith(s));
    const croissanceBase = isSecteurCroissance ? 15 : 5;
    const croissance = Math.round(croissanceBase + (Math.random() - 0.5) * 20);
    
    // Simulation du chiffre d'affaires estimé
    let caEstime = 0;
    switch(effectif) {
        case '00': caEstime = Math.round(50000 + Math.random() * 100000); break;
        case '01': caEstime = Math.round(100000 + Math.random() * 200000); break;
        case '02': caEstime = Math.round(200000 + Math.random() * 300000); break;
        case '03': caEstime = Math.round(300000 + Math.random() * 400000); break;
        case '11': caEstime = Math.round(500000 + Math.random() * 1000000); break;
        case '12': caEstime = Math.round(1000000 + Math.random() * 3000000); break;
        case '21': caEstime = Math.round(3000000 + Math.random() * 7000000); break;
        case '22': caEstime = Math.round(5000000 + Math.random() * 15000000); break;
        case '31': caEstime = Math.round(10000000 + Math.random() * 40000000); break;
        case '32': caEstime = Math.round(25000000 + Math.random() * 75000000); break;
        case '41': caEstime = Math.round(50000000 + Math.random() * 150000000); break;
        case '42': caEstime = Math.round(100000000 + Math.random() * 400000000); break;
        case '51': caEstime = Math.round(200000000 + Math.random() * 800000000); break;
        case '52': caEstime = Math.round(500000000 + Math.random() * 1500000000); break;
        case '53': caEstime = Math.round(1000000000 + Math.random() * 5000000000); break;
        default: caEstime = Math.round(100000 + Math.random() * 500000);
    }
    
    return {
        ...etablissement,
        enrichissement: {
            scoreSolvabilite,
            classeRisque,
            noteCredit,
            croissanceEstimee: `${croissance > 0 ? '+' : ''}${croissance}%`,
            chiffreAffairesEstime: caEstime,
            viabilite: scoreSolvabilite >= 60 ? 'VIABLE' : scoreSolvabilite >= 40 ? 'ATTENTION' : 'RISQUE',
            secteurActivite: getSecteurLibelle(secteur),
            nombreEmployes: getEffectifLibelle(effectif),
            anciennete: dateCreation ? new Date().getFullYear() - parseInt(dateCreation.substring(0, 4)) : 0
        }
    };
}

// Fonction pour obtenir le libellé du secteur
function getSecteurLibelle(codeNaf) {
    const secteurs = {
        '01': 'Agriculture, sylviculture et pêche',
        '10': 'Industries alimentaires',
        '20': 'Industrie chimique',
        '26': 'Fabrication produits informatiques/électroniques',
        '41': 'Construction de bâtiments',
        '46': 'Commerce de gros',
        '47': 'Commerce de détail',
        '49': 'Transports terrestres',
        '55': 'Hébergement',
        '56': 'Restauration',
        '58': 'Édition',
        '61': 'Télécommunications',
        '62': 'Programmation informatique',
        '63': 'Services d\'information',
        '68': 'Activités immobilières',
        '69': 'Activités juridiques et comptables',
        '70': 'Conseil de gestion',
        '72': 'Recherche-développement',
        '73': 'Publicité et études de marché'
    };
    
    const code2 = codeNaf.substring(0, 2);
    return secteurs[code2] || 'Secteur non déterminé';
}

// Fonction pour obtenir le libellé de l'effectif
function getEffectifLibelle(effectif) {
    const effectifs = {
        'NN': 'Non déterminé',
        '00': '0 salarié',
        '01': '1 à 2 salariés',
        '02': '3 à 5 salariés',
        '03': '6 à 9 salariés',
        '11': '10 à 19 salariés',
        '12': '20 à 49 salariés',
        '21': '50 à 99 salariés',
        '22': '100 à 199 salariés',
        '31': '200 à 249 salariés',
        '32': '250 à 499 salariés',
        '41': '500 à 999 salariés',
        '42': '1000 à 1999 salariés',
        '51': '2000 à 4999 salariés',
        '52': '5000 à 9999 salariés',
        '53': '10000 salariés et plus'
    };
    
    return effectifs[effectif] || 'Non déterminé';
}

// Fonction pour filtrer les entreprises selon les critères
function filterEntreprises(entreprises, filters) {
    return entreprises.filter(entreprise => {
        const enrichissement = entreprise.enrichissement;
        
        if (filters.effectifMin || filters.effectifMax) {
            const effectifCode = entreprise.uniteLegale?.trancheEffectifsUniteLegale || '00';
            const effectifNum = getEffectifNumber(effectifCode);
            
            if (filters.effectifMin && effectifNum < filters.effectifMin) return false;
            if (filters.effectifMax && effectifNum > filters.effectifMax) return false;
        }
        
        if (filters.scoreMin && enrichissement.scoreSolvabilite < filters.scoreMin) return false;
        if (filters.scoreMax && enrichissement.scoreSolvabilite > filters.scoreMax) return false;
        
        if (filters.classeRisque && enrichissement.classeRisque !== filters.classeRisque) return false;
        if (filters.viabilite && enrichissement.viabilite !== filters.viabilite) return false;
        
        if (filters.secteur) {
            const secteurCode = entreprise.activitePrincipaleEtablissement || '';
            if (!secteurCode.startsWith(filters.secteur)) return false;
        }
        
        if (filters.caMin && enrichissement.chiffreAffairesEstime < filters.caMin) return false;
        if (filters.caMax && enrichissement.chiffreAffairesEstime > filters.caMax) return false;
        
        if (filters.croissanceMin) {
            const croissance = parseFloat(enrichissement.croissanceEstimee.replace('%', '').replace('+', ''));
            if (croissance < filters.croissanceMin) return false;
        }
        
        if (filters.companyLocation) {
            const locationFilter = filters.companyLocation.toLowerCase();
            const commune = (entreprise.libelleCommuneEtablissement || '').toLowerCase();
            const codePostal = entreprise.codePostalEtablissement || '';
            const adresse = [
                entreprise.numeroVoieEtablissement,
                entreprise.typeVoieEtablissement,
                entreprise.libelleVoieEtablissement
            ].filter(Boolean).join(' ').toLowerCase();
            
            const matchLocation = commune.includes(locationFilter) || 
                                codePostal.includes(locationFilter) ||
                                adresse.includes(locationFilter);
            
            if (!matchLocation) return false;
        }
        
        return true;
    });
}

// Fonction pour convertir le code effectif en nombre
function getEffectifNumber(effectifCode) {
    const effectifNumbers = {
        '00': 0, '01': 1, '02': 3, '03': 6, '11': 10, '12': 20,
        '21': 50, '22': 100, '31': 200, '32': 250, '41': 500,
        '42': 1000, '51': 2000, '52': 5000, '53': 10000
    };
    return effectifNumbers[effectifCode] || 0;
}

// Fonction pour enrichir une entreprise avec DeepSeek
async function enrichWithDeepSeek(entreprise, retryCount = 0) {
    try {
        const siret = entreprise.siret;
        const uniteLegale = entreprise.uniteLegale || {};
        
        if (cache.deepseekCache.has(siret)) {
            console.log(`💡 DeepSeek cache hit pour SIRET: ${siret}`);
            return cache.deepseekCache.get(siret);
        }
        
        const baseInfo = {
            siret: siret,
            denomination: uniteLegale.denominationUniteLegale || 
                         `${uniteLegale.prenom1UniteLegale || ''} ${uniteLegale.nomUniteLegale || ''}`.trim() || 
                         'Non renseigné',
            codeNaf: entreprise.activitePrincipaleEtablissement || '',
            adresse: {
                numero: entreprise.numeroVoieEtablissement || '',
                typeVoie: entreprise.typeVoieEtablissement || '',
                voie: entreprise.libelleVoieEtablissement || '',
                complement: entreprise.complementAdresseEtablissement || '',
                codePostal: entreprise.codePostalEtablissement || '',
                commune: entreprise.libelleCommuneEtablissement || ''
            },
            effectifCode: uniteLegale.trancheEffectifsUniteLegale || 'NN',
            dateCreation: uniteLegale.dateCreationUniteLegale || '',
            categorieJuridique: uniteLegale.categorieJuridiqueUniteLegale || ''
        };

        const prompt = `En tant qu'expert en analyse d'entreprise, analysez les informations suivantes et enrichissez-les :

Entreprise : ${baseInfo.denomination}
SIRET : ${baseInfo.siret}
Code NAF : ${baseInfo.codeNaf}
Adresse : ${baseInfo.adresse.numero} ${baseInfo.adresse.typeVoie} ${baseInfo.adresse.voie}, ${baseInfo.adresse.codePostal} ${baseInfo.adresse.commune}
Effectif code : ${baseInfo.effectifCode}
Date création : ${baseInfo.dateCreation}
Catégorie juridique : ${baseInfo.categorieJuridique}

Veuillez enrichir ces données en fournissant UNIQUEMENT un objet JSON valide avec les champs suivants (sans commentaires, sans texte explicatif) :

{
  "adresseComplete": "adresse formatée et corrigée",
  "domaineActivite": "description précise du domaine d'activité basé sur le code NAF et le nom",
  "nombreEmployesEstime": "estimation du nombre d'employés (nombre entier)",
  "typeOrganisation": "type d'organisation (PME, ETI, Grande entreprise, Startup, Artisan, etc.)",
  "informationsEntreprise": "résumé informatif sur l'entreprise et son activité",
  "styleEntreprise": "style/caractère de l'entreprise (jeune, dynamique, corporate, artisanal, business, cool, traditionnel, etc.)"
}`;

        const response = await axios.post(`${DEEPSEEK_BASE_URL}/chat/completions`, {
            model: DEEPSEEK_MODEL,
            messages: [
                {
                    role: "system",
                    content: "Tu es un expert en analyse d'entreprises françaises. Réponds UNIQUEMENT avec un objet JSON valide, sans texte explicatif."
                },
                {
                    role: "user",
                    content: prompt
                }
            ],
            temperature: 0.3,
            max_tokens: 1000
        }, {
            headers: {
                'Authorization': `Bearer ${DEEPSEEK_API_KEY}`,
                'Content-Type': 'application/json'
            },
            timeout: 30000
        });

        const content = response.data.choices[0].message.content.trim();
        
        let jsonStr = content;
        if (content.includes('```json')) {
            jsonStr = content.match(/```json\s*([\s\S]*?)\s*```/)?.[1] || content;
        } else if (content.includes('```')) {
            jsonStr = content.match(/```\s*([\s\S]*?)\s*```/)?.[1] || content;
        }
        
        const enrichissement = JSON.parse(jsonStr);
        
        const cleanedEnrichissement = {
            adresseComplete: enrichissement.adresseComplete || 'Non disponible',
            domaineActivite: enrichissement.domaineActivite || 'Non déterminé',
            nombreEmployesEstime: parseInt(enrichissement.nombreEmployesEstime) || 0,
            typeOrganisation: enrichissement.typeOrganisation || 'Non déterminé',
            informationsEntreprise: enrichissement.informationsEntreprise || 'Informations non disponibles',
            styleEntreprise: enrichissement.styleEntreprise || 'Non déterminé'
        };
        
        cache.deepseekCache.set(siret, cleanedEnrichissement);
        
        console.log(`✅ DeepSeek enrichissement réussi pour: ${baseInfo.denomination}`);
        return cleanedEnrichissement;
        
    } catch (error) {
        console.error(`❌ Erreur DeepSeek pour SIRET ${entreprise.siret}:`, error.message);
        
        if (error.response?.status === 402) {
            console.log(`💳 Quota DeepSeek épuisé - Arrêt de l'enrichissement IA`);
            throw new Error('Quota DeepSeek épuisé');
        }
        
        if (retryCount < DEEPSEEK_MAX_RETRIES && error.response?.status !== 402) {
            console.log(`🔄 Tentative ${retryCount + 1}/${DEEPSEEK_MAX_RETRIES} pour SIRET ${entreprise.siret}`);
            await new Promise(resolve => setTimeout(resolve, (retryCount + 1) * 2000));
            return await enrichWithDeepSeek(entreprise, retryCount + 1);
        }
        
        return {
            adresseComplete: 'Erreur lors de l\'enrichissement',
            domaineActivite: 'Non disponible',
            nombreEmployesEstime: 0,
            typeOrganisation: 'Non déterminé',
            informationsEntreprise: 'Données non disponibles',
            styleEntreprise: 'Non déterminé'
        };
    }
}

// Fonction pour traitement par lots avec DeepSeek
async function enrichBatchWithDeepSeek(entreprises, socketId = null) {
    const totalEntreprises = entreprises.length;
    const enrichedEntreprises = [];
    
    console.log(`🤖 Début de l'enrichissement DeepSeek pour ${totalEntreprises} entreprises`);
    
    for (let i = 0; i < totalEntreprises; i += DEEPSEEK_BATCH_SIZE) {
        const batch = entreprises.slice(i, i + DEEPSEEK_BATCH_SIZE);
        const batchNumber = Math.floor(i / DEEPSEEK_BATCH_SIZE) + 1;
        const totalBatches = Math.ceil(totalEntreprises / DEEPSEEK_BATCH_SIZE);
        
        console.log(`📦 Traitement du lot ${batchNumber}/${totalBatches} (${batch.length} entreprises)`);
        
        const batchPromises = batch.map(async (entreprise, index) => {
            await new Promise(resolve => setTimeout(resolve, index * 200));
            
            try {
                const deepseekEnrichissement = await enrichWithDeepSeek(entreprise);
                
                return {
                    ...entreprise,
                    deepseekEnrichissement
                };
            } catch (error) {
                console.error(`❌ Erreur lors de l'enrichissement DeepSeek:`, error.message);
                return {
                    ...entreprise,
                    deepseekEnrichissement: {
                        adresseComplete: 'Erreur d\'enrichissement',
                        domaineActivite: 'Non disponible',
                        nombreEmployesEstime: 0,
                        typeOrganisation: 'Non déterminé',
                        informationsEntreprise: 'Erreur lors du traitement',
                        styleEntreprise: 'Non déterminé'
                    }
                };
            }
        });
        
        const batchResults = await Promise.all(batchPromises);
        enrichedEntreprises.push(...batchResults);
        
        if (socketId) {
            const socket = io.sockets.sockets.get(socketId);
            if (socket) {
                socket.emit('deepseek_progress', {
                    processed: enrichedEntreprises.length,
                    total: totalEntreprises,
                    batch: batchNumber,
                    totalBatches: totalBatches,
                    data: batchResults
                });
            }
        }
        
        if (i + DEEPSEEK_BATCH_SIZE < totalEntreprises) {
            console.log(`⏳ Attente de ${DEEPSEEK_DELAY_MS}ms avant le prochain lot...`);
            await new Promise(resolve => setTimeout(resolve, DEEPSEEK_DELAY_MS));
        }
    }
    
    console.log(`✅ Enrichissement DeepSeek terminé: ${enrichedEntreprises.length} entreprises traitées`);
    return enrichedEntreprises;
}

// Fonction pour détecter si c'est un nom d'entreprise
function isCompanyName(term) {
    const termLower = term.toLowerCase();
    
    const companyIndicators = [
        'sarl', 'sas', 'sa', 'eurl', 'sci', 'snc', 'scp', 'scop',
        'association', 'asso', 'fondation',
        'ltd', 'inc', 'corp', 'llc', 'gmbh',
        'entreprise', 'société', 'compagnie', 'groupe', 'holding',
        'consulting', 'conseil', 'services', 'solutions',
        'technologies', 'tech', 'digital', 'systems',
        'international', 'france', 'paris', 'lyon',
        'restaurant', 'boulangerie', 'pharmacie', 'garage',
        'coiffure', 'immobilier', 'construction', 'batiment',
        'transport', 'logistique', 'informatique', 'web'
    ];
    
    const hasCompanyIndicator = companyIndicators.some(indicator => 
        termLower.includes(indicator)
    );
    
    const hasMultipleWords = term.split(/\s+/).length >= 2;
    const hasCapitalLetters = /[A-Z]/.test(term) && term !== term.toUpperCase();
    
    const commonCities = [
        'paris', 'lyon', 'marseille', 'toulouse', 'nice', 'nantes',
        'strasbourg', 'montpellier', 'bordeaux', 'lille', 'rennes',
        'reims', 'le havre', 'saint-étienne', 'toulon', 'grenoble'
    ];
    
    const isCommonCity = commonCities.some(city => 
        termLower.includes(city)
    );
    
    return (hasCompanyIndicator || (hasMultipleWords && hasCapitalLetters)) && !isCommonCity;
}

// Fonction pour normaliser un nom d'entreprise
function normalizeCompanyName(companyName) {
    let normalized = companyName.trim();
    
    normalized = normalized
        .replace(/\s+(sarl|sas|sa|eurl|sci|snc|scp|scop|ltd|inc|corp|llc|gmbh)$/i, '')
        .replace(/^(sarl|sas|sa|eurl|sci|snc|scp|scop|ltd|inc|corp|llc|gmbh)\s+/i, '')
        .trim();
    
    normalized = normalized.replace(/\s+/g, ' ');
    
    return normalized;
}

// Fonction de recherche avec cache et streaming
async function searchWithCacheAndStreaming(location, filters = {}, socketId = null) {
    const customLimit = filters.maxCompanies || MAX_COMPANIES_LIMIT;
    const effectiveLimit = customLimit === 0 ? Number.MAX_SAFE_INTEGER : customLimit;
    
    console.log(`🛡️ Limite de sécurité appliquée: ${customLimit === 0 ? 'Aucune limite' : customLimit.toLocaleString()} entreprises`);
    
    const cacheKey = generateCacheKey(location, filters);
    
    // Vérifier le cache en mémoire
    if (cache.data.has(cacheKey) && cache.metadata.has(cacheKey)) {
        const metadata = cache.metadata.get(cacheKey);
        if (isCacheValid(metadata)) {
            console.log(`🎯 Cache en mémoire trouvé pour: ${cacheKey}`);
            const cachedData = cache.data.get(cacheKey);
            
            if (socketId) {
                const socket = io.sockets.sockets.get(socketId);
                if (socket) {
                    socket.emit('search_start', { 
                        location, 
                        total: cachedData.length,
                        fromCache: true,
                        maxCompanies: customLimit
                    });
                    
                    for (let i = 0; i < cachedData.length; i += 50) {
                        const chunk = cachedData.slice(i, i + 50);
                        socket.emit('data_chunk', { 
                            data: chunk, 
                            progress: Math.min(i + 50, cachedData.length),
                            total: cachedData.length 
                        });
                        await new Promise(resolve => setTimeout(resolve, 50));
                    }
                    
                    socket.emit('search_complete', { 
                        total: cachedData.length,
                        fromCache: true 
                    });
                }
            }
            
            return {
                success: true,
                data: cachedData,
                total: cachedData.length,
                fromCache: true,
                metadata
            };
        }
    }
    
    // Vérifier le cache sur disque
    const diskCache = await loadCacheFromFile(cacheKey);
    if (diskCache && isCacheValid(diskCache.metadata)) {
        console.log(`💾 Cache disque trouvé pour: ${cacheKey}`);
        
        cache.data.set(cacheKey, diskCache.data);
        cache.metadata.set(cacheKey, diskCache.metadata);
        
        if (socketId) {
            const socket = io.sockets.sockets.get(socketId);
            if (socket) {
                socket.emit('search_start', { 
                    location, 
                    total: diskCache.data.length,
                    fromCache: true,
                    maxCompanies: customLimit
                });
                
                for (let i = 0; i < diskCache.data.length; i += 50) {
                    const chunk = diskCache.data.slice(i, i + 50);
                    socket.emit('data_chunk', { 
                        data: chunk, 
                        progress: Math.min(i + 50, diskCache.data.length),
                        total: diskCache.data.length 
                    });
                    await new Promise(resolve => setTimeout(resolve, 50));
                }
                
                socket.emit('search_complete', { 
                    total: diskCache.data.length,
                    fromCache: true 
                });
            }
        }
        
        return {
            success: true,
            data: diskCache.data,
            total: diskCache.data.length,
            fromCache: true,
            metadata: diskCache.metadata
        };
    }
    
    // Pas de cache valide, faire la recherche complète
    console.log(`🔍 Recherche INSEE enrichie pour: "${location}" avec filtres:`, filters);
    
    if (socketId) {
        const socket = io.sockets.sockets.get(socketId);
        if (socket) {
            socket.emit('search_start', { 
                location, 
                fromCache: false,
                maxCompanies: customLimit
            });
        }
    }
    
    // Construction de la requête avec syntaxe INSEE correcte
    // Combiner TOUS les critères avec AND pour que tous soient respectés
    let query = '';
    const locationTrimmed = location.trim();
    const queryParts = [];
    
    // Si des filtres spécifiques sont fournis (recherche optimisée), les utiliser
    if (filters.postalCode || filters.cityName || filters.streetName || filters.companyName) {
        // Code postal (priorité la plus haute)
        if (filters.postalCode) {
            queryParts.push(`codePostalEtablissement:${filters.postalCode}`);
        }
        
        // Nom de ville
        if (filters.cityName) {
            const cityNormalized = filters.cityName.trim().replace(/\s+/g, ' ');
            if (cityNormalized.includes(' ')) {
                queryParts.push(`libelleCommuneEtablissement:*${cityNormalized.replace(' ', '*')}*`);
            } else {
                queryParts.push(`libelleCommuneEtablissement:${cityNormalized}*`);
            }
        }
        
        // Nom de rue
        if (filters.streetName) {
            let streetNormalized = filters.streetName.trim().replace(/\s+/g, ' ');
            // Supprimer les types de voie en début/fin
            streetNormalized = streetNormalized
                .replace(/^(rue|avenue|boulevard|place|chemin|impasse|allée)\s+/i, '')
                .replace(/\s+(rue|avenue|boulevard|place|chemin|impasse|allée)$/i, '')
                .trim();
            
            if (streetNormalized.length >= 2) {
                if (streetNormalized.includes(' ')) {
                    queryParts.push(`libelleVoieEtablissement:*${streetNormalized.replace(' ', '*')}*`);
                } else {
                    queryParts.push(`libelleVoieEtablissement:*${streetNormalized}*`);
                }
            }
        }
        
        // Nom d'entreprise
        if (filters.companyName) {
            const companyNormalized = normalizeCompanyName(filters.companyName);
            if (companyNormalized.includes(' ')) {
                const mots = companyNormalized.split(' ').filter(mot => mot.length >= 2);
                if (mots.length > 1) {
                    const rechercheEntreprise = mots.map(mot => `denominationUniteLegale:*${mot}*`).join(' AND ');
                    queryParts.push(`(${rechercheEntreprise})`);
                } else {
                    queryParts.push(`denominationUniteLegale:*${companyNormalized}*`);
                }
            } else {
                queryParts.push(`denominationUniteLegale:*${companyNormalized}*`);
            }
        }
        
        // Combiner toutes les parties avec AND
        if (queryParts.length > 0) {
            query = queryParts.length === 1 ? queryParts[0] : `(${queryParts.join(' AND ')})`;
            console.log(`🔍 Recherche optimisée combinée: "${query}"`);
        }
    } 
    // Sinon, utiliser la logique de fallback avec location
    else if (/^\d{5}$/.test(locationTrimmed)) {
        query = `codePostalEtablissement:${locationTrimmed}`;
        console.log(`🔍 Recherche par code postal: ${locationTrimmed}`);
    } else if (isCompanyName(locationTrimmed)) {
        const nomNormalise = normalizeCompanyName(locationTrimmed);
        if (nomNormalise.includes(' ')) {
            const mots = nomNormalise.split(' ').filter(mot => mot.length >= 2);
            if (mots.length > 1) {
                query = mots.map(mot => `denominationUniteLegale:*${mot}*`).join(' AND ');
            } else {
                query = `denominationUniteLegale:*${nomNormalise}*`;
            }
        } else {
            query = `denominationUniteLegale:*${nomNormalise}*`;
        }
        console.log(`🔍 Recherche par nom d'entreprise: "${query}"`);
    } else if (locationTrimmed.length >= 2) {
        const termes = locationTrimmed.split(/\s+/).filter(terme => terme.length >= 2);
        
        if (termes.length === 1) {
            query = `(libelleCommuneEtablissement:${termes[0]}* OR libelleVoieEtablissement:*${termes[0]}* OR denominationUniteLegale:*${termes[0]}*)`;
            console.log(`🔍 Recherche mixte (commune/voie/entreprise): ${termes[0]}`);
        } else {
            const termesJoints = termes.join(' ');
            const rechercheCommune = `libelleCommuneEtablissement:*${termesJoints.replace(' ', '*')}*`;
            const rechercheEntreprise = termes.map(terme => `denominationUniteLegale:*${terme}*`).join(' AND ');
            query = `(${rechercheCommune} OR (${rechercheEntreprise}))`;
            console.log(`🔍 Recherche mixte (commune/entreprise): "${query}"`);
        }
    }
    
    if (!query) {
        throw new Error('Le terme de recherche doit contenir au moins 2 caractères');
    }
    
    let tousLesEtablissements = [];
    let debut = 1;
    const nombreParPage = 1000;
    let continuerRecherche = true;
    let pageCount = 0;
    
    try {
        while (continuerRecherche) {
            pageCount++;
            
            if (pageCount > MAX_PAGES_LIMIT) {
                console.log(`🛑 Limite de pages atteinte (${MAX_PAGES_LIMIT} pages max)`);
                break;
            }
            
            if (tousLesEtablissements.length >= effectiveLimit) {
                console.log(`🛑 Limite d'entreprises atteinte (${effectiveLimit === Number.MAX_SAFE_INTEGER ? 'aucune limite' : effectiveLimit.toLocaleString()} entreprises max)`);
                break;
            }
            
            if (tousLesEtablissements.length >= WARN_THRESHOLD && tousLesEtablissements.length < WARN_THRESHOLD + 1000) {
                console.log(`⚠️ Seuil d'avertissement atteint : ${tousLesEtablissements.length} entreprises récupérées`);
            }
            
            const params = {
                q: query,
                nombre: nombreParPage,
                debut: debut
            };

            console.log(`📡 Appel API INSEE - Page ${Math.ceil(debut/nombreParPage)} (résultats ${debut} à ${debut + nombreParPage - 1})`);

            try {
                const response = await axios.get(`${API_BASE_URL}/siret`, { 
                    params,
                    timeout: 30000,
                    headers: {
                        'X-INSEE-Api-Key-Integration': INSEE_API_KEY,
                        'User-Agent': 'ProspectIQ/2.0',
                        'Accept': 'application/json'
                    }
                });
                
                const etablissements = response.data.etablissements || [];
                
                if (etablissements.length === 0) {
                    console.log(`✅ Fin de pagination - Aucun résultat supplémentaire`);
                    continuerRecherche = false;
                } else {
                    console.log(`📊 ${etablissements.length} entreprises récupérées pour cette page`);
                    
                    const etablissementsEnrichis = etablissements.map(enrichWithFinancialData);
                    tousLesEtablissements = tousLesEtablissements.concat(etablissementsEnrichis);
                    
                    if (socketId) {
                        const socket = io.sockets.sockets.get(socketId);
                        if (socket) {
                            socket.emit('data_chunk', { 
                                data: etablissementsEnrichis, 
                                progress: tousLesEtablissements.length,
                                page: Math.ceil(debut/nombreParPage)
                            });
                        }
                    }
                    
                    debut += nombreParPage;
                    await new Promise(resolve => setTimeout(resolve, 2100));
                }
                
            } catch (error) {
                if (error.response?.status === 429) {
                    console.log(`⏳ Limite de taux atteinte, attente de 10 secondes...`);
                    await new Promise(resolve => setTimeout(resolve, 10000));
                    continue;
                } else {
                    console.error(`❌ Erreur lors de l'appel API:`, error.message);
                    continuerRecherche = false;
                }
            }
        }

        console.log(`🎯 Total récupéré: ${tousLesEtablissements.length} entreprises (${pageCount} pages)`);
        
        if (tousLesEtablissements.length >= effectiveLimit && effectiveLimit !== Number.MAX_SAFE_INTEGER) {
            console.log(`⚠️ Limite maximale d'entreprises atteinte (${effectiveLimit.toLocaleString()})`);
        }
        if (pageCount >= MAX_PAGES_LIMIT) {
            console.log(`⚠️ Limite maximale de pages atteinte (${MAX_PAGES_LIMIT})`);
        }
        
        console.log('💰 Enrichissement des données avec scores financiers...');

        let entreprisesEnrichiesDeepSeek = tousLesEtablissements;
        if (filters.enableDeepSeek === true && !DEEPSEEK_TEMPORARILY_DISABLED && tousLesEtablissements.length > 0) {
            console.log('🤖 Enrichissement avec DeepSeek activé...');
            
            if (socketId) {
                const socket = io.sockets.sockets.get(socketId);
                if (socket) {
                    socket.emit('deepseek_start', { 
                        total: tousLesEtablissements.length,
                        batchSize: DEEPSEEK_BATCH_SIZE
                    });
                }
            }
            
            try {
                entreprisesEnrichiesDeepSeek = await enrichBatchWithDeepSeek(tousLesEtablissements, socketId);
                console.log('✅ Enrichissement DeepSeek terminé avec succès');
            } catch (deepseekError) {
                console.error('⚠️ Erreur DeepSeek - Continuation sans enrichissement IA:', deepseekError.message);
                
                if (deepseekError.message.includes('Quota DeepSeek épuisé')) {
                    DEEPSEEK_TEMPORARILY_DISABLED = true;
                    console.log('🚫 DeepSeek désactivé temporairement suite au quota épuisé');
                }
                
                entreprisesEnrichiesDeepSeek = tousLesEtablissements;
                
                if (socketId) {
                    const socket = io.sockets.sockets.get(socketId);
                    if (socket) {
                        socket.emit('deepseek_error', { 
                            message: 'Enrichissement IA non disponible - Données de base conservées',
                            fallback: true,
                            temporarilyDisabled: DEEPSEEK_TEMPORARILY_DISABLED
                        });
                    }
                }
            }
        }

        // Application des filtres
        let entreprisesFiltrees = entreprisesEnrichiesDeepSeek;
        if (Object.keys(filters).length > 0) {
            const { enableDeepSeek, ...otherFilters } = filters;
            if (Object.keys(otherFilters).length > 0) {
                console.log('🔍 Application des filtres...');
                entreprisesFiltrees = filterEntreprises(entreprisesEnrichiesDeepSeek, otherFilters);
                console.log(`📊 ${entreprisesFiltrees.length} entreprises après filtrage`);
            }
        }
        
        // Sauvegarder dans le cache
        const metadata = {
            timestamp: Date.now(),
            location,
            filters,
            totalResults: entreprisesFiltrees.length,
            searchDate: new Date().toISOString()
        };
        
        cache.data.set(cacheKey, entreprisesFiltrees);
        cache.metadata.set(cacheKey, metadata);
        
        saveCacheToFile(cacheKey, entreprisesFiltrees, metadata);
        
        if (socketId) {
            const socket = io.sockets.sockets.get(socketId);
            if (socket) {
                socket.emit('search_complete', { 
                    total: entreprisesFiltrees.length,
                    fromCache: false 
                });
            }
        }
        
        return {
            success: true,
            data: entreprisesFiltrees,
            total: entreprisesFiltrees.length,
            fromCache: false,
            metadata
        };
        
    } catch (error) {
        console.error('❌ Erreur lors de la recherche:', error.message);
        
        if (socketId) {
            const socket = io.sockets.sockets.get(socketId);
            if (socket) {
                socket.emit('search_error', { error: error.message });
            }
        }
        
        throw error;
    }
}

// Route pour la recherche optimisée depuis l'interface
app.post('/search-optimized', async (req, res) => {
    try {
        const { 
            cityName, 
            postalCode, 
            streetName, 
            companyName,
            filters = {} 
        } = req.body;
        
        let location = '';
        if (postalCode) {
            location = postalCode;
        } else if (cityName) {
            location = cityName;
        } else if (streetName) {
            location = streetName;
        } else if (companyName) {
            location = companyName;
        } else {
            return res.status(400).json({ 
                success: false, 
                message: 'Au moins un critère de recherche est requis' 
            });
        }

        const enrichedFilters = {
            ...filters,
            cityName: cityName || null,
            postalCode: postalCode || null,
            streetName: streetName || null,
            companyName: companyName || null,
            enableDeepSeek: (companyName && !DEEPSEEK_TEMPORARILY_DISABLED) ? true : false
        };

        Object.keys(enrichedFilters).forEach(key => {
            if (enrichedFilters[key] === null || enrichedFilters[key] === undefined || enrichedFilters[key] === '') {
                delete enrichedFilters[key];
            }
        });

        const result = await searchWithCacheAndStreaming(location, enrichedFilters);
        
        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
        const criteriaName = postalCode || cityName || streetName || companyName || 'search';
        const filename = `entreprises_${criteriaName}_${timestamp}.csv`;
        const filepath = path.join(exportsDir, filename);

        await saveToCSVEnrichi(result.data, filepath);

        res.json({
            success: true,
            count: result.total,
            message: `${result.total} entreprises trouvées et sauvegardées`,
            filename: filename,
            fromCache: result.fromCache,
            searchCriteria: {
                cityName,
                postalCode,
                streetName,
                companyName
            },
            enrichissement: {
                scoresFinanciers: true,
                evaluationRisque: true,
                estimationCroissance: true,
                classificationViabilite: true,
                deepSeekActive: enrichedFilters.enableDeepSeek
            },
            companies: result.data.slice(0, 50).map(etablissement => {
                const enrichissement = etablissement.enrichissement;
                const deepseekEnrichissement = etablissement.deepseekEnrichissement;
                const uniteLegale = etablissement.uniteLegale || {};
                
                return {
                    siret: etablissement.siret,
                    denomination: uniteLegale.denominationUniteLegale || 
                                 uniteLegale.prenom1UniteLegale + ' ' + uniteLegale.nomUniteLegale || 
                                 'Non renseigné',
                    secteurActivite: deepseekEnrichissement?.domaineActivite || enrichissement.secteurActivite,
                    adresseComplete: deepseekEnrichissement?.adresseComplete || 
                                   [etablissement.numeroVoieEtablissement,
                                    etablissement.typeVoieEtablissement,
                                    etablissement.libelleVoieEtablissement,
                                    etablissement.complementAdresseEtablissement].filter(Boolean).join(' ') ||
                                   `${etablissement.codePostalEtablissement || ''} ${etablissement.libelleCommuneEtablissement || ''}`.trim() ||
                                   'Adresse non disponible',
                    nombreEmployes: deepseekEnrichissement?.nombreEmployesEstime || enrichissement.nombreEmployes,
                    scoreSolvabilite: enrichissement.scoreSolvabilite,
                    classeRisque: enrichissement.classeRisque,
                    viabilite: enrichissement.viabilite,
                    croissanceEstimee: enrichissement.croissanceEstimee,
                    chiffreAffairesEstime: enrichissement.chiffreAffairesEstime,
                    typeOrganisation: deepseekEnrichissement?.typeOrganisation || 'Non déterminé',
                    codePostal: etablissement.codePostalEtablissement,
                    commune: etablissement.libelleCommuneEtablissement,
                    hasDeepSeekEnrichment: !!deepseekEnrichissement
                };
            }),
            filtresAppliques: enrichedFilters,
            metadata: result.metadata
        });

    } catch (error) {
        console.error('Erreur lors de la recherche optimisée:', error);
        res.status(500).json({ 
            success: false, 
            message: 'Erreur lors de la recherche optimisée: ' + error.message 
        });
    }
});

// Route pour la recherche avec streaming WebSocket
app.post('/search-stream', async (req, res) => {
    try {
        const { location, filters = {}, socketId } = req.body;
        
        if (!location) {
            return res.status(400).json({ 
                success: false, 
                message: 'Le paramètre location est requis' 
            });
        }

        if (!socketId) {
            return res.status(400).json({ 
                success: false, 
                message: 'Le paramètre socketId est requis pour le streaming' 
            });
        }

        const result = await searchWithCacheAndStreaming(location, filters, socketId);
        
        res.json({
            success: true,
            message: 'Recherche avec streaming initiée',
            total: result.total,
            fromCache: result.fromCache
        });

    } catch (error) {
        console.error('Erreur lors de la recherche avec streaming:', error);
        res.status(500).json({ 
            success: false, 
            message: 'Erreur lors de la recherche avec streaming: ' + error.message 
        });
    }
});

// Fonction pour sauvegarder en CSV enrichi
async function saveToCSVEnrichi(etablissements, filepath) {
    const csvWriter = createCsvWriter({
        path: filepath,
        header: [
            { id: 'siret', title: 'SIRET' },
            { id: 'siren', title: 'SIREN' },
            { id: 'denominationUniteLegale', title: 'Dénomination' },
            { id: 'activitePrincipaleEtablissement', title: 'Code NAF' },
            { id: 'secteurActivite', title: 'Secteur d\'activité' },
            { id: 'adresseComplete', title: 'Adresse complète' },
            { id: 'codePostalEtablissement', title: 'Code postal' },
            { id: 'libelleCommuneEtablissement', title: 'Commune' },
            { id: 'nombreEmployes', title: 'Nombre d\'employés' },
            { id: 'dateCreationUniteLegale', title: 'Date de création' },
            { id: 'anciennete', title: 'Ancienneté (années)' },
            { id: 'scoreSolvabilite', title: 'Score de solvabilité (/100)' },
            { id: 'classeRisque', title: 'Classe de risque' },
            { id: 'noteCredit', title: 'Note de crédit' },
            { id: 'viabilite', title: 'Viabilité' },
            { id: 'croissanceEstimee', title: 'Croissance estimée' },
            { id: 'chiffreAffairesEstime', title: 'CA estimé (€)' },
            { id: 'etatAdministratifEtablissement', title: 'État administratif' },
            { id: 'categorieJuridiqueUniteLegale', title: 'Catégorie juridique' },
            { id: 'adresseCompleteDeepSeek', title: 'Adresse complète (DeepSeek)' },
            { id: 'domaineActiviteDeepSeek', title: 'Domaine d\'activité (DeepSeek)' },
            { id: 'nombreEmployesEstimeDeepSeek', title: 'Nombre d\'employés estimé (DeepSeek)' },
            { id: 'typeOrganisationDeepSeek', title: 'Type d\'organisation (DeepSeek)' },
            { id: 'informationsEntrepriseDeepSeek', title: 'Informations entreprise (DeepSeek)' },
            { id: 'styleEntrepriseDeepSeek', title: 'Style entreprise (DeepSeek)' }
        ]
    });

    const records = etablissements.map(etablissement => {
        const enrichissement = etablissement.enrichissement;
        const deepseekEnrichissement = etablissement.deepseekEnrichissement;
        const uniteLegale = etablissement.uniteLegale || {};
        
        const adresseComplete = [
            etablissement.numeroVoieEtablissement,
            etablissement.typeVoieEtablissement,
            etablissement.libelleVoieEtablissement,
            etablissement.complementAdresseEtablissement
        ].filter(Boolean).join(' ');

        return {
            siret: etablissement.siret,
            siren: uniteLegale.siren,
            denominationUniteLegale: uniteLegale.denominationUniteLegale || 
                                   uniteLegale.prenom1UniteLegale + ' ' + uniteLegale.nomUniteLegale || 
                                   'Non renseigné',
            activitePrincipaleEtablissement: etablissement.activitePrincipaleEtablissement,
            secteurActivite: enrichissement.secteurActivite,
            adresseComplete: adresseComplete,
            codePostalEtablissement: etablissement.codePostalEtablissement,
            libelleCommuneEtablissement: etablissement.libelleCommuneEtablissement,
            nombreEmployes: enrichissement.nombreEmployes,
            dateCreationUniteLegale: uniteLegale.dateCreationUniteLegale,
            anciennete: enrichissement.anciennete,
            scoreSolvabilite: enrichissement.scoreSolvabilite,
            classeRisque: enrichissement.classeRisque,
            noteCredit: enrichissement.noteCredit,
            viabilite: enrichissement.viabilite,
            croissanceEstimee: enrichissement.croissanceEstimee,
            chiffreAffairesEstime: enrichissement.chiffreAffairesEstime.toLocaleString('fr-FR'),
            etatAdministratifEtablissement: etablissement.etatAdministratifEtablissement,
            categorieJuridiqueUniteLegale: uniteLegale.categorieJuridiqueUniteLegale,
            adresseCompleteDeepSeek: deepseekEnrichissement?.adresseComplete || 'Non enrichi',
            domaineActiviteDeepSeek: deepseekEnrichissement?.domaineActivite || 'Non enrichi',
            nombreEmployesEstimeDeepSeek: deepseekEnrichissement?.nombreEmployesEstime || 'Non enrichi',
            typeOrganisationDeepSeek: deepseekEnrichissement?.typeOrganisation || 'Non enrichi',
            informationsEntrepriseDeepSeek: deepseekEnrichissement?.informationsEntreprise || 'Non enrichi',
            styleEntrepriseDeepSeek: deepseekEnrichissement?.styleEntreprise || 'Non enrichi'
        };
    });

    await csvWriter.writeRecords(records);
    console.log(`💾 Fichier CSV enrichi sauvegardé: ${filepath}`);
}

// Route pour lister les fichiers disponibles
app.get('/exports', (req, res) => {
    try {
        const files = fs.readdirSync(exportsDir)
            .filter(file => file.endsWith('.csv'))
            .map(file => {
                const filepath = path.join(exportsDir, file);
                const stats = fs.statSync(filepath);
                return {
                    filename: file,
                    size: stats.size,
                    sizeFormatted: (stats.size / 1024 / 1024).toFixed(2) + ' MB',
                    created: stats.birthtime,
                    modified: stats.mtime
                };
            })
            .sort((a, b) => new Date(b.created) - new Date(a.created));

        res.json({
            success: true,
            count: files.length,
            files: files
        });

    } catch (error) {
        console.error('Erreur lors de la liste des exports:', error);
        res.status(500).json({ 
            success: false, 
            message: 'Erreur lors de la liste des exports: ' + error.message 
        });
    }
});

// Route pour télécharger un fichier
app.get('/download/:filename', (req, res) => {
    try {
        const filename = req.params.filename;
        const filepath = path.join(exportsDir, filename);
        
        if (!fs.existsSync(filepath)) {
            return res.status(404).json({ 
                success: false, 
                message: 'Fichier non trouvé' 
            });
        }

        res.download(filepath, filename);

    } catch (error) {
        console.error('Erreur lors du téléchargement:', error);
        res.status(500).json({ 
            success: false, 
            message: 'Erreur lors du téléchargement: ' + error.message 
        });
    }
});

server.listen(port, () => {
    console.log(`🚀 ProspectIQ démarré sur http://localhost:${port}`);
    console.log(`📊 Fonctionnalités disponibles:`);
    console.log(`   • Récupération avec limites de sécurité (API INSEE)`);
    console.log(`   • Enrichissement avec scores financiers`);
    console.log(`   • Évaluation de la croissance et viabilité`);
    console.log(`   • Filtres avancés par effectif, secteur, score`);
    console.log(`   • Export CSV enrichi avec 25 colonnes`);
    console.log(`   • API REST complète pour intégration`);
    console.log(`   • 🆕 Système de cache intelligent`);
    console.log(`   • 🆕 Streaming temps réel avec WebSocket`);
    console.log(`   • 🤖 Enrichissement IA avec DeepSeek`);
    console.log(`⚙️ Limites de sécurité:`);
    console.log(`   • Max entreprises: ${MAX_COMPANIES_LIMIT.toLocaleString('fr-FR')}`);
    console.log(`   • Max pages: ${MAX_PAGES_LIMIT}`);
    console.log(`   • Seuil d'avertissement: ${WARN_THRESHOLD.toLocaleString('fr-FR')}`);
    console.log(`🤖 Configuration DeepSeek:`);
    console.log(`   • Modèle: ${DEEPSEEK_MODEL}`);
    console.log(`   • Taille des lots: ${DEEPSEEK_BATCH_SIZE} entreprises`);
    console.log(`   • Délai entre lots: ${DEEPSEEK_DELAY_MS}ms`);
    console.log(`   • Tentatives max: ${DEEPSEEK_MAX_RETRIES}`);
    console.log(`📍 Endpoints disponibles:`);
    console.log(`   • POST /search-optimized - Recherche interface (recommandé)`);
    console.log(`   • POST /search-stream - Recherche avec streaming`);
    console.log(`   • GET /exports - Liste des fichiers CSV`);
    console.log(`   • GET /download/:filename - Télécharger un fichier`);
});