from rest_framework.generics import ListAPIView, RetrieveAPIView
from django.shortcuts import get_object_or_404
from utils.pagination import NoPagination
from rest_framework.response import Response

from ..models import HadisCategory, Hadis, HadisCollection
from ..serializers import HadisListSerializer, HadisBasicSerializer, HadisDetailSerializer, HadisCollectionListSerializer, HadisSyncSerializer
from ..docs import hadis_list_swagger, hadis_detail_swagger, hadis_collections_swagger, hadis_sync_swagger, hadis_transmitters_swagger, hadis_corrections_swagger, hadis_basic_swagger


class HadisCollectionListView(ListAPIView):
    """
    API view to list all hadis collections
    """
    queryset = HadisCollection.objects.filter(status=True).order_by('order')
    serializer_class = HadisCollectionListSerializer
    pagination_class = NoPagination

    @hadis_collections_swagger
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)


class HadisSyncView(ListAPIView):
    """
    API view to sync all hadis data for offline mode
    """
    serializer_class = HadisSyncSerializer
    pagination_class = NoPagination

    def get_queryset(self):
        return Hadis.objects.filter(status=True).select_related(
            'category', 'hadis_status'
        ).prefetch_related(
            'tags',
            'transmitters__transmitter',
            'references__book_reference__images',
            'references__book_reference__authors',
            'hadiscorrection_set'
        ).order_by('id')

    @hadis_sync_swagger
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)
    
    def list(self, request, *args, **kwargs):
        queryset = self.get_queryset()
        serializer = self.get_serializer(queryset, many=True)

        response_data = {
            'count': queryset.count(),
            'results': serializer.data
        }
        
        return Response(response_data)


class HadisListView(ListAPIView):
    """
    API view to list Hadis by category_id
    """
    serializer_class = HadisListSerializer

    @hadis_list_swagger
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def get_queryset(self):
        category_id = self.kwargs.get('category_id')
        if not HadisCategory.objects.filter(id=category_id).exists():
            return Hadis.objects.none()
    
        return Hadis.objects.filter(
            category_id=category_id,
            status=True
        ).order_by('number')


class HadisBasicView(RetrieveAPIView):
    """
    API view to retrieve basic Hadis information by hadis_id
    """
    serializer_class = HadisBasicSerializer
    lookup_field = 'id'
    lookup_url_kwarg = 'hadis_id'

    @hadis_basic_swagger
    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

    def get_queryset(self):
        return Hadis.objects.filter(status=True)


class HadisDetailView(RetrieveAPIView):
    """
    API view to retrieve detailed Hadis information by hadis_id (excluding transmitters and corrections)
    """
    serializer_class = HadisDetailSerializer
    lookup_field = 'id'
    lookup_url_kwarg = 'hadis_id'

    @hadis_detail_swagger
    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

    def get_queryset(self):
        return Hadis.objects.filter(status=True).select_related(
            'category', 'hadis_status'
        ).prefetch_related(
            'tags',
            'references__book_reference__title',
            'references__book_reference__images',
            'references__book_reference__authors',
            'references__book_reference__id',
            'references__book_reference__description',
        )


class HadisTransmittersView(RetrieveAPIView):
    """
    API view to retrieve transmitters for a specific hadis
    """
    serializer_class = HadisDetailSerializer
    lookup_field = 'id'
    lookup_url_kwarg = 'hadis_id'

    @hadis_transmitters_swagger
    def get(self, request, *args, **kwargs):
        hadis = self.get_object()
        transmitters_data = []

        for transmitter_rel in hadis.transmitters.all().order_by('order'):
            transmitter_info = {
                'id': transmitter_rel.id,
                'order': transmitter_rel.order,
                'is_gap': transmitter_rel.is_gap,
                'narrator_layer': transmitter_rel.narrator_layer,
                'transmitter': {
                    'id': transmitter_rel.transmitter.id,
                    'full_name': transmitter_rel.transmitter.full_name,
                    'birth_year_hijri': transmitter_rel.transmitter.birth_year_hijri,
                    'death_year_hijri': transmitter_rel.transmitter.death_year_hijri,
                    'madhhab': transmitter_rel.transmitter.madhhab,
                    'description': transmitter_rel.transmitter.description,
                    'reliability': transmitter_rel.transmitter.reliability
                }
            }
            transmitters_data.append(transmitter_info)

        return Response({
            'hadis_id': hadis.id,
            'hadis_description': getattr(hadis, 'description', None),
            'transmitters_count': len(transmitters_data),
            'transmitters': transmitters_data
        })

    def get_queryset(self):
        return Hadis.objects.filter(status=True).prefetch_related('transmitters__transmitter')


class HadisCorrectionsView(RetrieveAPIView):
    """
    API view to retrieve corrections for a specific hadis
    """
    serializer_class = HadisDetailSerializer
    lookup_field = 'id'
    lookup_url_kwarg = 'hadis_id'

    @hadis_corrections_swagger
    def get(self, request, *args, **kwargs):
        hadis = self.get_object()
        corrections_data = []

        for correction in hadis.hadiscorrection_set.all():
            correction_info = {
                'id': correction.id,
                'title': correction.title,
                'description': correction.description,
                'translation': correction.translation
            }
            corrections_data.append(correction_info)

        return Response({
            'hadis_id': hadis.id,
            'corrections_count': len(corrections_data),
            'corrections': corrections_data
        })

    def get_queryset(self):
        return Hadis.objects.filter(status=True).prefetch_related('hadiscorrection_set')