import pytest
from datetime import date
from models import db, Assessment, ClassGroup, Exercise, GradingElement
from repositories.assessment_repository import AssessmentRepository


class TestAssessmentRepository:
    """Tests pour le repository Assessment."""
    
    def test_find_by_id(self, app):
        """Test de recherche par ID."""
        with app.app_context():
            repo = AssessmentRepository()
            
            # Créer des données de test
            class_group = ClassGroup(name="6A", year="2023-2024")
            db.session.add(class_group)
            db.session.commit()
            
            assessment = Assessment(
                title="Test Assessment",
                trimester=1,
                class_group_id=class_group.id,
                date=date(2023, 10, 15)
            )
            db.session.add(assessment)
            db.session.commit()
            
            # Test
            found = repo.find_by_id(assessment.id)
            assert found is not None
            assert found.title == "Test Assessment"
            assert found.id == assessment.id
    
    def test_find_all(self, app):
        """Test de recherche de tous les éléments."""
        with app.app_context():
            repo = AssessmentRepository()
            
            # Créer des données de test
            class_group = ClassGroup(name="6A", year="2023-2024")
            db.session.add(class_group)
            db.session.commit()
            
            assessment1 = Assessment(
                title="Assessment 1",
                trimester=1,
                class_group_id=class_group.id,
                date=date(2023, 10, 15)
            )
            assessment2 = Assessment(
                title="Assessment 2",
                trimester=2,
                class_group_id=class_group.id,
                date=date(2023, 12, 15)
            )
            db.session.add_all([assessment1, assessment2])
            db.session.commit()
            
            # Test
            all_assessments = repo.find_all()
            assert len(all_assessments) >= 2
            titles = [a.title for a in all_assessments]
            assert "Assessment 1" in titles
            assert "Assessment 2" in titles
    
    def test_find_by_filters_trimester(self, app):
        """Test de recherche par trimestre."""
        with app.app_context():
            repo = AssessmentRepository()
            
            # Créer des données de test
            class_group = ClassGroup(name="6A", year="2023-2024")
            db.session.add(class_group)
            db.session.commit()
            
            assessment1 = Assessment(
                title="Assessment T1",
                trimester=1,
                class_group_id=class_group.id,
                date=date(2023, 10, 15)
            )
            assessment2 = Assessment(
                title="Assessment T2",
                trimester=2,
                class_group_id=class_group.id,
                date=date(2023, 12, 15)
            )
            db.session.add_all([assessment1, assessment2])
            db.session.commit()
            
            # Test
            t1_assessments = repo.find_by_filters(trimester=1)
            assert len(t1_assessments) >= 1
            assert all(a.trimester == 1 for a in t1_assessments)
            
            t2_assessments = repo.find_by_filters(trimester=2)
            assert len(t2_assessments) >= 1
            assert all(a.trimester == 2 for a in t2_assessments)
    
    def test_find_by_filters_class_id(self, app):
        """Test de recherche par classe."""
        with app.app_context():
            repo = AssessmentRepository()
            
            # Créer des données de test
            class_group1 = ClassGroup(name="6A", year="2023-2024")
            class_group2 = ClassGroup(name="6B", year="2023-2024")
            db.session.add_all([class_group1, class_group2])
            db.session.commit()
            
            assessment1 = Assessment(
                title="Assessment 6A",
                trimester=1,
                class_group_id=class_group1.id,
                date=date(2023, 10, 15)
            )
            assessment2 = Assessment(
                title="Assessment 6B",
                trimester=1,
                class_group_id=class_group2.id,
                date=date(2023, 10, 15)
            )
            db.session.add_all([assessment1, assessment2])
            db.session.commit()
            
            # Test
            class1_assessments = repo.find_by_filters(class_id=class_group1.id)
            assert len(class1_assessments) >= 1
            assert all(a.class_group_id == class_group1.id for a in class1_assessments)
            
            class2_assessments = repo.find_by_filters(class_id=class_group2.id)
            assert len(class2_assessments) >= 1
            assert all(a.class_group_id == class_group2.id for a in class2_assessments)
    
    def test_find_with_full_details(self, app):
        """Test de recherche avec tous les détails."""
        with app.app_context():
            repo = AssessmentRepository()
            
            # Créer des données de test
            class_group = ClassGroup(name="6A", year="2023-2024")
            db.session.add(class_group)
            db.session.commit()
            
            assessment = Assessment(
                title="Test Assessment",
                trimester=1,
                class_group_id=class_group.id,
                date=date(2023, 10, 15)
            )
            db.session.add(assessment)
            db.session.commit()
            
            exercise = Exercise(
                title="Exercise 1",
                assessment_id=assessment.id
            )
            db.session.add(exercise)
            db.session.commit()
            
            grading_element = GradingElement(
                label="Question 1",
                max_points=5.0,
                exercise_id=exercise.id
            )
            db.session.add(grading_element)
            db.session.commit()
            
            # Test
            found = repo.find_with_full_details(assessment.id)
            assert found is not None
            assert found.title == "Test Assessment"
            assert found.class_group is not None
            assert found.class_group.name == "6A"
            assert len(found.exercises) >= 1
            assert found.exercises[0].title == "Exercise 1"
            assert len(found.exercises[0].grading_elements) >= 1
            assert found.exercises[0].grading_elements[0].label == "Question 1"
    
    def test_find_recent(self, app):
        """Test de recherche des évaluations récentes."""
        with app.app_context():
            repo = AssessmentRepository()
            
            # Créer des données de test
            class_group = ClassGroup(name="6A", year="2023-2024")
            db.session.add(class_group)
            db.session.commit()
            
            # Créer plusieurs assessments avec dates différentes
            assessments = []
            for i in range(7):
                assessment = Assessment(
                    title=f"Assessment {i}",
                    trimester=1,
                    class_group_id=class_group.id,
                    date=date(2023, 10, i + 1)
                )
                assessments.append(assessment)
            
            db.session.add_all(assessments)
            db.session.commit()
            
            # Test
            recent = repo.find_recent(limit=5)
            assert len(recent) == 5
            
            # Vérifier que c'est trié par date décroissante
            dates = [a.date for a in recent]
            assert dates == sorted(dates, reverse=True)
    
    def test_save_and_commit(self, app):
        """Test de sauvegarde."""
        with app.app_context():
            repo = AssessmentRepository()
            
            # Créer des données de test
            class_group = ClassGroup(name="6A", year="2023-2024")
            db.session.add(class_group)
            db.session.commit()
            
            # Créer un assessment
            assessment = Assessment(
                title="New Assessment",
                trimester=1,
                class_group_id=class_group.id,
                date=date(2023, 10, 15)
            )
            
            # Test save
            saved = repo.save(assessment)
            assert saved is assessment
            
            # L'objet est dans la session mais pas encore committé
            assert assessment.id is None  # Pas d'ID tant qu'on n'a pas flush/commit
            
            # Commit
            repo.commit()
            
            # Maintenant en base avec un ID
            assert assessment.id is not None
            found = Assessment.query.filter_by(title="New Assessment").first()
            assert found is not None
            assert found.title == "New Assessment"
    
    def test_delete(self, app):
        """Test de suppression."""
        with app.app_context():
            repo = AssessmentRepository()
            
            # Créer des données de test
            class_group = ClassGroup(name="6A", year="2023-2024")
            db.session.add(class_group)
            db.session.commit()
            
            assessment = Assessment(
                title="To Delete",
                trimester=1,
                class_group_id=class_group.id,
                date=date(2023, 10, 15)
            )
            db.session.add(assessment)
            db.session.commit()
            assessment_id = assessment.id
            
            # Vérifier qu'il existe
            found = repo.find_by_id(assessment_id)
            assert found is not None
            
            # Supprimer
            repo.delete(assessment)
            repo.commit()
            
            # Vérifier qu'il n'existe plus
            found = repo.find_by_id(assessment_id)
            assert found is None