from rest_framework import serializers
 
from cis.models import casedetails
from masters.models.admin_master_tables import Act, ActSectionDetails, ActSubsectionDetails, CheckerCategory
from cis.models.roster import Advocate_for_lokadalat, Roster, RosterBench,  RosterJudge, RosterMatter, RosterSession
from hrms.models.user import JRPUser
from django.utils import timezone
from django.db import transaction
 
 
from masters.models.admin_master_tables import RosterHeadings, RosterSitting
from masters.serializers.baseuser import BaseUserSerializer

class RosterBenchSerializer(BaseUserSerializer):
    
     
    class Meta:
        model = RosterBench
        exclude= ['created_by','updated_by','created_at','updated_at']

    def create(self, validated_data):        
        request = self.context.get("request")
        current_user = request.user if request and request.user.is_authenticated else None       
        # Get the model dynamically
        model_class = self.Meta.model         
        
        if hasattr(model_class, "created_by") and current_user:
            validated_data["created_by"] = current_user.id        
        
        instance = model_class.objects.create(**validated_data)
        return instance
    
class RosterSessionSerializer(BaseUserSerializer):
    
     
    class Meta:
        model = RosterSession
        exclude= ['created_by','updated_by','created_at','updated_at']

    def create(self, validated_data):        
        request = self.context.get("request")
        current_user = request.user if request and request.user.is_authenticated else None       
        # Get the model dynamically
        model_class = self.Meta.model         
        
        if hasattr(model_class, "created_by") and current_user:
            validated_data["created_by"] = current_user.id        
        
        instance = model_class.objects.create(**validated_data)
        return instance
class RosterHeadingSerializer(BaseUserSerializer):
    
     
    class Meta:
        model = RosterHeadings
        exclude= ['created_by','updated_by','created_at','updated_at']

    def create(self, validated_data):        
        request = self.context.get("request")
        current_user = request.user if request and request.user.is_authenticated else None       
        # Get the model dynamically
        model_class = self.Meta.model         
        
        if hasattr(model_class, "created_by") and current_user:
            validated_data["created_by"] = current_user.id        
        
        instance = model_class.objects.create(**validated_data)
        return instance
class RosterSittingSerializer(BaseUserSerializer):
    
     
    class Meta:
        model = RosterSitting
        exclude= ['created_by','updated_by','created_at','updated_at']

    def create(self, validated_data):        
        request = self.context.get("request")
        current_user = request.user if request and request.user.is_authenticated else None       
        # Get the model dynamically
        model_class = self.Meta.model         
        
        if hasattr(model_class, "created_by") and current_user:
            validated_data["created_by"] = current_user.id        
        
        instance = model_class.objects.create(**validated_data)
        return instance
    
class AdvocateLokAdalatSerializer(BaseUserSerializer):
    
     
    class Meta:
        model = Advocate_for_lokadalat
        exclude= ['created_by','updated_by','created_at','updated_at']
    def validate(self, data):
        advocate = data.get('advocate')
        from_date = data.get('from_date')
        to_date = data.get('to_date')
        
        existing = Advocate_for_lokadalat.objects.filter(
            advocate=advocate,
            from_date__lt=to_date,
            to_date__gt=from_date
        ).exists()

        if existing:
            raise serializers.ValidationError("Date range overlaps with an existing entry for this advocate.")

        # 1. Advocate must be selected
        if not advocate:
            raise serializers.ValidationError({"advocate": "Advocate must be selected."})

        # 2. Check both dates are provided
        if not from_date :
            raise serializers.ValidationError("from_date' is required.")

        # 3. from_date must be earlier than to_date
        if from_date >= to_date:
            raise serializers.ValidationError({"from_date": "'from_date' must be earlier than 'to_date'."})

        # 4. Optional: Ensure from_date and to_date are not in the past
        if from_date < timezone.now():
            raise serializers.ValidationError({"from_date": "'from_date' cannot be in the past."})
        

        return data

    def create(self, validated_data):        
        request = self.context.get("request")
        current_user = request.user if request and request.user.is_authenticated else None       
        # Get the model dynamically
        model_class = self.Meta.model         
        
        if hasattr(model_class, "created_by") and current_user:
            validated_data["created_by"] = current_user.id        
        
        instance = model_class.objects.create(**validated_data)
        return instance
    
 

class RosterJudgeSerializer(serializers.ModelSerializer):
    class Meta:
        model = RosterJudge
        fields = ['judge', 'judge_type', 'position']

class RosterMatterSerializer(serializers.ModelSerializer):
    class Meta:
        model = RosterMatter
        fields = ['matter']

class RosterListSerializer(serializers.ModelSerializer):
    judges = RosterJudgeSerializer(many=True, read_only=True)
    matters = RosterMatterSerializer(many=True, read_only=True)

    class Meta:
        model = Roster
        fields = [
            'id', 'branch', 'bench', 'benchno', 'matter_ids',
            'roster_session', 'from_date', 'to_date',
            'display', 'courtno', 'm_f', 'from_time',
            'total_cases', 'session', 'bench_fail',
            'created_by', 'updated_by', 'judges', 'matters'
        ]
class RosterSerializer(serializers.ModelSerializer):
    judges = RosterJudgeSerializer(many=True)
    matters = RosterMatterSerializer(many=True)

    class Meta:
        model = Roster
        fields = [
            'id', 'branch', 'bench', 'benchno', 'matter_ids',
            'roster_session', 'from_date', 'to_date',
            'display', 'courtno', 'm_f', 'from_time',
            'total_cases', 'session', 'bench_fail',
            'created_by', 'updated_by', 'judges', 'matters'
        ]
    @transaction.atomic
    def create(self, validated_data):
        judges_data = validated_data.pop('judges', [])
        matters_data = validated_data.pop('matters', [])

        with transaction.atomic():
            roster = Roster.objects.create(**validated_data)

            # Create related judges
            RosterJudge.objects.bulk_create([
                RosterJudge(roster=roster, **judge) for judge in judges_data
            ])

            # Create related matters
            RosterMatter.objects.bulk_create([
                RosterMatter(roster=roster, **matter) for matter in matters_data
            ])

        return roster
    @transaction.atomic
    def update(self, instance, validated_data):
        judges_data = validated_data.pop('judges', [])
        matters_data = validated_data.pop('matters', [])

        # Update main Roster fields
        for attr, value in validated_data.items():
            setattr(instance, attr, value)
        instance.save()

        # Replace related judges
        instance.judges.all().delete()
        RosterJudge.objects.bulk_create([
            RosterJudge(roster=instance, **judge) for judge in judges_data
        ])

        # Replace related matters
        instance.matters.all().delete()
        RosterMatter.objects.bulk_create([
            RosterMatter(roster=instance, **matter) for matter in matters_data
        ])

        return instance