from django.db.models import Q


from cis.models.roster import Advocate_for_lokadalat, Roster
from cis.serializers.roster import AdvocateLokAdalatSerializer, RosterBenchSerializer, RosterHeadingSerializer, RosterListSerializer, RosterSerializer, RosterSessionSerializer, RosterSittingSerializer
from rest_framework import viewsets, permissions
from drf_yasg import openapi
from drf_yasg.utils import swagger_auto_schema
from rest_framework import generics, status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework import viewsets, permissions

from hrms.models.user import Advocate
from django.utils.timezone import now

from hrms.serializers.user import AdvocateDetailSerializer
from django.db import transaction

from masters.models.admin_master_tables import RosterBench, RosterHeadings, RosterSession, RosterSitting
 
class RosterBenchViewSet(viewsets.ModelViewSet):
    queryset = RosterBench.objects.all().order_by('-created_at')
    default_serializer_class = RosterBenchSerializer
    serializer_class = RosterBenchSerializer
    #permission_classes = [permissions.IsAuthenticated]  # Only authenticated users can access

    def perform_create(self, serializer):
        """ Set the created_by user when creating a new City. """
        serializer.save()

    def perform_update(self, serializer):
        """ Set the updated_by user when updating a City. """
        serializer.save()
        
        
    @action(detail=False, methods=['GET'], name='Get Roster Bench By Bench Id')
    @swagger_auto_schema(
        # query_serializer=MyQueryParamSerializer,
        manual_parameters=[
            openapi.Parameter(
                'bench_id',
                openapi.IN_QUERY,
                description="bench_id Query Param",
                type=openapi.TYPE_INTEGER,
             ),
        ],
    )
    def get_roster_bench_by_bench(self, request):
        bench_id = self.request.query_params.get("bench_id")
         

        # Basic validation for required query params
       
        if not all([bench_id]):
            return Response(
                {"error": "Missing required query parameters: bench_id"},
                status=status.HTTP_400_BAD_REQUEST
            )

        try:
            roster_bench = RosterBench.objects.filter(
                bench_id=bench_id
            ) 

            if not roster_bench:
                return Response(
                    {"error": "No matching record found."},
                    status=status.HTTP_404_NOT_FOUND
                )

            serializer = RosterBenchSerializer(roster_bench,many=True)
            filtered_data = [{'id': item['id'], 'name': item['bench_no']} for item in serializer.data]
            return Response(filtered_data,status=status.HTTP_200_OK)
        

        except Exception as e:
            return Response(
                {"error": "An unexpected error occurred.", "details": str(e)},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )
class RosterSessionViewSet(viewsets.ModelViewSet):
    queryset = RosterSession.objects.all().order_by('-created_at')
    default_serializer_class = RosterSessionSerializer
    serializer_class = RosterSessionSerializer
    #permission_classes = [permissions.IsAuthenticated]  # Only authenticated users can access

    def perform_create(self, serializer):
        """ Set the created_by user when creating a new City. """
        serializer.save()

    def perform_update(self, serializer):
        """ Set the updated_by user when updating a City. """
        serializer.save()
        
    @action(detail=False, methods=["GET"], name="DDL List")     
    def ddl(self, request, *args, **kwargs):         
         
        data_list=RosterSession.objects.all()
        data_list_serializr = self.default_serializer_class(
            data_list, read_only=True, many=True
        )    
        filtered_data = [{'id': item['id'], 'name': item['title']} for item in data_list_serializr.data]
        return Response(filtered_data)
class RosterHeadingViewSet(viewsets.ModelViewSet):
    queryset = RosterHeadings.objects.all().order_by('-created_at')
    default_serializer_class = RosterHeadingSerializer
    serializer_class = RosterHeadingSerializer
    #permission_classes = [permissions.IsAuthenticated]  # Only authenticated users can access

    def perform_create(self, serializer):
        """ Set the created_by user when creating a new City. """
        serializer.save()

    def perform_update(self, serializer):
        """ Set the updated_by user when updating a City. """
        serializer.save()
        
    @action(detail=False, methods=["GET"], name="DDL List")     
    def ddl(self, request, *args, **kwargs):         
         
        data_list=RosterHeadings.objects.all()
        data_list_serializr = self.default_serializer_class(
            data_list, read_only=True, many=True
        )    
        filtered_data = [{'id': item['id'], 'name': item['title']} for item in data_list_serializr.data]
        return Response(filtered_data)
class RosterSittingViewSet(viewsets.ModelViewSet):
    queryset = RosterSitting.objects.all().order_by('-created_at')
    default_serializer_class = RosterSittingSerializer
    serializer_class = RosterSittingSerializer
    #permission_classes = [permissions.IsAuthenticated]  # Only authenticated users can access

    def perform_create(self, serializer):
        """ Set the created_by user when creating a new City. """
        serializer.save()

    def perform_update(self, serializer):
        """ Set the updated_by user when updating a City. """
        serializer.save()
        
    @action(detail=False, methods=["GET"], name="DDL List")     
    def ddl(self, request, *args, **kwargs):         
         
        data_list=RosterSitting.objects.all()
        data_list_serializr = self.default_serializer_class(
            data_list, read_only=True, many=True
        )    
        filtered_data = [{'id': item['id'], 'name': item['title']} for item in data_list_serializr.data]
        return Response(filtered_data)
    
class AdvocateLokAdalatgViewSet(viewsets.ModelViewSet):
    queryset = Advocate_for_lokadalat.objects.all().order_by('-created_at')
    default_serializer_class = AdvocateLokAdalatSerializer
    serializer_class = AdvocateLokAdalatSerializer
    #permission_classes = [permissions.IsAuthenticated]  # Only authenticated users can access

    def perform_create(self, serializer):
        """ Set the created_by user when creating a new City. """
        serializer.save()

    def perform_update(self, serializer):
        """ Set the updated_by user when updating a City. """
        serializer.save()
        
    @action(detail=False, methods=["GET"], name="DDL List")     
    def ddl(self, request, *args, **kwargs):         
         
        #data_list = Advocate_for_lokadalat.objects.select_related('advocate').all()
        
        current_time = now()

        advocates = Advocate.objects.filter(
            roster_advocate__display='Y',
            roster_advocate__from_date__lte=current_time,
            roster_advocate__to_date__gte=current_time,
        ).distinct()

        data_list_serializr = AdvocateDetailSerializer(
            advocates, read_only=True, many=True
        )    
        print(data_list_serializr.data)

        filtered_data = [{'id': item['id'], 'name': item['name']} for item in data_list_serializr.data]
        return Response(filtered_data)
        
 

class RosterViewSet(viewsets.ModelViewSet):
    queryset = Roster.objects.all()
    serializer_class = RosterSerializer
    serializer_classes = {
        "update": RosterSerializer, # update
        "retrieve": RosterListSerializer, "get item by id "
        "create": RosterSerializer, #save
        "list": RosterListSerializer, ##"all objects list"
        # ... other actions
    }
    default_serializer_class = RosterSerializer

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        try:
            with transaction.atomic():
                self.perform_create(serializer)
        except Exception as e:
            return Response({'detail': str(e)}, status=status.HTTP_400_BAD_REQUEST)

        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    @action(detail=False, methods=['get'], name="DDL List")
    def ddl(self, request):
        # Example optional helper endpoint for DDLs if needed
        return Response({"message": "Optional dropdown list data can be handled here."})