/**
 * Service pour la gestion des templates de chantiers et l'auto-génération des phases
 */

import { TypeChantier, PhaseTemplate, ChantierTemplate } from '../types/chantier-templates';
import { PhaseChantier } from '../types/btp-extended';
import phaseTemplateService from './phaseTemplateService';

class ChantierTemplateService {
    
    /**
     * Récupérer la liste des types de chantiers disponibles
     */
    async getAvailableChantierTypes(): Promise<{ value: TypeChantier; label: string; categorie: string }[]> {
        return phaseTemplateService.getAvailableChantierTypes();
    }
    
    /**
     * Récupérer le template d'un type de chantier
     */
    async getTemplate(typeChantier: TypeChantier): Promise<ChantierTemplate> {
        const templates = await phaseTemplateService.getTemplatesByType(typeChantier);
        const dureeTotal = await phaseTemplateService.calculateDureeTotale(typeChantier);
        
        // Construire un ChantierTemplate à partir des données API
        return {
            typeChantier,
            nom: typeChantier,
            description: `Template pour ${typeChantier}`,
            dureeMoyenneJours: dureeTotal,
            phases: templates
        };
    }
    
    /**
     * Estimer la durée d'un projet selon son type
     */
    async estimateProjectDuration(typeChantier: TypeChantier): Promise<number> {
        return phaseTemplateService.calculateDureeTotale(typeChantier);
    }
    
    /**
     * Générer automatiquement les phases d'un chantier
     */
    async generatePhases(
        chantierId: string, 
        typeChantier: TypeChantier, 
        dateDebutProjet: Date,
        options?: {
            ajusterDelais?: boolean;
            inclureSousPhases?: boolean;
            personnaliser?: boolean;
        }
    ): Promise<PhaseChantier[]> {
        
        try {
            // Utiliser l'API backend pour générer les phases
            const phasesGenerees = await phaseTemplateService.generatePhases(
                chantierId,
                dateDebutProjet,
                options?.inclureSousPhases !== false // Par défaut true
            );
            
            return phasesGenerees;
            
        } catch (error) {
            console.error('Erreur lors de la génération des phases:', error);
            throw new Error('Impossible de générer les phases automatiquement');
        }
    }
    
    /**
     * Prévisualiser les phases qui seraient générées (sans les créer)
     */
    async previewPhases(typeChantier: TypeChantier, dateDebutProjet: Date): Promise<PhaseTemplate[]> {
        return phaseTemplateService.previewPhases(typeChantier);
    }
    
    /**
     * Obtenir les spécificités d'un type de chantier
     */
    async getSpecificites(typeChantier: TypeChantier): Promise<string[]> {
        const template = await this.getTemplate(typeChantier);
        return template.specificites || [];
    }
    
    /**
     * Obtenir les réglementations applicables
     */
    async getReglementations(typeChantier: TypeChantier): Promise<string[]> {
        const template = await this.getTemplate(typeChantier);
        return template.reglementations || [];
    }
    
    /**
     * Calculer le planning prévisionnel complet
     */
    async calculatePlanning(typeChantier: TypeChantier, dateDebutProjet: Date): Promise<{
        dateDebut: Date;
        dateFin: Date;
        dureeJours: number;
        phases: Array<{
            nom: string;
            dateDebut: Date;
            dateFin: Date;
            duree: number;
            critique: boolean;
        }>;
    }> {
        const template = await this.getTemplate(typeChantier);
        let currentDate = new Date(dateDebutProjet);
        
        const phases = template.phases.map(phase => {
            const phaseDebut = new Date(currentDate);
            const phaseFin = new Date(currentDate);
            phaseFin.setDate(phaseFin.getDate() + phase.dureePrevueJours);
            
            const phaseInfo = {
                nom: phase.nom,
                dateDebut: phaseDebut,
                dateFin: phaseFin,
                duree: phase.dureePrevueJours,
                critique: phase.critique
            };
            
            currentDate = new Date(phaseFin);
            return phaseInfo;
        });
        
        return {
            dateDebut: dateDebutProjet,
            dateFin: currentDate,
            dureeJours: template.dureeMoyenneJours,
            phases
        };
    }
    
    /**
     * Analyser la complexité d'un projet
     */
    async analyzeComplexity(typeChantier: TypeChantier): Promise<{
        niveau: 'SIMPLE' | 'MOYEN' | 'COMPLEXE' | 'TRES_COMPLEXE';
        score: number;
        facteurs: string[];
    }> {
        const complexiteAPI = await phaseTemplateService.analyzeComplexity(typeChantier);
        
        // Calculer des facteurs supplémentaires basés sur les données
        const facteurs: string[] = [];
        
        if (complexiteAPI.nombrePhases > 8) facteurs.push('Nombreuses phases');
        if (complexiteAPI.dureeTotal > 365) facteurs.push('Durée longue');
        if (complexiteAPI.nombrePhasesCritiques > 3) facteurs.push('Phases critiques multiples');
        
        // Calculer un score basé sur les données API
        let score = 0;
        score += complexiteAPI.nombrePhases * 2;
        score += Math.floor(complexiteAPI.dureeTotal / 30);
        score += complexiteAPI.nombrePhasesCritiques * 3;
        
        return {
            niveau: complexiteAPI.niveauComplexite as 'SIMPLE' | 'MOYEN' | 'COMPLEXE' | 'TRES_COMPLEXE',
            score,
            facteurs
        };
    }
}

export default new ChantierTemplateService();