from rest_framework.generics import ListAPIView, RetrieveAPIView, GenericAPIView

from drf_yasg.utils import swagger_auto_schema
from drf_yasg import openapi
from django.shortcuts import get_object_or_404
from rest_framework import status
from rest_framework.response import Response

from apps.course.serializers import (
    CourseLessonSerializer
)
from apps.course.models import Course, CourseLesson, LessonCompletion
from apps.course.doc import *
from utils.exceptions import AppAPIException 
from rest_framework.permissions import IsAuthenticated



class LessonListView(ListAPIView):
    serializer_class = CourseLessonSerializer

    @swagger_auto_schema(
        operation_description=doc_courses_lesson(),
    )
    def get(self, request, *args, **kwargs):
        return super().get(request, *args, **kwargs)
    
    def get_queryset(self):
        """
        Optimized queryset with select_related and prefetch_related for lesson relationships
        """
        course_slug = self.kwargs.get('slug')
        course = get_object_or_404(Course, slug=course_slug)

        return CourseLesson.objects.select_related(
            'course',
            'lesson'
        ).prefetch_related(
            'completions',
            'quizzes'
        ).filter(
            course=course,
            is_active=True
        ).order_by('priority', 'id')




class LessonDetailView(RetrieveAPIView):
    serializer_class = CourseLessonSerializer

    def get(self, request, *args, **kwargs):
        """
        Optimized lesson detail view with select_related for relationships
        """
        lesson_id = self.kwargs.get('id')
        course_lesson = get_object_or_404(
            CourseLesson.objects.select_related('course', 'lesson'),
            id=lesson_id,
            is_active=True
        )

        course = course_lesson.course
        lessons = CourseLesson.objects.select_related(
            'lesson'
        ).filter(
            course=course,
            is_active=True
        ).order_by('priority')

        total_lessons = lessons.count()
        current_lesson_number = list(lessons.values_list('id', flat=True)).index(course_lesson.id) + 1
        next_lesson = lessons.filter(priority__gt=course_lesson.priority).order_by('priority').first()
        next_lesson_id = next_lesson.id if next_lesson else None
        previous_lesson = lessons.filter(priority__lt=course_lesson.priority).order_by('-priority').first()
        previous_lesson_id = previous_lesson.id if previous_lesson else None

        lesson_data = self.get_serializer(course_lesson).data
        lesson_data['total_lessons'] = total_lessons
        lesson_data['current_lesson_number'] = current_lesson_number
        lesson_data['next_lesson_id'] = next_lesson_id
        lesson_data['previous_lesson_id'] = previous_lesson_id
        lesson_data['can_go_next'] = next_lesson is not None

        return Response(lesson_data)



class LessonCompletionCreateAPIView(GenericAPIView):
    permission_classes = [IsAuthenticated]


    @swagger_auto_schema(
        request_body=openapi.Schema(
            type=openapi.TYPE_OBJECT,
            required=['lesson_id'],
            properties={
                'lesson_id': openapi.Schema(type=openapi.TYPE_INTEGER, description='ID of the lesson to be marked as completed'),
            },
        ),
        responses={
            201: 'Lesson completed successfully.',
            200: 'Lesson already completed.',
            400: 'Lesson ID is required.',
            404: 'Lesson not found.',
        }
    )
    def post(self, request):
        student = request.user  # Assuming the user is the student
        lesson_id = request.data.get('lesson_id')

        if not lesson_id:
            return Response({'error': 'Lesson ID is required.'}, status=status.HTTP_400_BAD_REQUEST)
        try:
            course_lesson = CourseLesson.objects.get(id=lesson_id)
        except CourseLesson.DoesNotExist:
            return Response({'error': 'Lesson not found.'}, status=status.HTTP_404_NOT_FOUND)

        # Check if the lesson is already completed by the student
        if LessonCompletion.objects.filter(student=student, course_lesson=course_lesson).exists():
            return Response({'message': 'Lesson already completed.'}, status=status.HTTP_200_OK)

        # Create a new completion record
        completion = LessonCompletion(student=student, course_lesson=course_lesson)
        completion.save()

        return Response({'message': 'Lesson completed successfully.'}, status=status.HTTP_201_CREATED)