from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth.views import LoginView
from django.contrib.auth import login
from django.contrib.auth.decorators import login_required
from django.urls import reverse_lazy
from django.views.generic import CreateView
from django.contrib import messages
from django.db import models as dj_models
from django.db.models import Avg, ExpressionWrapper, FloatField, Count
from django.utils.text import slugify
import uuid

from .forms import DualRegistrationForm, RatingForm, TeacherProfileForm, StudentProfileForm, WikiPostForm, CourseForm, LessonForm, EnrollmentForm
from .models import User, TeacherProfile, StudentProfile, Rating, SubjectResult, WikiPost, Course, Lesson, Enrollment, LessonCompletion, PDFSummary, SummaryPurchase
from django.http import HttpResponse



# ──────────────────────────────────────────────
# Public Views
# ──────────────────────────────────────────────

def home_view(request):
    approved_teachers = TeacherProfile.objects.filter(is_approved=True).annotate(
        avg_rating=ExpressionWrapper(
            (Avg('ratings__clarity_score') + Avg('ratings__practical_score') + Avg('ratings__professionalism_score')) / 3.0,
            output_field=FloatField()
        )
    )[:4]

    approved_students = StudentProfile.objects.filter(is_approved=True)[:4]

    # Results search
    seat_query = request.GET.get('seat', '').strip()
    search_results = None
    search_student = None
    search_error = None

    if seat_query:
        try:
            search_student = StudentProfile.objects.select_related('user').get(seat_number=seat_query)
            search_results = SubjectResult.objects.filter(student=search_student)
            if not search_results.exists():
                search_error = 'لم يتم إدخال نتائج لهذا الطالب بعد.'
        except StudentProfile.DoesNotExist:
            search_error = f'لا يوجد طالب برقم الجلوس "{seat_query}"، تأكد من الرقم وحاول مرة أخرى.'

    return render(request, 'core/home.html', {
        'teachers': approved_teachers,
        'students': approved_students,
        'search_results': search_results,
        'search_student': search_student,
        'search_error': search_error,
        'seat_query': seat_query,
    })


# ──────────────────────────────────────────────
# Authentication Views
# ──────────────────────────────────────────────

class CustomLoginView(LoginView):
    template_name = 'core/login.html'
    redirect_authenticated_user = True

    def get_success_url(self):
        user = self.request.user
        if user.role == 'student':
            return reverse_lazy('student_dashboard')
        elif user.role == 'teacher':
            return reverse_lazy('teacher_dashboard')
        return reverse_lazy('home')


class RegisterView(CreateView):
    model = User
    form_class = DualRegistrationForm
    template_name = 'core/register.html'
    success_url = reverse_lazy('home')

    def form_valid(self, form):
        user = form.save()
        login(self.request, user)
        if user.role == 'student':
            return redirect('student_dashboard')
        elif user.role == 'teacher':
            return redirect('teacher_dashboard')
        return redirect('home')


# ──────────────────────────────────────────────
# Student Dashboard & Profile
# ──────────────────────────────────────────────

@login_required
def student_dashboard(request):
    if request.user.role != 'student':
        return redirect('home')

    try:
        try:
            student_profile = request.user.student_profile
        except StudentProfile.DoesNotExist:
            messages.error(request, 'لم يتم العثور على ملفك الشخصي. يرجى التواصل مع الإدارة.')
            return redirect('home')

        # Calculate Progress
        enrollments = Enrollment.objects.filter(student=student_profile).select_related('course')
        my_courses_data = []
        total_progress_sum = 0
        
        for enrollment in enrollments:
            total_lessons = enrollment.course.lessons.count()
            try:
                completed_lessons = LessonCompletion.objects.filter(
                    student=student_profile, 
                    lesson__course=enrollment.course
                ).count()
            except:
                completed_lessons = 0
            
            progress = round((completed_lessons / total_lessons * 100), 1) if total_lessons > 0 else 0
            total_progress_sum += progress
            
            my_courses_data.append({
                'enrollment': enrollment,
                'course': enrollment.course,
                'progress': progress,
                'completed_count': completed_lessons,
                'total_count': total_lessons
            })

        activity_percentage = round(total_progress_sum / len(enrollments), 1) if enrollments.exists() else 0

        teachers = TeacherProfile.objects.filter(is_approved=True)
        my_ratings = Rating.objects.filter(student=student_profile).select_related('teacher__user').order_by('-created_at')
        my_results = SubjectResult.objects.filter(student=student_profile)

        return render(request, 'core/student_dashboard.html', {
            'teachers': teachers,
            'my_ratings': my_ratings,
            'my_results': my_results,
            'my_courses': my_courses_data,
            'activity_percentage': activity_percentage,
        })
    except Exception as e:
        return HttpResponse(f"<h1>Debug Error:</h1><p>{str(e)}</p>")


@login_required
def student_profile_update(request):
    if request.user.role != 'student':
        return redirect('home')
    try:
        profile = request.user.student_profile
    except StudentProfile.DoesNotExist:
        return redirect('home')

    if request.method == 'POST':
        form = StudentProfileForm(request.POST, request.FILES, instance=profile)
        if form.is_valid():
            form.save()
            # Update first/last name on user model too
            request.user.first_name = request.POST.get('first_name', request.user.first_name)
            request.user.last_name = request.POST.get('last_name', request.user.last_name)
            request.user.save()
            messages.success(request, 'تم تحديث ملفك الشخصي بنجاح!')
            return redirect('student_dashboard')
    else:
        form = StudentProfileForm(instance=profile)

    return render(request, 'core/profile_update.html', {
        'form': form,
        'role': 'student',
        'profile': profile,
    })


# ──────────────────────────────────────────────
# Teacher Dashboard & Profile
# ──────────────────────────────────────────────

@login_required
def teacher_dashboard(request):
    if request.user.role != 'teacher':
        return redirect('home')

    try:
        teacher_profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        messages.error(request, 'لم يتم العثور على ملفك الشخصي. يرجى التواصل مع الإدارة.')
        return redirect('home')

    # Standard dashboard context
    ratings = Rating.objects.filter(
        teacher=teacher_profile, is_approved=True
    ).select_related('student__user').order_by('-created_at')

    pending_count = Rating.objects.filter(teacher=teacher_profile, is_approved=False).count()

    stats = ratings.aggregate(
        avg_clarity=Avg('clarity_score'),
        avg_practical=Avg('practical_score'),
        avg_prof=Avg('professionalism_score'),
    )

    valid_scores = [s for s in [stats['avg_clarity'], stats['avg_practical'], stats['avg_prof']] if s is not None]
    overall_score = round(sum(valid_scores) / len(valid_scores), 1) if valid_scores else 0

    return render(request, 'core/teacher_dashboard.html', {
        'profile': teacher_profile,
        'ratings': ratings,
        'stats': stats,
        'overall_score': overall_score,
        'pending_count': pending_count,
    })



@login_required
def teacher_profile_update(request):
    if request.user.role != 'teacher':
        return redirect('home')
    try:
        profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        return redirect('home')

    if request.method == 'POST':
        form = TeacherProfileForm(request.POST, request.FILES, instance=profile)
        if form.is_valid():
            form.save()
            request.user.first_name = request.POST.get('first_name', request.user.first_name)
            request.user.last_name = request.POST.get('last_name', request.user.last_name)
            request.user.save()
            messages.success(request, 'تم تحديث ملفك الشخصي بنجاح!')
            return redirect('teacher_dashboard')
    else:
        form = TeacherProfileForm(instance=profile)

    return render(request, 'core/profile_update.html', {
        'form': form,
        'role': 'teacher',
        'profile': profile,
    })


# ──────────────────────────────────────────────
# Custom Error Handlers
# ──────────────────────────────────────────────

def handler404(request, exception):
    return render(request, 'core/404.html', {
        'debug_path': request.path,
    }, status=404)

@login_required
def run_migrations_view(request):
    """Powerful tool to fix DB issues on server."""
    if not request.user.is_superuser:
        return HttpResponse("Unauthorized", status=403)
    try:
        from django.core.management import call_command
        from django.db import connection
        results = []
        
        # 1. Try to make migrations first
        call_command('makemigrations', 'core', interactive=False)
        # 2. Run migrate
        call_command('migrate', interactive=False)
        results.append("تم تحديث قاعدة البيانات والجداول بنجاح! ✅")
        
        # Check/Create LessonCompletion table manually just in case migration fails
        with connection.cursor() as cursor:
            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='core_lessoncompletion'")
            if not cursor.fetchone():
                cursor.execute("""
                    CREATE TABLE core_lessoncompletion (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        completed_at DATETIME NOT NULL,
                        lesson_id INTEGER NOT NULL REFERENCES core_lesson(id),
                        student_id INTEGER NOT NULL REFERENCES core_studentprofile(id),
                        UNIQUE(student_id, lesson_id)
                    )
                """)
                results.append("تم إنشاء جدول 'تفاعل الدروس' يدوياً بنجاح ✅")

        return HttpResponse("<h1>نتائج الإصلاح:</h1><br>" + "<br>".join(results) + "<br><br><a href='/'>العودة للموقع</a>")
    except Exception as e:
        return HttpResponse(f"<h1>❌ فشل التحديث:</h1><pre>{str(e)}</pre>")


# ──────────────────────────────────────────────
# Wiki / Articles Views
# ──────────────────────────────────────────────

@login_required
def wiki_list(request):
    """Public articles list with category filter and search."""
    category = request.GET.get('cat', '')
    search   = request.GET.get('q', '').strip()

    posts = WikiPost.objects.filter(is_published=True).select_related('author__user')

    if category:
        posts = posts.filter(category=category)
    if search:
        posts = posts.filter(title__icontains=search) | posts.filter(content__icontains=search) | posts.filter(summary__icontains=search)

    categories = WikiPost.CATEGORY_CHOICES

    return render(request, 'core/wiki_list.html', {
        'posts': posts,
        'categories': categories,
        'active_cat': category,
        'search': search,
    })


@login_required
def wiki_detail(request, slug):
    """Single article detail with view counter."""
    # We use select_related to get author and user info in one query
    post = get_object_or_404(WikiPost.objects.select_related('author__user'), slug=slug)

    # If the post is not published, only the author can see it
    if not post.is_published:
        is_author = False
        if request.user.is_authenticated and hasattr(request.user, 'teacher_profile'):
            if post.author == request.user.teacher_profile:
                is_author = True
        
        if not is_author:
            from django.http import Http404
            raise Http404("هذا المقال غير منشور بعد.")

    # Increment view counter
    WikiPost.objects.filter(pk=post.pk).update(views_count=post.views_count + 1)
    post.views_count += 1

    # Related articles (same category, excluding this one)
    related = WikiPost.objects.filter(
        is_published=True, category=post.category
    ).exclude(pk=post.pk)[:3]

    return render(request, 'core/wiki_detail.html', {
        'post': post,
        'related': related,
    })


@login_required
def wiki_create(request):
    """Teacher-only article creation."""
    if request.user.role != 'teacher':
        messages.error(request, 'هذه الصفحة للمعلمين فقط.')
        return redirect('wiki_list')

    try:
        teacher_profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        return redirect('home')

    if not teacher_profile.is_approved:
        messages.error(request, 'يجب أن يكون حسابك معتمداً لكتابة المقالات.')
        return redirect('teacher_dashboard')

    if request.method == 'POST':
        form = WikiPostForm(request.POST, request.FILES)
        if form.is_valid():
            post = form.save(commit=False)
            post.author = teacher_profile
            # Generate unique slug from title
            base_slug = slugify(post.title, allow_unicode=True)
            if not base_slug:
                base_slug = str(uuid.uuid4())[:8]
            slug = base_slug
            counter = 1
            while WikiPost.objects.filter(slug=slug).exists():
                slug = f"{base_slug}-{counter}"
                counter += 1
            post.slug = slug
            # Check if saving as draft or publish
            post.is_published = 'publish' in request.POST
            post.save()
            if post.is_published:
                messages.success(request, 'تم نشر مقالك بنجاح! ✨')
            else:
                messages.success(request, 'تم حفظ المقال كمسودة، يمكنك نشره لاحقاً.')
            return redirect('teacher_dashboard')
    else:
        form = WikiPostForm()

    return render(request, 'core/wiki_create.html', {
        'form': form,
        'is_edit': False,
    })


@login_required
def wiki_edit(request, slug):
    """Teacher can edit their own articles."""
    if request.user.role != 'teacher':
        return redirect('wiki_list')

    try:
        teacher_profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        return redirect('home')

    post = get_object_or_404(WikiPost, slug=slug, author=teacher_profile)

    if request.method == 'POST':
        form = WikiPostForm(request.POST, request.FILES, instance=post)
        if form.is_valid():
            updated = form.save(commit=False)
            updated.is_published = 'publish' in request.POST
            updated.save()
            messages.success(request, 'تم تحديث المقال بنجاح!')
            return redirect('wiki_detail', slug=post.slug)
    else:
        form = WikiPostForm(instance=post)

    return render(request, 'core/wiki_create.html', {
        'form': form,
        'post': post,
        'is_edit': True,
    })


@login_required
def wiki_delete(request, slug):
    """Teacher can delete their own articles."""
    if request.user.role != 'teacher':
        return redirect('wiki_list')

    try:
        teacher_profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        return redirect('home')

    post = get_object_or_404(WikiPost, slug=slug, author=teacher_profile)
    if request.method == 'POST':
        post.delete()
        messages.success(request, 'تم حذف المقال.')
    return redirect('teacher_dashboard')


# ──────────────────────────────────────────────
# Teacher Public Profile
# ──────────────────────────────────────────────

def teacher_public_profile(request, teacher_id):
    """Public profile page for a teacher - visible to everyone."""
    teacher = get_object_or_404(TeacherProfile, pk=teacher_id, is_approved=True)

    approved_ratings = Rating.objects.filter(
        teacher=teacher, is_approved=True
    ).select_related('student__user').order_by('-created_at')

    stats = approved_ratings.aggregate(
        avg_clarity=Avg('clarity_score'),
        avg_practical=Avg('practical_score'),
        avg_prof=Avg('professionalism_score'),
    )

    valid_scores = [s for s in [stats['avg_clarity'], stats['avg_practical'], stats['avg_prof']] if s is not None]
    overall_score = round(sum(valid_scores) / len(valid_scores), 1) if valid_scores else 0

    # Teacher's published courses
    courses = Course.objects.filter(teacher=teacher, is_published=True)

    return render(request, 'core/teacher_profile.html', {
        'teacher': teacher,
        'ratings': approved_ratings,
        'stats': stats,
        'overall_score': overall_score,
        'ratings_count': approved_ratings.count(),
        'courses': courses,
    })


# ──────────────────────────────────────────────
# Courses & Lessons Views
# ──────────────────────────────────────────────

@login_required
def course_list(request):
    """Public courses list."""
    level_filter = request.GET.get('level', '')
    search = request.GET.get('q', '').strip()

    courses = Course.objects.filter(is_published=True).select_related('teacher__user').annotate(
        lessons_num=Count('lessons')
    )

    if level_filter:
        courses = courses.filter(level=level_filter)
    if search:
        courses = courses.filter(title__icontains=search) | courses.filter(description__icontains=search)

    return render(request, 'core/course_list.html', {
        'courses': courses,
        'level_choices': Course.LEVEL_CHOICES,
        'active_level': level_filter,
        'search': search,
    })


@login_required
def course_detail(request, course_id):
    """Course detail page with lessons and enrollment logic."""
    course = get_object_or_404(Course, pk=course_id, is_published=True)
    lessons = course.lessons.all()
    
    # Check enrollment status
    enrollment = None
    if request.user.role == 'student':
        try:
            student_profile = request.user.student_profile
            enrollment = Enrollment.objects.filter(student=student_profile, course=course).first()
        except StudentProfile.DoesNotExist:
            pass

    return render(request, 'core/course_detail.html', {
        'course': course,
        'lessons': lessons,
        'enrollment': enrollment,
        'enrollment_form': EnrollmentForm() if course.is_paid else None,
    })


@login_required
def enroll_course(request, course_id):
    """Handle student enrollment in a course - Testing Version (No restrictions)"""
    course = get_object_or_404(Course, pk=course_id, is_published=True)
    
    # Use existing profile if available, otherwise create/use a mock for testing
    student = None
    if hasattr(request.user, 'student_profile'):
        student = request.user.student_profile
    else:
        # If no profile, we can't save the enrollment because the field is required.
        # But for testing, let's try to find any profile or show a clear error.
        messages.error(request, '❌ لا يمكن الاشتراك لأن حسابك لا يمتلك "ملف طالب". يرجى إنشاء ملف طالب من لوحة الإدارة أولاً.')
        return redirect('course_detail', course_id=course_id)

    # Check if already enrolled
    if Enrollment.objects.filter(student=student, course=course).exists():
        messages.info(request, 'أنت مشترك في هذا الكورس بالفعل.')
        return redirect('course_detail', course_id=course_id)

    if request.method == 'POST':
        if course.is_paid:
            form = EnrollmentForm(request.POST, request.FILES)
            if form.is_valid():
                try:
                    enrollment = form.save(commit=False)
                    enrollment.student = student
                    enrollment.course = course
                    enrollment.status = 'pending'
                    enrollment.save()
                    messages.success(request, '✅ ممتاز! تم رفع الإيصال وحفظ الاشتراك بنجاح. راجع لوحة الإدارة الآن.')
                except Exception as e:
                    messages.error(request, f'❌ خطأ فني أثناء الحفظ: {str(e)}')
            else:
                messages.error(request, '❌ الملف الذي رفعته غير صالح (تأكد أنه صورة).')
        else:
            Enrollment.objects.create(student=student, course=course, status='active')
            messages.success(request, '✨ تم الاشتراك في الكورس المجاني!')
            
    return redirect('course_detail', course_id=course_id)


@login_required
def lesson_detail(request, course_id, lesson_id):
    """Single lesson view with enrollment check."""
    course = get_object_or_404(Course, pk=course_id, is_published=True)
    lesson = get_object_or_404(Lesson, pk=lesson_id, course=course)
    
    # Check access permission
    has_access = False
    if request.user.is_superuser or (request.user.role == 'teacher' and course.teacher.user == request.user):
        has_access = True
    elif request.user.role == 'student':
        # Safely check for active enrollment
        enrollment = Enrollment.objects.filter(
            student=request.user.student_profile, 
            course=course, 
            status='active'
        ).first()
        if enrollment:
            has_access = True
    
    if not has_access:
        messages.warning(request, 'يجب عليك الاشتراك في الكورس وتفعيله من قبل الإدارة لتتمكن من رؤية الدروس.')
        return redirect('course_detail', course_id=course.id)

    # prev / next navigation
    all_lessons = list(course.lessons.values_list('id', flat=True))
    current_idx = all_lessons.index(lesson.id)
    prev_lesson = course.lessons.filter(pk=all_lessons[current_idx - 1]).first() if current_idx > 0 else None
    next_lesson = course.lessons.filter(pk=all_lessons[current_idx + 1]).first() if current_idx < len(all_lessons) - 1 else None
    # Check completion status
    is_completed = False
    if request.user.role == 'student':
        is_completed = LessonCompletion.objects.filter(student=request.user.student_profile, lesson=lesson).exists()

    return render(request, 'core/lesson_detail.html', {
        'course': course,
        'lesson': lesson,
        'prev_lesson': prev_lesson,
        'next_lesson': next_lesson,
        'all_lessons': course.lessons.all(),
        'is_completed': is_completed,
        'embed_url': lesson.get_embed_url(),
    })


@login_required
def course_create(request):
    """Teacher creates a new course."""
    if request.user.role != 'teacher':
        messages.error(request, 'هذه الصفحة للمعلمين فقط.')
        return redirect('course_list')
    try:
        teacher_profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        return redirect('home')

    if not teacher_profile.is_approved:
        messages.error(request, 'يجب أن يكون حسابك معتمداً لإنشاء كورسات.')
        return redirect('teacher_dashboard')

    if request.method == 'POST':
        form = CourseForm(request.POST, request.FILES)
        if form.is_valid():
            course = form.save(commit=False)
            course.teacher = teacher_profile
            course.is_published = 'publish' in request.POST
            course.save()
            if course.is_published:
                messages.success(request, 'تم نشر الكورس بنجاح! الآن أضف دروسك ✨')
            else:
                messages.success(request, 'تم حفظ الكورس كمسودة.')
            return redirect('course_manage', course_id=course.pk)
    else:
        form = CourseForm()

    return render(request, 'core/course_form.html', {'form': form, 'is_edit': False})


@login_required
def course_edit(request, course_id):
    """Teacher edits an existing course."""
    if request.user.role != 'teacher':
        return redirect('course_list')
    try:
        teacher_profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        return redirect('home')

    course = get_object_or_404(Course, pk=course_id, teacher=teacher_profile)

    if request.method == 'POST':
        form = CourseForm(request.POST, request.FILES, instance=course)
        if form.is_valid():
            form.save()
            messages.success(request, 'تم تحديث بيانات الكورس بنجاح!')
            return redirect('course_manage', course_id=course.pk)
    else:
        form = CourseForm(instance=course)

    return render(request, 'core/course_form.html', {'form': form, 'is_edit': True, 'course': course})


@login_required
def course_manage(request, course_id):
    """Teacher manages their course - view lessons and add new."""
    if request.user.role != 'teacher':
        return redirect('course_list')
    try:
        teacher_profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        return redirect('home')

    course = get_object_or_404(Course, pk=course_id, teacher=teacher_profile)
    lessons = course.lessons.all()
    return render(request, 'core/course_manage.html', {
        'course': course,
        'lessons': lessons,
    })


@login_required
def lesson_create(request, course_id):
    """Teacher adds a lesson to their course."""
    if request.user.role != 'teacher':
        return redirect('course_list')
    try:
        teacher_profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        return redirect('home')

    course = get_object_or_404(Course, pk=course_id, teacher=teacher_profile)

    if request.method == 'POST':
        form = LessonForm(request.POST, request.FILES)
        if form.is_valid():
            lesson = form.save(commit=False)
            lesson.course = course
            lesson.save()
            messages.success(request, f'تم إضافة الدرس "{lesson.title}" بنجاح!')
            return redirect('course_manage', course_id=course.pk)
    else:
        # Auto-set order to next available
        next_order = (course.lessons.count() or 0) + 1
        form = LessonForm(initial={'order': next_order})

    return render(request, 'core/lesson_form.html', {
        'form': form,
        'course': course,
        'is_edit': False,
    })


@login_required
def lesson_edit(request, course_id, lesson_id):
    """Teacher edits a lesson."""
    if request.user.role != 'teacher':
        return redirect('course_list')
    try:
        teacher_profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        return redirect('home')

    course = get_object_or_404(Course, pk=course_id, teacher=teacher_profile)
    lesson = get_object_or_404(Lesson, pk=lesson_id, course=course)

    if request.method == 'POST':
        form = LessonForm(request.POST, request.FILES, instance=lesson)
        if form.is_valid():
            form.save()
            messages.success(request, 'تم تحديث الدرس بنجاح!')
            return redirect('course_manage', course_id=course.pk)
    else:
        form = LessonForm(instance=lesson)

    return render(request, 'core/lesson_form.html', {
        'form': form,
        'course': course,
        'lesson': lesson,
        'is_edit': True,
    })


@login_required
def lesson_delete(request, course_id, lesson_id):
    """Teacher deletes a lesson."""
    if request.user.role != 'teacher':
        return redirect('course_list')
    try:
        teacher_profile = request.user.teacher_profile
    except TeacherProfile.DoesNotExist:
        return redirect('home')
    course = get_object_or_404(Course, pk=course_id, teacher=teacher_profile)
    lesson = get_object_or_404(Lesson, pk=lesson_id, course=course)
    if request.method == 'POST':
        lesson.delete()
        messages.success(request, 'تم حذف الدرس.')
    return redirect('course_manage', course_id=course.pk)

@login_required
def mark_lesson_complete(request, lesson_id):
    """Mark a lesson as completed by the student."""
    if request.user.role != 'student':
        return HttpResponse("Unauthorized", status=403)
        
    lesson = get_object_or_404(Lesson, pk=lesson_id)
    student = request.user.student_profile
    
    # Check if student is enrolled in the course
    if not Enrollment.objects.filter(student=student, course=lesson.course, status='active').exists():
        messages.error(request, 'يجب أن تكون مشتركاً في الكورس ومفعلاً لتتمكن من إكمال الدروس.')
        return redirect('course_detail', course_id=lesson.course.id)
        
    # Toggle completion
    completion, created = LessonCompletion.objects.get_or_create(student=student, lesson=lesson)
    if not created:
        completion.delete()
        messages.info(request, f'تم إلغاء إكمال الدرس: {lesson.title}')
    else:
        messages.success(request, f'✅ تم إكمال الدرس: {lesson.title}')
        
    return redirect('lesson_detail', course_id=lesson.course.id, lesson_id=lesson.id)

# ──────────────────────────────────────────────
# PDF Summaries Views
# ──────────────────────────────────────────────

@login_required
def summary_list(request):
    summaries = PDFSummary.objects.filter(is_active=True)
    return render(request, 'core/summary_list.html', {'summaries': summaries})

@login_required
def summary_detail(request, summary_id):
    summary = get_object_or_404(PDFSummary, pk=summary_id, is_active=True)
    purchase = None
    if request.user.role == 'student':
        try:
            student_profile = request.user.student_profile
            purchase = SummaryPurchase.objects.filter(student=student_profile, summary=summary).first()
        except StudentProfile.DoesNotExist:
            pass

    return render(request, 'core/summary_detail.html', {
        'summary': summary,
        'purchase': purchase
    })

@login_required
def summary_buy(request, summary_id):
    summary = get_object_or_404(PDFSummary, pk=summary_id, is_active=True)
    if request.user.role != 'student':
        messages.error(request, 'يجب أن تكون طالباً لشراء الملخصات.')
        return redirect('summary_detail', summary_id=summary.id)

    try:
        student_profile = request.user.student_profile
    except StudentProfile.DoesNotExist:
        messages.error(request, 'لا تمتلك ملف طالب.')
        return redirect('summary_detail', summary_id=summary.id)

    if SummaryPurchase.objects.filter(student=student_profile, summary=summary).exists():
        messages.info(request, 'لقد قمت بطلب شراء هذا الملخص مسبقاً.')
        return redirect('summary_detail', summary_id=summary.id)

    if request.method == 'POST':
        payment_screenshot = request.FILES.get('payment_screenshot')
        if not payment_screenshot:
            messages.error(request, 'يجب إرفاق صورة إيصال التحويل.')
            return redirect('summary_detail', summary_id=summary.id)

        SummaryPurchase.objects.create(
            student=student_profile,
            summary=summary,
            status='pending',
            payment_screenshot=payment_screenshot
        )
        messages.success(request, 'تم رفع الإيصال بنجاح. سيتم تفعيل الملخص بعد المراجعة.')
        return redirect('summary_detail', summary_id=summary.id)

    return redirect('summary_detail', summary_id=summary.id)

@login_required
def summary_read(request, summary_id):
    summary = get_object_or_404(PDFSummary, pk=summary_id, is_active=True)
    
    # Check access permission
    has_access = False
    if request.user.is_superuser:
        has_access = True
    elif hasattr(request.user, 'role') and request.user.role == 'student':
        try:
            student_profile = request.user.student_profile
            purchase = SummaryPurchase.objects.filter(
                student=student_profile, 
                summary=summary, 
                status='active'
            ).first()
            if purchase:
                has_access = True
        except StudentProfile.DoesNotExist:
            pass

    if not has_access:
        messages.error(request, 'يجب عليك شراء الملخص وتفعيله من الإدارة لتتمكن من القراءة.')
        return redirect('summary_detail', summary_id=summary.id)

    return render(request, 'core/summary_read.html', {'summary': summary})