Dovodi_Backend/apps/course/views/lesson.py

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(),
        tags=['Imam-Javad - Course'],
    )
    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

    @swagger_auto_schema(
        operation_description="Get detailed lesson information with navigation data",
        tags=["Imam-Javad - Course"],
        manual_parameters=[
            openapi.Parameter(
                'id', openapi.IN_PATH,
                description="Lesson ID",
                type=openapi.TYPE_INTEGER,
                required=True
            )
        ],
        responses={
            200: openapi.Response(
                description="Lesson details with navigation information",
                schema=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 LessonCompletionToggleAPIView(GenericAPIView):
    permission_classes = [IsAuthenticated]

    @swagger_auto_schema(
        operation_description="Toggle lesson completion status (Check/Uncheck)",
        tags=["Imam-Javad - Course"],
        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 toggle'),
            },
        ),
        responses={
            201: 'Lesson marked as COMPLETED.',
            200: 'Lesson marked as INCOMPLETE (Unchecked).',
            400: 'Lesson ID is required.',
            404: 'Lesson not found.',
        }
    )
    def post(self, request):
        student = request.user
        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)

        # TOGGLE LOGIC
        # Try to find an existing completion record
        completion = LessonCompletion.objects.filter(student=student, course_lesson=course_lesson).first()

        if completion:
            # Scenario: The user clicked by mistake or wants to un-check
            # Action: Delete the record
            completion.delete()
            return Response(
                {'message': 'Lesson marked as incomplete.', 'is_completed': False}, 
                status=status.HTTP_200_OK
            )
        else:
            # Scenario: The lesson is not finished yet
            # Action: Create the record
            LessonCompletion.objects.create(student=student, course_lesson=course_lesson)
            return Response(
                {'message': 'Lesson completed successfully.', 'is_completed': True}, 
                status=status.HTTP_201_CREATED
            )