from rest_framework import serializers
from .models import Teacher, Speciality, SchoolClass, Planning, LEVEL_CHOICES
from Subscriptions.models import RegistrationForm
from Subscriptions.serializers import StudentSerializer
from Auth.serializers import ProfileSerializer
from Auth.models import Profile
from N3wtSchool import settings, bdd
from django.utils import timezone
import pytz

class SpecialitySerializer(serializers.ModelSerializer):
    creationDateFormatted = serializers.SerializerMethodField()

    class Meta:
        model = Speciality
        fields = '__all__'

    def get_creationDateFormatted(self, obj):
        utc_time = timezone.localtime(obj.updatedDate) # Convert to local time
        local_tz = pytz.timezone(settings.TZ_APPLI)
        local_time = utc_time.astimezone(local_tz)

        return local_time.strftime("%d-%m-%Y %H:%M")

class TeacherDetailSerializer(serializers.ModelSerializer):
    specialities = SpecialitySerializer(many=True, read_only=True)

    class Meta:
        model = Teacher
        fields = ['id', 'lastName', 'firstName', 'email', 'specialities']

class TeacherSerializer(serializers.ModelSerializer):
    specialities = SpecialitySerializer(many=True, read_only=True)
    specialties_ids = serializers.PrimaryKeyRelatedField(queryset=Speciality.objects.all(), many=True, source='specialities')
    associatedProfile_id = serializers.PrimaryKeyRelatedField(queryset=Profile.objects.all(), source='associatedProfile', write_only=False, read_only=False)
    mainClasses = serializers.PrimaryKeyRelatedField(many=True, read_only=True, source='schoolClasses')
    associatedProfile = ProfileSerializer(read_only=True)
    rightLabel = serializers.SerializerMethodField()
    rightValue = serializers.SerializerMethodField()
    creationDateFormatted = serializers.SerializerMethodField()

    class Meta:
        model = Teacher
        fields = ['id', 'lastName', 'firstName', 'email', 'specialities', 'specialties_ids', 'mainClasses', 'associatedProfile', 'associatedProfile_id', 'rightLabel', 'rightValue', 'updatedDate', 'creationDateFormatted']

    def create(self, validated_data):
        specialties_data = validated_data.pop('specialities', None)
        associatedProfile = validated_data.pop('associatedProfile', None)
        teacher = Teacher.objects.create(**validated_data)
        teacher.specialities.set(specialties_data)
        if associatedProfile:
            teacher.associatedProfile = associatedProfile
        teacher.save()
        return teacher

    def update(self, instance, validated_data):
        specialties_data = validated_data.pop('specialities', [])
        instance.lastName = validated_data.get('lastName', instance.lastName)
        instance.firstName = validated_data.get('firstName', instance.firstName)
        instance.email = validated_data.get('email', instance.email)
        instance.associatedProfile = validated_data.get('associatedProfile', instance.associatedProfile)
        instance.save()
        instance.specialities.set(specialties_data)
        return instance

    def get_rightLabel(self, obj): 
        return obj.associatedProfile.get_right_display() if obj.associatedProfile else None

    def get_rightValue(self, obj): 
        return obj.associatedProfile.right if obj.associatedProfile else None

    def get_creationDateFormatted(self, obj):
        utc_time = timezone.localtime(obj.updatedDate) # Convert to local time
        local_tz = pytz.timezone(settings.TZ_APPLI)
        local_time = utc_time.astimezone(local_tz)
        return local_time.strftime("%d-%m-%Y %H:%M")

class PlanningSerializer(serializers.ModelSerializer):
    class Meta:
        model = Planning
        fields = ['id', 'level', 'schedule']

    def to_internal_value(self, data):
        internal_value = super().to_internal_value(data)
        internal_value['schedule'] = data.get('schedule', {})
        return internal_value

class SchoolClassSerializer(serializers.ModelSerializer):
    creationDateFormatted = serializers.SerializerMethodField()
    teachers = TeacherSerializer(many=True, read_only=True)
    teachers_ids = serializers.PrimaryKeyRelatedField(queryset=Teacher.objects.all(), many=True, source='teachers')
    students = serializers.SerializerMethodField()
    levels = serializers.ListField(child=serializers.ChoiceField(choices=LEVEL_CHOICES))
    plannings_read = serializers.SerializerMethodField()
    plannings = PlanningSerializer(many=True, write_only=True)

    class Meta:
        model = SchoolClass
        fields = [
            'id', 'atmosphereName', 'ageGroup', 'numberOfStudents', 'teachingLanguage',
            'teachers', 'teachers_ids', 'schoolYear', 'updatedDate',
            'creationDateFormatted', 'students', 'levels', 'type', 'schedule',
            'openingDays', 'plannings', 'plannings_read'
        ]

    def create(self, validated_data):
        teachers_data = validated_data.pop('teachers', [])
        levels_data = validated_data.pop('levels', [])
        plannings_data = validated_data.pop('plannings', [])
        
        classModel = SchoolClass.objects.create(
            atmosphereName=validated_data.get('atmosphereName', ''),
            ageGroup=validated_data.get('ageGroup', []),
            numberOfStudents=validated_data.get('numberOfStudents', 0),
            teachingLanguage=validated_data.get('teachingLanguage', ''),
            schoolYear=validated_data.get('schoolYear', ''),
            levels=levels_data,
            type=validated_data.get('type', 1),  # Added here
            schedule=validated_data.get('schedule', ['08:30', '17:30']),  # Added here
            openingDays=validated_data.get('openingDays', [1, 2, 4, 5])  # Added here
        )

        classModel.teachers.set(teachers_data)

        for planning_data in plannings_data:
            Planning.objects.create(
                classModel=classModel,
                level=planning_data['level'],
                schedule=planning_data.get('schedule', {})
            )

        return classModel

    def update(self, instance, validated_data):
        teachers_data = validated_data.pop('teachers', [])
        levels_data = validated_data.pop('levels', [])
        plannings_data = validated_data.pop('plannings', [])

        instance.atmosphereName = validated_data.get('atmosphereName', instance.atmosphereName)
        instance.ageGroup = validated_data.get('ageGroup', instance.ageGroup)
        instance.numberOfStudents = validated_data.get('numberOfStudents', instance.numberOfStudents)
        instance.teachingLanguage = validated_data.get('teachingLanguage', instance.teachingLanguage)
        instance.schoolYear = validated_data.get('schoolYear', instance.schoolYear)
        instance.levels = levels_data
        instance.type = validated_data.get('type', instance.type)  # Added here
        instance.schedule = validated_data.get('schedule', instance.schedule)  # Added here
        instance.openingDays = validated_data.get('openingDays', instance.openingDays)  # Added here

        instance.save()
        instance.teachers.set(teachers_data)

        existing_plannings = {planning.level: planning for planning in instance.plannings.all()}

        for planning_data in plannings_data:
            level = planning_data['level']
            if level in existing_plannings:
                # Update existing planning
                planning = existing_plannings[level]
                planning.schedule = planning_data.get('schedule', planning.schedule)
                planning.save()
            else:
                # Create new planning if level not existing
                Planning.objects.create(
                    classModel=instance,
                    level=level,
                    schedule=planning_data.get('schedule', {})
                )

        return instance

    def get_creationDateFormatted(self, obj):
        utc_time = timezone.localtime(obj.updatedDate)
        local_tz = pytz.timezone(settings.TZ_APPLI)
        local_time = utc_time.astimezone(local_tz)
        return local_time.strftime("%d-%m-%Y %H:%M")

    def get_students(self, obj):
        studentsList = obj.students.all()
        filtered_students = []
        for student in studentsList:
            registrationForm = bdd.getObject(RegistrationForm, "student__id", student.id)
            if registrationForm.status == registrationForm.RegistrationFormStatus.RF_VALIDATED:
                filtered_students.append(student)
        return StudentSerializer(filtered_students, many=True, read_only=True).data

    def get_plannings_read(self, obj):
        plannings = obj.plannings.all()
        levels_dict = {level: {'level': level, 'planning': None} for level in obj.levels}
        
        for planning in plannings:
            if planning.level in levels_dict:
                levels_dict[planning.level]['planning'] = PlanningSerializer(planning).data
        
        return list(levels_dict.values())