from typing import List
from models import Student
from repositories.temporal_student_repository import TemporalStudentRepository
from services.temporal_assessment_services import (
    TemporalAssessmentProgressService, 
    TemporalStudentScoreCalculator,
    TemporalClassStatisticsService,
    TemporalProgressResult
)
from services.assessment_services import AssessmentStatisticsService, UnifiedGradingCalculator
from providers.concrete_providers import ConfigManagerProvider, SQLAlchemyDatabaseProvider


class TemporalAssessmentServicesFacade:
    """
    Facade temporelle qui remplace la facade standard.
    Intègre toute la logique temporelle de manière transparente.
    """
    
    def __init__(self, 
                 config_provider = None,
                 db_provider = None):
        # Injection des repositories temporels
        self.student_repo = TemporalStudentRepository()
        
        # Providers par défaut si non fournis
        if config_provider is None:
            config_provider = ConfigManagerProvider()
        if db_provider is None:
            db_provider = SQLAlchemyDatabaseProvider()
        
        # Services temporels
        self.grading_calculator = UnifiedGradingCalculator(config_provider)
        self.progress_service = TemporalAssessmentProgressService(db_provider, self.student_repo)
        self.score_calculator = TemporalStudentScoreCalculator(
            self.grading_calculator, db_provider, self.student_repo
        )
        self.statistics_service = AssessmentStatisticsService(self.score_calculator)
        self.class_statistics_service = TemporalClassStatisticsService(self.student_repo)
    
    def get_eligible_students(self, assessment) -> List[Student]:
        """Nouvelle méthode pour récupérer les élèves éligibles."""
        return self.student_repo.find_eligible_for_assessment(assessment)
    
    def get_grading_progress(self, assessment) -> TemporalProgressResult:
        """Progression avec logique temporelle."""
        return self.progress_service.calculate_grading_progress(assessment)
    
    def get_class_enrollment_summary(self, class_group_id: int, trimester: int = None):
        """Résumé des inscriptions pour une classe."""
        return self.class_statistics_service.get_class_enrollment_summary(class_group_id, trimester)
    
    # Compatibilité avec l'interface existante
    def get_assessment_statistics(self, assessment):
        """Statistiques d'évaluation (héritée du service existant)."""
        return self.statistics_service.get_assessment_statistics(assessment)


class TemporalAssessmentServicesFactory:
    """Factory pour créer les services temporels."""
    
    @staticmethod
    def create_temporal_facade(config_provider = None) -> TemporalAssessmentServicesFacade:
        """Crée une facade temporelle."""
        return TemporalAssessmentServicesFacade(config_provider)
    
    @staticmethod
    def create_temporal_student_repository() -> TemporalStudentRepository:
        """Crée un repository d'élèves temporel."""
        return TemporalStudentRepository()