HH/apps/appreciation/ui_views.py

"""
Appreciation UI views - Server-rendered templates for appreciation management
"""
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.views.decorators.csrf import csrf_exempt
from django.contrib.contenttypes.models import ContentType
from django.core.cache import cache
from django.core.paginator import Paginator
from django.db.models import Q, Count
from django.http import JsonResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.utils import timezone
from django.utils.translation import gettext as _
from django.views.decorators.http import require_http_methods

from apps.accounts.models import User
from apps.accounts.services import StaffActivityService
from apps.core.services import AuditService
from apps.organizations.models import Department, Hospital, Staff

from .models import (
    Appreciation,
    AppreciationBadge,
    AppreciationCategory,
    AppreciationStatus,
    AppreciationVisibility,
    AppreciationStats,
    UserBadge,
)


# ============================================================================
# APPRECIATION LIST & DETAIL VIEWS
# ============================================================================

@login_required
def appreciation_list(request):
    queryset = Appreciation.objects.select_related(
        "hospital", "department", "category"
    ).order_by("-created_at")

    user = request.user
    selected_hospital = getattr(request, "tenant_hospital", None)

    if user.is_px_admin():
        if selected_hospital:
            queryset = queryset.filter(hospital=selected_hospital)
    elif user.is_hospital_admin() and user.hospital:
        queryset = queryset.filter(hospital=user.hospital)
    elif user.is_px_management() or user.is_px_employee():
        if user.hospital:
            queryset = queryset.filter(hospital=user.hospital)
    elif user.is_department_manager() and user.department:
        queryset = queryset.filter(department=user.department)
    elif user.is_champion() and user.department:
        queryset = queryset.filter(department=user.department)
    elif user.is_source_user():
        queryset = queryset.filter(created_by=user)
    elif user.hospital:
        queryset = queryset.filter(hospital=user.hospital)
    else:
        queryset = queryset.none()

    status_filter_val = request.GET.get("status", "")
    if status_filter_val:
        queryset = queryset.filter(status=status_filter_val)

    search_query = request.GET.get("search", "").strip()
    if search_query:
        queryset = queryset.filter(
            Q(message_en__icontains=search_query)
            | Q(message_ar__icontains=search_query)
            | Q(metadata__submitted_by_name__icontains=search_query)
        )

    base_qs = Appreciation.objects.all()
    if user.is_px_admin():
        if selected_hospital:
            base_qs = base_qs.filter(hospital=selected_hospital)
    elif user.is_hospital_admin() and user.hospital:
        base_qs = base_qs.filter(hospital=user.hospital)
    elif user.is_px_management() or user.is_px_employee():
        if user.hospital:
            base_qs = base_qs.filter(hospital=user.hospital)
    elif user.is_department_manager() and user.department:
        base_qs = base_qs.filter(department=user.department)
    elif user.is_champion() and user.department:
        base_qs = base_qs.filter(department=user.department)
    elif user.is_source_user():
        base_qs = base_qs.filter(created_by=user)
    elif user.hospital:
        base_qs = base_qs.filter(hospital=user.hospital)
    else:
        base_qs = base_qs.none()

    stats = {
        "total": base_qs.count(),
        "draft": base_qs.filter(status=AppreciationStatus.DRAFT).count(),
        "activated": base_qs.filter(
            status=AppreciationStatus.ACTIVATED
        ).count(),
        "sent": base_qs.filter(status=AppreciationStatus.SENT).count(),
    }

    paginator = Paginator(queryset, 25)
    page_number = request.GET.get("page", 1)
    page_obj = paginator.get_page(page_number)

    context = {
        "page_obj": page_obj,
        "appreciations": page_obj.object_list,
        "stats": stats,
        "status_filter": status_filter_val,
        "search_query": search_query,
    }
    return render(request, "appreciation/appreciation_list.html", context)


@login_required
def appreciation_detail(request, pk):
    appreciation = get_object_or_404(
        Appreciation.objects.select_related("hospital", "department", "category"),
        pk=pk,
    )

    user = request.user
    if not (
        user.is_px_admin() or user.is_hospital_admin()
        or user.is_px_management() or user.is_px_employee()
    ):
        if not (user.hospital and appreciation.hospital_id == user.hospital_id):
            messages.error(request, _("You don't have permission to view this appreciation."))
            return redirect("appreciation:appreciation_list")

    metadata = appreciation.metadata or {}

    staff_queryset = Staff.objects.filter(status="active").select_related("department").order_by("first_name")
    if user.hospital and not user.is_px_admin():
        staff_queryset = staff_queryset.filter(hospital=user.hospital)

    departments = Department.objects.filter(status="active").order_by("name")
    if user.hospital and not user.is_px_admin():
        departments = departments.filter(hospital=user.hospital)

    categories = AppreciationCategory.objects.filter(is_active=True).order_by("order", "name_en")

    # Sendable departments for the "Send to Department" modal
    from apps.organizations.department_contacts import has_contact_target
    hospital_departments = []
    if appreciation.hospital:
        hospital_departments = [
            d for d in Department.objects.filter(
                hospital=appreciation.hospital, status="active"
            ).select_related("champion", "manager", "manager__staff_profile").order_by("name")
            if has_contact_target(d)
        ]

    from django.contrib.contenttypes.models import ContentType
    appreciation_ct = ContentType.objects.get_for_model(appreciation)
    generic_notes = appreciation.notes.select_related("created_by").all()

    has_recipient = appreciation.recipient is not None
    is_activated = appreciation.status == AppreciationStatus.ACTIVATED

    context = {
        "appreciation": appreciation,
        "metadata": metadata,
        "staff_list": staff_queryset,
        "departments": departments,
        "categories": categories,
        "hospital_departments": hospital_departments,
        "can_activate": appreciation.status == AppreciationStatus.DRAFT,
        "can_send": is_activated and appreciation.department_id is not None,
        "has_recipient": has_recipient,
        "is_recipient": False,
        "content_type_id": appreciation_ct.pk,
        "object_id": appreciation.pk,
        "notes": generic_notes,
        "notes_count": generic_notes.count(),
    }
    _apr_steps = [
        {"label": _("Activate"), "icon": "zap", "done": appreciation.activated_at is not None},
        {"label": _("Select Staff"), "icon": "user-check", "done": has_recipient or appreciation.sent_at is not None},
        {"label": _("Send"), "icon": "send", "done": appreciation.sent_at is not None},
    ]
    _apr_next = next((i for i, s in enumerate(_apr_steps) if not s["done"]), len(_apr_steps))
    if _apr_next < len(_apr_steps):
        _apr_steps[_apr_next]["current"] = True
    context["workflow_steps"] = _apr_steps
    return render(request, "appreciation/appreciation_detail.html", context)


@login_required
def appreciation_create(request):
    """Internal form for creating a new appreciation (department-targeted)."""
    user = request.user
    if not (
        user.is_px_admin()
        or user.is_hospital_admin()
        or user.is_px_management()
        or user.is_px_employee()
    ):
        messages.error(request, _("You don't have permission to create appreciations."))
        return redirect("appreciation:appreciation_list")

    from .forms import AppreciationForm

    hospital = getattr(request, "tenant_hospital", None) or user.hospital

    if request.method == "POST":
        form = AppreciationForm(request.POST, hospital=hospital)
        if form.is_valid():
            appreciation = form.save(commit=False)
            appreciation.sender = user
            appreciation.hospital = hospital
            appreciation.status = AppreciationStatus.DRAFT
            appreciation.save()
            form.save_m2m()

            staff_id = request.POST.get("staff_id")
            if staff_id:
                try:
                    from django.contrib.contenttypes.models import ContentType
                    staff_ct = ContentType.objects.get_for_model(Staff)
                    staff = Staff.objects.get(pk=staff_id, status="active")
                    appreciation.recipient_content_type = staff_ct
                    appreciation.recipient_object_id = staff.id
                    appreciation.save(update_fields=["recipient_content_type", "recipient_object_id"])
                except Staff.DoesNotExist:
                    pass

            messages.success(request, _("Appreciation created successfully."))
            return redirect("appreciation:appreciation_detail", pk=appreciation.pk)
        else:
            messages.error(request, _("Please correct the errors below."))
    else:
        form = AppreciationForm(hospital=hospital)

    context = {
        "form": form,
        "hospital": hospital,
    }
    return render(request, "appreciation/appreciation_create.html", context)


@login_required
@require_http_methods(["POST"])
def appreciation_activate(request, pk):
    appreciation = get_object_or_404(Appreciation, pk=pk)

    if appreciation.status != AppreciationStatus.DRAFT:
        messages.error(request, _("This appreciation has already been processed."))
        return redirect("appreciation:appreciation_detail", pk=appreciation.pk)

    user = request.user
    if not (
        user.is_px_admin() or user.is_hospital_admin()
        or user.is_px_management() or user.is_px_employee()
    ):
        if not (user.hospital and appreciation.hospital_id == user.hospital_id):
            messages.error(request, _("Permission denied."))
            return redirect("appreciation:appreciation_list")

    appreciation.status = AppreciationStatus.ACTIVATED
    appreciation.activated_at = timezone.now()
    appreciation.activated_by = user
    appreciation.save()

    StaffActivityService.log_from_request(
        request,
        activity_type="create",
        description=f"Activated appreciation {appreciation.pk}",
        content_object=appreciation,
        module="appreciation",
    )

    AuditService.log_event(
        event_type="appreciation_activated",
        description=f"Appreciation {appreciation.pk} activated by {user.get_full_name()}",
        content_object=appreciation,
    )

    try:
        from apps.core.ai_service import AIService

        analysis_result = AIService.chat_completion(
            prompt=f'Analyze this patient appreciation message and provide:\n'
            f'1. A summary of what the patient appreciated (in English and Arabic)\n'
            f'2. Key themes mentioned\n'
            f'3. Suggested category if not already set\n'
            f'4. Tone analysis\n\n'
            f'Message: "{appreciation.message_en}"\n\n'
            f'Respond in JSON format with keys:\n'
            f'- summary_en: English summary\n'
            f'- summary_ar: Arabic summary\n'
            f'- themes: List of key themes\n'
            f'- tone: "warm", "formal", or "casual"\n'
            f'- suggested_response_en: Suggested response in English\n'
            f'- suggested_response_ar: Suggested response in Arabic',
            system_prompt="You are analyzing patient appreciation messages. Always respond with valid JSON.",
            response_format="json_object",
        )

        import json

        analysis_data = json.loads(analysis_result)
        appreciation.mark_ai_analyzed(analysis_data)
    except Exception as e:
        import logging

        logging.getLogger(__name__).error(f"AI analysis failed for appreciation {appreciation.pk}: {str(e)}")

    messages.success(request, _("Appreciation activated successfully."))
    return redirect("appreciation:appreciation_detail", pk=appreciation.pk)


@login_required
@require_http_methods(["POST"])
def appreciation_select_recipient(request, pk):
    """Select the department and optional staff recipient for an appreciation (without sending)."""
    appreciation = get_object_or_404(Appreciation, pk=pk)

    if appreciation.status != AppreciationStatus.ACTIVATED:
        messages.error(request, _("Appreciation must be activated before selecting a recipient."))
        return redirect("appreciation:appreciation_detail", pk=appreciation.pk)

    user = request.user
    if not (
        user.is_px_admin() or user.is_hospital_admin()
        or user.is_px_management() or user.is_px_employee()
    ):
        messages.error(request, _("Permission denied."))
        return redirect("appreciation:appreciation_list")

    department_id = request.POST.get("department_id")
    staff_id = request.POST.get("staff_id")

    if request.POST.get("clear_recipient"):
        appreciation.department = None
        appreciation.recipient_content_type = None
        appreciation.recipient_object_id = None
        appreciation.save(update_fields=["department", "recipient_content_type", "recipient_object_id"])
        messages.info(request, _("Recipient cleared. Please select a new recipient."))
        return redirect("appreciation:appreciation_detail", pk=appreciation.pk)

    if not department_id:
        messages.error(request, _("Please select a department."))
        return redirect("appreciation:appreciation_detail", pk=appreciation.pk)

    try:
        department = Department.objects.get(id=department_id, status="active")
    except Department.DoesNotExist:
        messages.error(request, _("Invalid department selected."))
        return redirect("appreciation:appreciation_detail", pk=appreciation.pk)

    appreciation.department = department

    if staff_id:
        try:
            from django.contrib.contenttypes.models import ContentType
            staff_ct = ContentType.objects.get_for_model(Staff)
            staff = Staff.objects.get(pk=staff_id, status="active")
            appreciation.recipient_content_type = staff_ct
            appreciation.recipient_object_id = staff.id
        except Staff.DoesNotExist:
            pass
    else:
        appreciation.recipient_content_type = None
        appreciation.recipient_object_id = None

    appreciation.save()
    messages.success(request, _("Recipient selected: {}").format(department.name))
    return redirect("appreciation:appreciation_detail", pk=appreciation.pk)


@login_required
@require_http_methods(["POST"])
def appreciation_send(request, pk):
    appreciation = get_object_or_404(Appreciation, pk=pk)

    if appreciation.status != AppreciationStatus.ACTIVATED:
        messages.error(request, _("This appreciation must be activated before sending."))
        return redirect("appreciation:appreciation_detail", pk=pk)

    user = request.user
    if not (
        user.is_px_admin() or user.is_hospital_admin()
        or user.is_px_management() or user.is_px_employee()
    ):
        if not (user.hospital and appreciation.hospital_id == user.hospital_id):
            messages.error(request, _("Permission denied."))
            return redirect("appreciation:appreciation_list")

    send_to_manager = request.POST.get("send_to_manager") == "on"
    send_to_department = request.POST.get("send_to_department") == "on"
    custom_message = request.POST.get("custom_message", "").strip()
    cc_emails = request.POST.get("cc_emails", "").strip()

    appreciation.send_to_manager = send_to_manager
    appreciation.send_to_department = send_to_department
    appreciation.custom_message = custom_message

    cc_list = [e.strip() for e in cc_emails.split(",") if e.strip()] if cc_emails else []
    appreciation.cc_list = cc_list

    appreciation.send()

    StaffActivityService.log_from_request(
        request,
        activity_type="send",
        description=f"Sent appreciation {appreciation.pk} to {appreciation.get_recipient_name()}",
        content_object=appreciation,
        module="appreciation",
    )

    AuditService.log_event(
        event_type="appreciation_sent",
        description=f"Appreciation {appreciation.pk} sent to {appreciation.get_recipient_name()}",
        user=user,
        content_object=appreciation,
        metadata={
            "send_to_manager": send_to_manager,
            "send_to_department": send_to_department,
            "cc_count": len(cc_list),
        },
    )

    messages.success(request, _("Appreciation sent successfully."))
    return redirect("appreciation:appreciation_detail", pk=pk)


@login_required
@require_http_methods(["POST"])
def appreciation_send_to(request, pk):
    """Unified AJAX endpoint to send an appreciation to a person or department.

    Mirrors the inquiry/complaint send-to flow used by the shared modal
    (components/send_to_modal.html). Requires the appreciation to be activated
    first; advances it to SENT on success.
    """
    appreciation = get_object_or_404(Appreciation, pk=pk)
    user = request.user

    # Permission
    if not (
        user.is_px_admin() or user.is_hospital_admin()
        or user.is_department_manager()
        or user.is_px_management() or user.is_px_employee()
    ):
        return JsonResponse(
            {"success": False, "error": str(_("You don't have permission to send this appreciation."))},
            status=403,
        )

    # Must be activated before it can be sent
    if appreciation.status != AppreciationStatus.ACTIVATED:
        return JsonResponse(
            {"success": False, "error": str(_("Activate this appreciation before sending it to a department."))},
            status=400,
        )

    recipient_type = request.POST.get("recipient_type", "department")
    note = request.POST.get("note", "").strip()
    email_subject = request.POST.get("email_subject", "").strip()
    email_body = request.POST.get("email_body", "").strip()

    try:
        from apps.notifications.services import NotificationService, get_email_header_html

        if recipient_type == "person":
            person_id = request.POST.get("person_id")
            if not person_id:
                return JsonResponse(
                    {"success": False, "error": str(_("Please select a person."))}, status=400
                )
            try:
                person = User.objects.get(id=person_id)
            except User.DoesNotExist:
                return JsonResponse(
                    {"success": False, "error": str(_("User not found."))}, status=400
                )

            if person.email:
                send_subject = email_subject or f"Appreciation Shared - {appreciation.reference_number}"
                send_body = email_body or (
                    f"An appreciation ({appreciation.reference_number}) has been shared with you."
                )
                NotificationService.send_email(
                    email=person.email,
                    subject=send_subject,
                    message=send_body,
                    html_message=f"""
                    <div style="font-family: 'Segoe UI', Tahoma, sans-serif; max-width: 600px; margin: 0 auto; border: 1px solid #e5e7eb; border-radius: 8px; overflow: hidden;">
                        {get_email_header_html()}
                        <div style="padding: 20px;">
                            <h2 style="color: #005696; font-size: 18px; margin: 0 0 12px 0;">Appreciation Shared With You</h2>
                            <p>An appreciation <strong>#{appreciation.reference_number}</strong> has been shared with you.</p>
                            <p><strong>Message:</strong> {appreciation.message_en or 'N/A'}</p>
                            {f'<p><strong>Note:</strong> {note}</p>' if note else ''}
                            <p><a href="https://{request.get_host()}/appreciation/detail/{appreciation.pk}/">View Appreciation</a></p>
                        </div>
                    </div>
                    """,
                    related_object=appreciation,
                )
            message = f"Appreciation sent to {person.get_full_name()}."

        else:  # department
            department_id = request.POST.get("department_id")
            if not department_id:
                return JsonResponse(
                    {"success": False, "error": str(_("Please select a department."))}, status=400
                )
            try:
                department = Department.objects.get(id=department_id, status="active")
            except Department.DoesNotExist:
                return JsonResponse(
                    {"success": False, "error": str(_("Department not found."))}, status=400
                )

            # Auto-target the department's champion and manager (no contact-person picker)
            from apps.organizations.department_contacts import get_champion_and_manager

            targets = get_champion_and_manager(department)
            if not targets:
                return JsonResponse(
                    {"success": False,
                     "error": str(_(f"Cannot send to {department.get_localized_name()}. This department has no champion or manager assigned. Please assign one before sending."))},
                    status=400,
                )

            # Route to the chosen department
            appreciation.department = department
            appreciation.send_to_department = True
            if note:
                appreciation.custom_message = note

            # Set the appreciated staff member as the recipient (if selected)
            staff_id = request.POST.get("staff_id", "").strip()
            if staff_id:
                try:
                    appreciated_staff = Staff.objects.get(id=staff_id)
                    from django.contrib.contenttypes.models import ContentType as CT
                    staff_ct = CT.objects.get_for_model(Staff)
                    appreciation.recipient_content_type = staff_ct
                    appreciation.recipient_object_id = appreciated_staff.id
                except Staff.DoesNotExist:
                    pass

            # Advance to SENT (validates status is ACTIVATED)
            appreciation.send()

            # Send notifications (email + SMS to champion, manager, staff) in the background
            from apps.appreciation.tasks import send_appreciation_notifications
            send_appreciation_notifications.delay(
                str(appreciation.pk),
                staff_id=staff_id or None,
                note=note,
                email_subject=email_subject,
                email_body=email_body,
                host=request.get_host(),
            )

            message = f"Appreciation sent to {department.name}."

        StaffActivityService.log_from_request(
            request,
            activity_type="send",
            description=f"Sent appreciation {appreciation.pk} to {recipient_type}",
            content_object=appreciation,
            module="appreciation",
        )
        AuditService.log_event(
            event_type="appreciation_sent",
            description=f"Appreciation {appreciation.pk} sent to {recipient_type}",
            user=user,
            content_object=appreciation,
            metadata={"recipient_type": recipient_type},
        )

        return JsonResponse({"success": True, "message": message})

    except Exception as e:
        import logging

        logging.getLogger(__name__).error(f"Error in appreciation_send_to: {e}")
        return JsonResponse(
            {"success": False, "error": str(_("An error occurred while sending the appreciation."))},
            status=500,
        )


# ============================================================================
# ACKNOWLEDGE
# ============================================================================

@login_required
@require_http_methods(["POST"])
def appreciation_acknowledge(request, pk):
    """DEPRECATED: ACKNOWLEDGED status was removed; SENT is terminal.

    The URL route was removed too. This view function is kept only so that
    any stale import or bookmarked URL that somehow resolves does not crash
    the worker; it redirects with a clear message. Safe to delete once no
    references remain.
    """
    messages.error(
        request,
        _("Appreciation acknowledge is no longer supported — sending is the final step."),
    )
    return redirect("appreciation:appreciation_detail", pk=pk)


@login_required
@require_http_methods(["POST"])
def appreciation_send_dept_reminder(request, pk):
    """Send a reminder to the department that hasn't acknowledged an appreciation."""
    appreciation = get_object_or_404(Appreciation, pk=pk)

    user = request.user
    if not (
        user.is_px_admin() or user.is_hospital_admin()
        or user.is_px_management() or user.is_px_employee()
    ):
        messages.error(request, _("You don't have permission to send reminders."))
        return redirect("appreciation:appreciation_detail", pk=pk)

    if appreciation.status != AppreciationStatus.SENT:
        messages.warning(request, _("Appreciation must be sent before sending reminders."))
        return redirect("appreciation:appreciation_detail", pk=pk)

    dept = appreciation.department
    if not dept:
        messages.error(request, _("No department assigned."))
        return redirect("appreciation:appreciation_detail", pk=pk)

    reminder_type = request.POST.get("reminder_type", "first")

    if reminder_type == "first" and appreciation.dept_response_reminder_sent_at:
        messages.warning(request, _("First reminder already sent."))
        return redirect("appreciation:appreciation_detail", pk=pk)
    if reminder_type == "second" and appreciation.dept_response_second_reminder_sent_at:
        messages.warning(request, _("Second reminder already sent."))
        return redirect("appreciation:appreciation_detail", pk=pk)
    if reminder_type == "second" and not appreciation.dept_response_reminder_sent_at:
        messages.warning(request, _("Please send the first reminder before the second."))
        return redirect("appreciation:appreciation_detail", pk=pk)

    try:
        from apps.notifications.services import NotificationService, get_email_header_html
        from apps.organizations.department_contacts import get_champion_and_manager

        targets = get_champion_and_manager(dept)
        if not targets:
            messages.error(request, _(f"No champion or manager assigned to {dept.name}."))
            return redirect("appreciation:appreciation_detail", pk=pk)

        recipients = []
        for target in targets:
            email = target.get("email") or ""
            if email:
                recipients.append({"email": email, "name": target.get("display_name", "")})

        if reminder_type == "first":
            appreciation.dept_response_reminder_sent_at = timezone.now()
        else:
            appreciation.dept_response_second_reminder_sent_at = timezone.now()
        appreciation.save(update_fields=["dept_response_reminder_sent_at", "dept_response_second_reminder_sent_at"])

        from apps.appreciation.tasks import send_appreciation_reminder_email
        send_appreciation_reminder_email.delay(str(appreciation.id), reminder_type, recipients)

        AuditService.log_event(
            event_type="appreciation_reminder_sent",
            description=f"{reminder_type.capitalize()} reminder sent for appreciation {appreciation.reference_number} by {user.get_full_name()}",
            content_object=appreciation,
        )

        messages.success(request, _(f"{reminder_type.capitalize()} reminder sent to {len(recipients)} recipient(s)."))
    except Exception as e:
        logger.error(f"Failed to send appreciation reminder: {e}")
        messages.error(request, _("Failed to send reminder."))

    return redirect("appreciation:appreciation_detail", pk=pk)


# ============================================================================
# LEADERBOARD VIEWS
# ============================================================================

@login_required
def leaderboard_view(request):
    """
    Appreciation leaderboard view.

    Features:
    - Monthly rankings
    - Hospital and department filters
    - Top recipients with badges
    """
    user = request.user

    # Get date range
    now = timezone.now()
    year = int(request.GET.get('year', now.year))
    month = int(request.GET.get('month', now.month))

    # Build base query
    queryset = AppreciationStats.objects.filter(year=year, month=month)

    # Apply RBAC
    selected_hospital = getattr(request, "tenant_hospital", None)
    if user.is_px_admin():
        if selected_hospital:
            queryset = queryset.filter(hospital=selected_hospital)
    elif user.is_hospital_admin() and user.hospital:
        queryset = queryset.filter(hospital=user.hospital)
    elif user.is_px_management() or user.is_px_employee():
        if user.hospital:
            queryset = queryset.filter(hospital=user.hospital)
    elif user.is_department_manager() and user.department:
        queryset = queryset.filter(department=user.department)
    elif user.is_champion() and user.department:
        queryset = queryset.filter(department=user.department)
    elif user.hospital:
        queryset = queryset.filter(hospital=user.hospital)
    else:
        queryset = queryset.none()

    # Apply filters
    hospital_filter = request.GET.get('hospital')
    if hospital_filter:
        queryset = queryset.filter(hospital_id=hospital_filter)

    department_filter = request.GET.get('department')
    if department_filter:
        queryset = queryset.filter(department_id=department_filter)

    # Order by received count
    queryset = queryset.order_by('-received_count')

    # Pagination
    page_size = int(request.GET.get('page_size', 50))
    paginator = Paginator(queryset, page_size)
    page_number = request.GET.get('page', 1)
    page_obj = paginator.get_page(page_number)


    departments = Department.objects.filter(status='active')
    if not user.is_px_admin() and user.hospital:
        departments = departments.filter(hospital=user.hospital)

    # Get months for filter
    months = [(i, timezone.datetime(year=year, month=i, day=1).strftime('%B')) for i in range(1, 13)]
    years = range(now.year - 1, now.year + 2)

    context = {
        'page_obj': page_obj,
        'leaderboard': page_obj.object_list,
        'departments': departments,
        'months': months,
        'years': years,
        'selected_year': year,
        'selected_month': month,
        'filters': request.GET,
    }

    return render(request, 'appreciation/leaderboard.html', context)


@login_required
def my_badges_view(request):
    """
    User's badges view.

    Features:
    - All earned badges
    - Badge details and criteria
    - Progress toward next badges
    """
    user = request.user
    user_content_type = ContentType.objects.get_for_model(user)

    # Get user's badges
    queryset = UserBadge.objects.filter(
        recipient_content_type=user_content_type,
        recipient_object_id=user.id
    ).select_related('badge').order_by('-earned_at')

    # Pagination
    page_size = int(request.GET.get('page_size', 20))
    paginator = Paginator(queryset, page_size)
    page_number = request.GET.get('page', 1)
    page_obj = paginator.get_page(page_number)

    # Get available badges for progress tracking
    available_badges = AppreciationBadge.objects.filter(is_active=True)
    if not request.user.is_px_admin() and request.user.hospital:
        available_badges = available_badges.filter(Q(hospital_id=request.user.hospital.id) | Q(hospital__isnull=True))

    # Calculate progress for each badge
    badge_progress = []
    total_received = Appreciation.objects.filter(
        recipient_content_type=user_content_type,
        recipient_object_id=user.id
    ).count()

    for badge in available_badges:
        earned = queryset.filter(badge=badge).exists()
        progress = 0
        if badge.criteria_type in ('received_count', 'received_month'):
            progress = min(100, int((total_received / badge.criteria_value) * 100)) if badge.criteria_value else 0
        elif badge.criteria_type == 'diverse_senders':
            unique_senders = Appreciation.objects.filter(
                recipient_content_type=user_content_type,
                recipient_object_id=user.id
            ).values('sender').distinct().count()
            progress = min(100, int((unique_senders / badge.criteria_value) * 100)) if badge.criteria_value else 0
        elif badge.criteria_type == 'streak_weeks':
            from datetime import timedelta
            now = timezone.now()
            streak = 0
            for i in range(badge.criteria_value):
                week_start = now - timedelta(weeks=i+1)
                week_end = now - timedelta(weeks=i)
                if Appreciation.objects.filter(
                    recipient_content_type=user_content_type,
                    recipient_object_id=user.id,
                    sent_at__gte=week_start,
                    sent_at__lt=week_end,
                ).exists():
                    streak += 1
                else:
                    break
            progress = min(100, int((streak / badge.criteria_value) * 100)) if badge.criteria_value else 0

        badge_progress.append({
            'badge': badge,
            'earned': earned,
            'progress': progress,
        })

    context = {
        'page_obj': page_obj,
        'badges': page_obj.object_list,
        'total_received': total_received,
        'badge_progress': badge_progress,
    }

    return render(request, 'appreciation/my_badges.html', context)


# ============================================================================
# ADMIN: CATEGORY MANAGEMENT
# ============================================================================

@login_required
def category_list(request):
    """List and manage appreciation categories"""
    user = request.user

    # Check permission
    if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee()):
        messages.error(request, "You don't have permission to manage categories.")
        return redirect('appreciation:appreciation_list')

    # Base queryset
    queryset = AppreciationCategory.objects.annotate(
        appreciation_count=Count('appreciations'),
    )

    # Apply RBAC
    if not user.is_px_admin() and user.hospital:
        queryset = queryset.filter(Q(hospital_id=user.hospital.id) | Q(hospital__isnull=True))

    # Search
    search_query = request.GET.get('search')
    if search_query:
        queryset = queryset.filter(
            Q(name_en__icontains=search_query) |
            Q(name_ar__icontains=search_query) |
            Q(code__icontains=search_query)
        )

    # Ordering
    queryset = queryset.order_by('order', 'code')

    # Pagination
    page_size = int(request.GET.get('page_size', 25))
    paginator = Paginator(queryset, page_size)
    page_number = request.GET.get('page', 1)
    page_obj = paginator.get_page(page_number)

    context = {
        'page_obj': page_obj,
        'categories': page_obj.object_list,
    }

    return render(request, 'appreciation/category_list.html', context)


@login_required
@require_http_methods(["GET", "POST"])
def category_create(request):
    """Create appreciation category"""
    user = request.user

    # Check permission
    if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee()):
        messages.error(request, "You don't have permission to create categories.")
        return redirect('appreciation:appreciation_list')

    if request.method == 'POST':
        try:
            code = request.POST.get('code')
            name_en = request.POST.get('name_en')
            name_ar = request.POST.get('name_ar', '')
            description_en = request.POST.get('description_en', '')
            description_ar = request.POST.get('description_ar', '')
            icon = request.POST.get('icon', 'fa-heart')
            color = request.POST.get('color', '#FF5733')
            order = request.POST.get('order', 0)
            is_active = request.POST.get('is_active') == 'on'

            # Get hospital
            hospital = None
            if user.is_hospital_admin() and user.hospital:
                hospital = user.hospital

            # Validate
            if not all([code, name_en]):
                messages.error(request, "Please fill in all required fields.")
                return redirect('appreciation:category_create')

            # Create category
            AppreciationCategory.objects.create(
                code=code,
                name_en=name_en,
                name_ar=name_ar,
                description_en=description_en,
                description_ar=description_ar,
                icon=icon,
                color=color,
                order=order,
                is_active=is_active,
                hospital=hospital,
            )

            messages.success(request, "Category created successfully.")
            return redirect('appreciation:category_list')

        except Exception as e:
            messages.error(request, f"Error creating category: {str(e)}")
            return redirect('appreciation:category_create')

    context = {}
    return render(request, 'appreciation/admin/category_form.html', context)


@login_required
@require_http_methods(["GET", "POST"])
def category_edit(request, pk):
    """Edit appreciation category"""
    user = request.user

    # Check permission
    if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee()):
        messages.error(request, "You don't have permission to edit categories.")
        return redirect('appreciation:appreciation_list')

    category = get_object_or_404(AppreciationCategory, pk=pk)

    # Check access
    if not user.is_px_admin() and category.hospital != user.hospital:
        messages.error(request, "You don't have permission to edit this category.")
        return redirect('appreciation:category_list')

    if request.method == 'POST':
        try:
            category.code = request.POST.get('code')
            category.name_en = request.POST.get('name_en')
            category.name_ar = request.POST.get('name_ar', '')
            category.description_en = request.POST.get('description_en', '')
            category.description_ar = request.POST.get('description_ar', '')
            category.icon = request.POST.get('icon', 'fa-heart')
            category.color = request.POST.get('color', '#FF5733')
            category.order = request.POST.get('order', 0)
            category.is_active = request.POST.get('is_active') == 'on'

            category.save()

            messages.success(request, "Category updated successfully.")
            return redirect('appreciation:category_list')

        except Exception as e:
            messages.error(request, f"Error updating category: {str(e)}")
            return redirect('appreciation:category_edit', pk=pk)

    context = {
        'category': category,
    }
    return render(request, 'appreciation/admin/category_form.html', context)


@login_required
@require_http_methods(["POST"])
def category_delete(request, pk):
    """Delete appreciation category"""
    user = request.user

    # Check permission
    if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee()):
        messages.error(request, "You don't have permission to delete categories.")
        return redirect('appreciation:appreciation_list')

    category = get_object_or_404(AppreciationCategory, pk=pk)

    # Check if category is in use
    if Appreciation.objects.filter(category=category).exists():
        messages.error(request, "Cannot delete category that is in use.")
        return redirect('appreciation:category_list')

    # Log audit
    AuditService.log_event(
        event_type='category_deleted',
        description=f"Appreciation category deleted: {category.name_en}",
        user=request.user,
        metadata={'category_code': category.code}
    )

    category.delete()

    messages.success(request, "Category deleted successfully.")
    return redirect('appreciation:category_list')


# ============================================================================
# ADMIN: BADGE MANAGEMENT
# ============================================================================

@login_required
def badge_list(request):
    """List and manage appreciation badges"""
    user = request.user

    # Check permission
    if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee()):
        messages.error(request, "You don't have permission to manage badges.")
        return redirect('appreciation:appreciation_list')

    # Base queryset
    queryset = AppreciationBadge.objects.annotate(
        earned_count=Count('earned_by'),
    )

    # Apply RBAC
    if not user.is_px_admin() and user.hospital:
        queryset = queryset.filter(Q(hospital_id=user.hospital.id) | Q(hospital__isnull=True))

    # Search
    search_query = request.GET.get('search')
    if search_query:
        queryset = queryset.filter(
            Q(name_en__icontains=search_query) |
            Q(name_ar__icontains=search_query) |
            Q(code__icontains=search_query)
        )

    # Ordering
    queryset = queryset.order_by('order', 'code')

    # Pagination
    page_size = int(request.GET.get('page_size', 25))
    paginator = Paginator(queryset, page_size)
    page_number = request.GET.get('page', 1)
    page_obj = paginator.get_page(page_number)

    context = {
        'page_obj': page_obj,
        'badges': page_obj.object_list,
    }

    return render(request, 'appreciation/badge_list.html', context)


@login_required
@require_http_methods(["GET", "POST"])
def badge_create(request):
    """Create appreciation badge"""
    user = request.user

    # Check permission
    if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee()):
        messages.error(request, "You don't have permission to create badges.")
        return redirect('appreciation:appreciation_list')

    if request.method == 'POST':
        try:
            code = request.POST.get('code')
            name_en = request.POST.get('name_en')
            name_ar = request.POST.get('name_ar', '')
            description_en = request.POST.get('description_en', '')
            description_ar = request.POST.get('description_ar', '')
            icon = request.POST.get('icon', 'fa-award')
            color = request.POST.get('color', '#FFD700')
            criteria_type = request.POST.get('criteria_type', 'received_count')
            criteria_value = request.POST.get('criteria_value', 5)
            order = request.POST.get('order', 0)
            is_active = request.POST.get('is_active') == 'on'

            # Get hospital
            hospital = None
            if user.is_hospital_admin() and user.hospital:
                hospital = user.hospital

            # Validate
            if not all([code, name_en, criteria_value]):
                messages.error(request, "Please fill in all required fields.")
                return redirect('appreciation:badge_create')

            # Create badge
            AppreciationBadge.objects.create(
                code=code,
                name_en=name_en,
                name_ar=name_ar,
                description_en=description_en,
                description_ar=description_ar,
                icon=icon,
                color=color,
                criteria_type=criteria_type,
                criteria_value=int(criteria_value),
                order=order,
                is_active=is_active,
                hospital=hospital,
            )

            messages.success(request, "Badge created successfully.")
            return redirect('appreciation:badge_list')

        except Exception as e:
            messages.error(request, f"Error creating badge: {str(e)}")
            return redirect('appreciation:badge_create')

    context = {}
    return render(request, 'appreciation/admin/badge_form.html', context)


@login_required
@require_http_methods(["GET", "POST"])
def badge_edit(request, pk):
    """Edit appreciation badge"""
    user = request.user

    # Check permission
    if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee()):
        messages.error(request, "You don't have permission to edit badges.")
        return redirect('appreciation:appreciation_list')

    badge = get_object_or_404(AppreciationBadge, pk=pk)

    # Check access
    if not user.is_px_admin() and badge.hospital != user.hospital:
        messages.error(request, "You don't have permission to edit this badge.")
        return redirect('appreciation:badge_list')

    if request.method == 'POST':
        try:
            badge.code = request.POST.get('code')
            badge.name_en = request.POST.get('name_en')
            badge.name_ar = request.POST.get('name_ar', '')
            badge.description_en = request.POST.get('description_en', '')
            badge.description_ar = request.POST.get('description_ar', '')
            badge.icon = request.POST.get('icon', 'fa-award')
            badge.color = request.POST.get('color', '#FFD700')
            badge.criteria_type = request.POST.get('criteria_type', 'received_count')
            badge.criteria_value = request.POST.get('criteria_value', 5)
            badge.order = request.POST.get('order', 0)
            badge.is_active = request.POST.get('is_active') == 'on'

            badge.save()

            messages.success(request, "Badge updated successfully.")
            return redirect('appreciation:badge_list')

        except Exception as e:
            messages.error(request, f"Error updating badge: {str(e)}")
            return redirect('appreciation:badge_edit', pk=pk)

    context = {
        'badge': badge,
    }
    return render(request, 'appreciation/admin/badge_form.html', context)


@login_required
@require_http_methods(["POST"])
def badge_delete(request, pk):
    """Delete appreciation badge"""
    user = request.user

    # Check permission
    if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee()):
        messages.error(request, "You don't have permission to delete badges.")
        return redirect('appreciation:appreciation_list')

    badge = get_object_or_404(AppreciationBadge, pk=pk)

    # Check if badge is in use
    if UserBadge.objects.filter(badge=badge).exists():
        messages.error(request, "Cannot delete badge that has been earned.")
        return redirect('appreciation:badge_list')

    # Log audit
    AuditService.log_event(
        event_type='badge_deleted',
        description=f"Appreciation badge deleted: {badge.name_en}",
        user=request.user,
        metadata={'badge_code': badge.code}
    )

    badge.delete()

    messages.success(request, "Badge deleted successfully.")
    return redirect('appreciation:badge_list')


@login_required
@require_http_methods(["POST"])
def appreciation_restore(request, pk):
    """Restore deleted appreciation"""
    user = request.user

    if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee()):
        messages.error(request, "You don't have permission to restore appreciation.")
        return redirect('config:deleted_items')

    appreciation = get_object_or_404(Appreciation.all_objects, pk=pk, is_deleted=True)
    appreciation.restore()

    messages.success(request, "Appreciation restored successfully.")
    return redirect('config:deleted_items')


# ============================================================================
# AJAX/API HELPERS
# ============================================================================

@login_required
def get_users_by_hospital(request):
    """Get users for a hospital (AJAX)"""
    hospital_id = request.GET.get('hospital_id')
    if not hospital_id:
        return JsonResponse({'users': []})

    users = User.objects.filter(
        hospital_id=hospital_id,
        is_active=True
    ).values('id', 'first_name', 'last_name')

    results = [
        {
            'id': str(u['id']),
            'name': f"{u['first_name']} {u['last_name']}",
        }
        for u in users
    ]

    return JsonResponse({'users': results})


@login_required
def get_staff_by_hospital(request):
    """Get staff for a hospital (AJAX)"""
    hospital_id = request.GET.get('hospital_id')
    if not hospital_id:
        return JsonResponse({'staff': []})

    staff = Staff.objects.filter(
        hospital_id=hospital_id,
        status='active'
    ).values('id', 'user__first_name', 'user__last_name')

    results = [
        {
            'id': str(s['id']),
            'name': f"{s['user__first_name']} {s['user__last_name']}",
        }
        for s in staff
    ]

    return JsonResponse({'staff': results})


@login_required
def get_physicians_by_hospital(request):
    """Get physicians for a hospital (AJAX)"""
    hospital_id = request.GET.get('hospital_id')
    if not hospital_id:
        return JsonResponse({'physicians': []})

    physicians = Staff.objects.filter(
        hospital_id=hospital_id,
        status='active',
        staff_type='physician'
    ).values('id', 'user__first_name', 'user__last_name')

    results = [
        {
            'id': str(p['id']),
            'name': f"{p['user__first_name']} {p['user__last_name']}",
        }
        for p in physicians
    ]

    return JsonResponse({'physicians': results})


@login_required
def get_departments_by_hospital(request):
    """Get departments for a hospital (AJAX)"""
    hospital_id = request.GET.get('hospital_id')
    if not hospital_id:
        return JsonResponse({'departments': []})

    departments = Department.objects.filter(
        hospital_id=hospital_id,
        status='active'
    ).values('id', 'name', 'name_ar')

    results = [
        {
            'id': str(d['id']),
            'name': d['name'],
        }
        for d in departments
    ]

    return JsonResponse({'departments': results})


@login_required
def appreciation_summary_ajax(request):
    """Get appreciation summary for current user (AJAX)"""
    user = request.user
    user_content_type = ContentType.objects.get_for_model(user)

    now = timezone.now()
    current_year = now.year
    current_month = now.month

    summary = {
        'total_received': Appreciation.objects.filter(
            recipient_content_type=user_content_type,
            recipient_object_id=user.id
        ).count(),
        'total_sent': Appreciation.objects.filter(sender=user).count(),
        'this_month_received': Appreciation.objects.filter(
            recipient_content_type=user_content_type,
            recipient_object_id=user.id,
            sent_at__year=current_year,
            sent_at__month=current_month
        ).count(),
        'this_month_sent': Appreciation.objects.filter(
            sender=user,
            sent_at__year=current_year,
            sent_at__month=current_month
        ).count(),
        'badges_earned': UserBadge.objects.filter(
            recipient_content_type=user_content_type,
            recipient_object_id=user.id
        ).count(),
    }

    # Get hospital rank
    if user.hospital:
        stats = AppreciationStats.objects.filter(
            recipient_content_type=user_content_type,
            recipient_object_id=user.id,
            year=current_year,
            month=current_month
        ).first()
        summary['hospital_rank'] = stats.hospital_rank if stats else None

    return JsonResponse(summary)


@csrf_exempt
@require_http_methods(["POST"])
def public_appreciation_submit(request):
    import json
    import logging
    logger = logging.getLogger(__name__)

    client_ip = request.META.get('HTTP_X_FORWARDED_FOR', '').split(',')[0].strip() or request.META.get('REMOTE_ADDR', '')
    cache_key = f"appreciation_rate:{client_ip}"
    from django.core.cache import cache
    if cache.get(cache_key, 0) >= 5:
        return JsonResponse({"success": False, "message": "Too many requests. Please try again later."}, status=429)
    cache.set(cache_key, cache.get(cache_key, 0) + 1, 300)

    try:
        try:
            data = json.loads(request.body) if request.content_type == 'application/json' else request.POST
        except json.JSONDecodeError:
            data = request.POST

        contact_name = data.get("contact_name", "").strip()
        contact_phone = data.get("contact_phone", "").strip()
        message = data.get("message", "").strip()
        hospital_id = data.get("hospital", "")
        staff_name = data.get("staff_name", "").strip()
        department_id = data.get("department", "").strip()
        section_id = data.get("section", "").strip()

        if not contact_name or not contact_phone or not message:
            return JsonResponse({"success": False, "message": "Name, phone, and message are required."}, status=400)

        from apps.core.validators import validate_saudi_phone
        from django.core.exceptions import ValidationError
        try:
            validate_saudi_phone(contact_phone)
        except ValidationError:
            return JsonResponse(
                {"success": False, "message": "Please enter a valid Saudi mobile number (e.g. 05XXXXXXXX or +9665XXXXXXXX)."},
                status=400,
            )

        if not hospital_id:
            return JsonResponse({"success": False, "message": "Please select a hospital."}, status=400)

        try:
            hospital = Hospital.objects.get(id=hospital_id)
        except Hospital.DoesNotExist:
            return JsonResponse({"success": False, "message": "Invalid hospital."}, status=400)

        from apps.organizations.models import Department, Section, OrgSubSection
        department = Department.objects.filter(id=department_id).first() if department_id else None
        section = Section.objects.filter(id=section_id).first() if section_id else None

        appreciation = Appreciation(
            hospital=hospital,
            department=department,
            section=section,
            category=None,
            message_en=message,
            message_ar="",
            is_anonymous=False,
            status=AppreciationStatus.DRAFT,
            visibility=AppreciationVisibility.PUBLIC,
            metadata={
                "source": "public_form",
                "submitted_by_name": contact_name,
                "submitted_by_phone": contact_phone,
                "staff_name_mentioned": staff_name,
            },
        )
        appreciation.save()

        try:
            from apps.complaints.tasks import notify_staff_new_item
            notify_staff_new_item.delay("appreciation", str(appreciation.id))
        except Exception:
            pass

        AuditService.log_event(
            event_type="public_appreciation_submitted",
            description=f"Public appreciation submitted by {contact_name}",
            content_object=appreciation,
            metadata={"hospital": str(hospital.id), "staff_mentioned": staff_name},
        )

        return JsonResponse({"success": True, "reference": appreciation.reference_number})
    except Exception as e:
        logger.exception("ERROR in public_appreciation_submit")
        return JsonResponse({"success": False, "message": str(e)}, status=500)

def _appreciation_pdf_context(appreciation):
    """Build the common context for the appreciation letter & certificate PDFs."""
    hospital = appreciation.hospital
    hospital_name = hospital.name if hospital else ""
    hospital_name_ar = getattr(hospital, "name_ar", "") if hospital else ""

    recipient = appreciation.recipient
    recipient_name = appreciation.get_recipient_name() or "—"
    department_name = appreciation.department.get_localized_name() if appreciation.department else ""
    recipient_title = ""
    if recipient is not None:
        getter = getattr(recipient, "get_localized_job_title", None)
        if callable(getter):
            recipient_title = getter() or ""
        recipient_title = recipient_title or getattr(recipient, "job_title", "") or ""

    meta = appreciation.metadata or {}
    is_patient = meta.get("source") == "public_form" or bool(meta.get("submitted_by_name"))
    patient_name = (meta.get("submitted_by_name") or "").strip()

    # Signer: sender (unless anonymous), else the activating officer, else generic PX team.
    signer = appreciation.sender if (appreciation.sender and not appreciation.is_anonymous) else appreciation.activated_by
    signer_name = _("Al Hammadi Patient Experience")
    signer_role = _("Patient Experience Team")
    if signer:
        signer_name = signer.get_full_name() or signer_name
        role_names = signer.get_role_names() if hasattr(signer, "get_role_names") else []
        if role_names:
            signer_role = ", ".join(role_names)

    date_dt = appreciation.sent_at or appreciation.activated_at or appreciation.created_at

    return {
        "hospital_name": hospital_name,
        "hospital_name_ar": hospital_name_ar,
        "recipient_name": recipient_name,
        "recipient_title": recipient_title,
        "department_name": department_name,
        "is_patient": is_patient,
        "patient_name": patient_name,
        "message_en": appreciation.message_en or "",
        "message_ar": appreciation.message_ar or "",
        "has_ar": bool((appreciation.message_ar or "").strip()),
        "signer_name": signer_name,
        "signer_role": signer_role,
        "date_dt": date_dt,
        "reference": appreciation.reference_number or "",
    }


def _render_appreciation_pdf_bytes(template_name, context, obj=None):
    """Render a PDF template via WeasyPrint and return the raw PDF bytes.

    When ``obj`` is provided, its hospital letterhead is injected into the context
    as ``letterhead_path`` (data URI) via the shared ``pdf_utils`` helper.
    Used by both the PDF download views (wraps bytes in HttpResponse) and the
    notification task (attaches bytes to email).
    """
    from django.conf import settings
    from django.template.loader import render_to_string
    from weasyprint import HTML

    full_context = dict(context)
    if obj is not None:
        from apps.core.pdf_utils import _get_letterhead_data_uri
        full_context.setdefault("letterhead_path", _get_letterhead_data_uri(obj))

    html_string = render_to_string(template_name, full_context)
    return HTML(string=html_string, base_url=str(settings.BASE_DIR / "static")).write_pdf()


def _appreciation_pdf_response(template_name, context, filename, obj=None):
    """Render a PDF template via WeasyPrint and return it as an attachment response."""
    from django.http import HttpResponse

    pdf_file = _render_appreciation_pdf_bytes(template_name, context, obj=obj)
    response = HttpResponse(pdf_file, content_type="application/pdf")
    response["Content-Disposition"] = f'attachment; filename="{filename}"'
    return response


def _check_appreciation_pdf_access(request, appreciation):
    """Shared permission + activation gate for the appreciation PDF views."""
    user = request.user
    allowed = (
        user.is_px_admin()
        or user.is_hospital_admin()
        or user.is_px_management()
        or user.is_px_employee()
        or (user.hospital_id and appreciation.hospital_id == user.hospital_id)
    )
    if not allowed:
        messages.error(request, _("You don't have permission to view this appreciation."))
        return redirect("appreciation:appreciation_detail", pk=appreciation.pk)
    if not appreciation.activated_at:
        messages.error(request, _("This appreciation must be activated before generating a document."))
        return redirect("appreciation:appreciation_detail", pk=appreciation.pk)
    if not appreciation.recipient:
        messages.error(request, _("Select a recipient before generating a document."))
        return redirect("appreciation:appreciation_detail", pk=appreciation.pk)
    return None


@login_required
def appreciation_letter(request, pk):
    """Everyday Letter of Appreciation (portrait, message-forward, sender-signed)."""
    obj = get_object_or_404(Appreciation, id=pk)
    denied = _check_appreciation_pdf_access(request, obj)
    if denied:
        return denied
    ctx = _appreciation_pdf_context(obj)
    return _appreciation_pdf_response(
        "appreciation/appreciation_letter.html",
        ctx,
        f"appreciation_letter_{obj.reference_number}.pdf",
        obj=obj,
    )


@login_required
def appreciation_certificate(request, pk):
    """Formal Certificate of Appreciation (landscape, leadership-signed)."""
    obj = get_object_or_404(Appreciation, id=pk)
    denied = _check_appreciation_pdf_access(request, obj)
    if denied:
        return denied
    ctx = _appreciation_pdf_context(obj)
    hospital = obj.hospital
    ctx["ceo_name"] = hospital.ceo.get_full_name() if hospital and hospital.ceo else ""
    ctx["medical_director_name"] = (
        hospital.medical_director.get_full_name() if hospital and hospital.medical_director else ""
    )
    ctx["hospital_initials"] = (
        "".join(w[0] for w in (hospital.name or "").split()[:2]).upper() if hospital and hospital.name else "HH"
    )
    return _appreciation_pdf_response(
        "appreciation/appreciation_certificate.html",
        ctx,
        f"appreciation_certificate_{obj.reference_number}.pdf",
    )