"""
Appointments views for the Tenhal Multidisciplinary Healthcare Platform.

This module contains views for appointment management including:
- Appointment CRUD operations
- State machine transitions (confirm, reschedule, cancel, arrive, start, complete)
- Calendar views
- Provider schedules
- Appointment reminders
"""

from django.contrib.auth.mixins import LoginRequiredMixin
from django.db.models import Q, Count
from django.http import JsonResponse, HttpResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from django.views import View
from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
from django.urls import reverse_lazy
from django.contrib import messages

from core.mixins import (
    TenantFilterMixin,
    RolePermissionMixin,
    AuditLogMixin,
    HTMXResponseMixin,
    SuccessMessageMixin,
    PaginationMixin,
)
from core.models import *
from .models import *
from .forms import *


class AppointmentListView(LoginRequiredMixin, TenantFilterMixin, PaginationMixin,
                         HTMXResponseMixin, ListView):
    """
    Appointment list view with filtering and search.
    
    Features:
    - Filter by status, clinic, provider, date range
    - Search by patient name/MRN
    - Role-based filtering (providers see only their appointments)
    - Export to CSV
    """
    model = Appointment
    template_name = 'appointments/appointment_list.html'
    htmx_template_name = 'appointments/partials/appointment_list_partial.html'
    context_object_name = 'appointments'
    paginate_by = 25
    
    def get_queryset(self):
        """Get filtered queryset based on role and filters."""
        queryset = super().get_queryset()
        user = self.request.user
        
        # Role-based filtering
        if user.role in [User.Role.DOCTOR, User.Role.NURSE, User.Role.OT, 
                        User.Role.SLP, User.Role.ABA]:
            # Clinical staff see only their appointments
            queryset = queryset.filter(provider__user=user)
        
        # Apply search
        search_query = self.request.GET.get('search', '').strip()
        if search_query:
            queryset = queryset.filter(
                Q(patient__first_name_en__icontains=search_query) |
                Q(patient__last_name_en__icontains=search_query) |
                Q(patient__mrn__icontains=search_query) |
                Q(appointment_number__icontains=search_query)
            )
        
        # Apply filters
        status = self.request.GET.get('status')
        if status:
            queryset = queryset.filter(status=status)
        
        clinic_id = self.request.GET.get('clinic')
        if clinic_id:
            queryset = queryset.filter(clinic_id=clinic_id)
        
        provider_id = self.request.GET.get('provider')
        if provider_id:
            queryset = queryset.filter(provider_id=provider_id)
        
        date_from = self.request.GET.get('date_from')
        if date_from:
            queryset = queryset.filter(appointment_date__gte=date_from)
        
        date_to = self.request.GET.get('date_to')
        if date_to:
            queryset = queryset.filter(appointment_date__lte=date_to)
        
        # Default ordering
        return queryset.select_related(
            'patient', 'provider', 'clinic', 'room', 'cancelled_by',
        ).order_by('-scheduled_date', '-scheduled_time')
    
    def get_context_data(self, **kwargs):
        """Add filter options to context."""
        context = super().get_context_data(**kwargs)
        
        # Add search form
        context['search_form'] = AppointmentSearchForm(self.request.GET)
        
        # Add filter options
        context['clinics'] = Clinic.objects.filter(tenant=self.request.user.tenant)
        context['providers'] = User.objects.filter(
            tenant=self.request.user.tenant,
            role__in=[User.Role.DOCTOR, User.Role.NURSE, User.Role.OT, 
                     User.Role.SLP, User.Role.ABA]
        )
        context['status_choices'] = Appointment.Status.choices
        
        # Add current filters
        context['current_filters'] = {
            'search': self.request.GET.get('search', ''),
            'status': self.request.GET.get('status', ''),
            'clinic': self.request.GET.get('clinic', ''),
            'provider': self.request.GET.get('provider', ''),
            'date_from': self.request.GET.get('date_from', ''),
            'date_to': self.request.GET.get('date_to', ''),
        }
        
        return context


class AppointmentCalendarView(LoginRequiredMixin, TenantFilterMixin, ListView):
    """
    Calendar view for appointments.
    
    Features:
    - Weekly/monthly calendar grid
    - Filter by clinic/provider
    - Drag-and-drop rescheduling (HTMX)
    - Color-coded by status
    """
    model = Appointment
    template_name = 'appointments/appointment_calendar.html'
    context_object_name = 'appointments'
    
    def get_queryset(self):
        """Get appointments for the selected date range."""
        queryset = super().get_queryset()
        user = self.request.user
        
        # Role-based filtering
        if user.role in [User.Role.DOCTOR, User.Role.NURSE, User.Role.OT,
                        User.Role.SLP, User.Role.ABA, User.Role.ADMIN]:
            queryset = queryset.filter(provider__user=user)
        
        # Get date range (default: current week)
        view_type = self.request.GET.get('view', 'week')  # week or month
        date_str = self.request.GET.get('date')
        
        if date_str:
            from datetime import datetime
            base_date = datetime.strptime(date_str, '%Y-%m-%d').date()
        else:
            base_date = timezone.now().date()
        
        if view_type == 'week':
            # Get week range
            start_date = base_date - timezone.timedelta(days=base_date.weekday())
            end_date = start_date + timezone.timedelta(days=6)
        else:  # month
            # Get month range
            start_date = base_date.replace(day=1)
            if base_date.month == 12:
                end_date = base_date.replace(year=base_date.year + 1, month=1, day=1)
            else:
                end_date = base_date.replace(month=base_date.month + 1, day=1)
            end_date = end_date - timezone.timedelta(days=1)
        
        queryset = queryset.filter(
            scheduled_date__gte=start_date,
            scheduled_date__lte=end_date
        )
        
        # Apply filters
        clinic_id = self.request.GET.get('clinic')
        if clinic_id:
            queryset = queryset.filter(clinic_id=clinic_id)
        
        provider_id = self.request.GET.get('provider')
        if provider_id:
            queryset = queryset.filter(provider_id=provider_id)
        
        return queryset.select_related('patient', 'provider', 'clinic', 'service')
    
    def get_context_data(self, **kwargs):
        """Add calendar data to context."""
        context = super().get_context_data(**kwargs)
        
        # Add filter options
        context['clinics'] = Clinic.objects.filter(tenant=self.request.user.tenant)
        context['providers'] = User.objects.filter(
            tenant=self.request.user.tenant,
            role__in=[User.Role.DOCTOR, User.Role.NURSE, User.Role.OT, 
                     User.Role.SLP, User.Role.ABA, User.Role.ADMIN]
        )
        
        # Get unique service types for filter
        context['services'] = Appointment.objects.filter(
            tenant=self.request.user.tenant
        ).values_list('service_type', flat=True).distinct().order_by('service_type')
        
        # Add view type and date
        context['view_type'] = self.request.GET.get('view', 'week')
        context['current_date'] = self.request.GET.get('date', timezone.now().date())
        
        # Calendar customization settings
        context['calendar_settings'] = {
            'initial_view': 'dayGridMonth',
            'slot_duration': '00:30:00',
            'slot_min_time': '08:00:00',
            'slot_max_time': '18:00:00',
            'weekends': True,
            'all_day_slot': False,
            'event_time_format': 'h:mm a',
            'slot_label_format': 'h:mm a',
        }
        
        # Event status colors
        context['status_colors'] = {
            'BOOKED': '#0d6efd',
            'CONFIRMED': '#198754',
            'ARRIVED': '#ffc107',
            'IN_PROGRESS': '#fd7e14',
            'COMPLETED': '#6c757d',
            'CANCELLED': '#dc3545',
            'NO_SHOW': '#6c757d',
            'RESCHEDULED': '#0dcaf0',
        }
        
        return context


class AppointmentDetailView(LoginRequiredMixin, TenantFilterMixin, DetailView):
    """
    Appointment detail view.
    
    Features:
    - Full appointment details
    - Patient information
    - Status history
    - Available actions based on current status
    - Related clinical documents
    """
    model = Appointment
    template_name = 'appointments/appointment_detail.html'
    context_object_name = 'appointment'
    
    def get_context_data(self, **kwargs):
        """Add related data and available actions."""
        context = super().get_context_data(**kwargs)
        appointment = self.object
        
        # Get available actions based on current status
        context['available_actions'] = self._get_available_actions(appointment)
        
        # Get status history (if using simple_history)
        if hasattr(appointment, 'history'):
            context['status_history'] = appointment.history.all()[:10]
        
        # Get related clinical documents
        context['clinical_documents'] = self._get_clinical_documents(appointment)
        
        # Check if user can modify
        context['can_modify'] = self._can_user_modify(appointment)
        
        return context
    
    def _get_available_actions(self, appointment):
        """Get list of available actions based on current status."""
        actions = []
        status = appointment.status
        
        if status == Appointment.Status.BOOKED:
            actions.extend(['confirm', 'reschedule', 'cancel'])
        elif status == Appointment.Status.CONFIRMED:
            actions.extend(['arrive', 'reschedule', 'cancel'])
        elif status == Appointment.Status.ARRIVED:
            actions.extend(['start', 'cancel'])
        elif status == Appointment.Status.IN_PROGRESS:
            actions.extend(['complete'])
        elif status == Appointment.Status.RESCHEDULED:
            actions.extend(['confirm', 'cancel'])
        
        return actions
    
    def _get_clinical_documents(self, appointment):
        """Get clinical documents related to this appointment."""
        documents = {}
        patient = appointment.patient
        
        # Import models
        from nursing.models import NursingEncounter
        from medical.models import MedicalConsultation, MedicalFollowUp
        from aba.models import ABAConsult
        from ot.models import OTConsult, OTSession
        from slp.models import SLPConsult, SLPAssessment, SLPIntervention
        
        # Get documents linked to this appointment
        documents['nursing'] = NursingEncounter.objects.filter(
            appointment=appointment
        ).first()
        
        documents['medical_consult'] = MedicalConsultation.objects.filter(
            appointment=appointment
        ).first()
        
        documents['medical_followup'] = MedicalFollowUp.objects.filter(
            appointment=appointment
        ).first()
        
        documents['aba'] = ABAConsult.objects.filter(
            appointment=appointment
        ).first()
        
        documents['ot_consult'] = OTConsult.objects.filter(
            appointment=appointment
        ).first()
        
        documents['ot_session'] = OTSession.objects.filter(
            appointment=appointment
        ).first()
        
        documents['slp_consult'] = SLPConsult.objects.filter(
            appointment=appointment
        ).first()
        
        documents['slp_assessment'] = SLPAssessment.objects.filter(
            appointment=appointment
        ).first()
        
        documents['slp_intervention'] = SLPIntervention.objects.filter(
            appointment=appointment
        ).first()
        
        return documents
    
    def _can_user_modify(self, appointment):
        """Check if current user can modify appointment."""
        user = self.request.user
        
        # Admin and FrontDesk can always modify
        if user.role in [User.Role.ADMIN, User.Role.FRONT_DESK]:
            return True
        
        # Provider can modify their own appointments
        if appointment.provider == user:
            return True
        
        return False


class AppointmentCreateView(LoginRequiredMixin, RolePermissionMixin, AuditLogMixin,
                           SuccessMessageMixin, CreateView):
    """
    Appointment creation view.
    
    Features:
    - Auto-generate appointment number
    - Check provider availability
    - Check patient consent
    - Send confirmation notification
    - Auto-populate patient from ?patient= URL parameter
    """
    model = Appointment
    form_class = AppointmentForm
    template_name = 'appointments/appointment_form.html'
    success_message = _("Appointment created successfully! Number: {appointment_number}")
    allowed_roles = [User.Role.ADMIN, User.Role.FRONT_DESK]
    
    def get_initial(self):
        """Set initial form values, including patient from URL parameter."""
        initial = super().get_initial()
        
        # Check for patient parameter in URL
        patient_id = self.request.GET.get('patient')
        if patient_id:
            try:
                # Verify patient exists and belongs to tenant
                from core.models import Patient
                patient = Patient.objects.get(
                    id=patient_id,
                    tenant=self.request.user.tenant
                )
                initial['patient'] = patient
            except (Patient.DoesNotExist, ValueError):
                # Invalid patient ID, ignore
                pass
        
        return initial
    
    def get_success_url(self):
        """Redirect to appointment detail."""
        return reverse_lazy('appointments:appointment_detail', kwargs={'pk': self.object.pk})
    
    def form_valid(self, form):
        """Set tenant, generate number, and send notification."""
        # Set tenant
        form.instance.tenant = self.request.user.tenant
        
        # Generate appointment number
        if not form.instance.appointment_number:
            form.instance.appointment_number = self._generate_appointment_number()
        
        # Set initial status
        form.instance.status = Appointment.Status.BOOKED
        
        # Save appointment
        response = super().form_valid(form)
        
        # Send confirmation notification (async in production)
        self._send_confirmation_notification()
        
        # Update success message
        self.success_message = self.success_message.format(
            appointment_number=self.object.appointment_number
        )
        
        return response
    
    def _generate_appointment_number(self):
        """Generate unique appointment number."""
        import random
        tenant = self.request.user.tenant
        year = timezone.now().year
        
        for _ in range(10):
            random_num = random.randint(10000, 99999)
            number = f"APT-{tenant.code}-{year}-{random_num}"
            
            if not Appointment.objects.filter(appointment_number=number).exists():
                return number
        
        # Fallback
        timestamp = int(timezone.now().timestamp())
        return f"APT-{tenant.code}-{year}-{timestamp}"
    
    def _send_confirmation_notification(self):
        """Send appointment confirmation notification."""
        # TODO: Implement notification sending
        # This would use the notifications app to send SMS/WhatsApp/Email
        pass
    
    def get_context_data(self, **kwargs):
        """Add form title to context."""
        context = super().get_context_data(**kwargs)
        context['form_title'] = _('Create New Appointment')
        context['submit_text'] = _('Create Appointment')
        return context


class AppointmentUpdateView(LoginRequiredMixin, RolePermissionMixin, TenantFilterMixin,
                           AuditLogMixin, SuccessMessageMixin, UpdateView):
    """
    Appointment update view.
    
    Features:
    - Update appointment details
    - Cannot change status (use state transition views)
    - Audit trail
    """
    model = Appointment
    form_class = AppointmentForm
    template_name = 'appointments/appointment_form.html'
    success_message = _("Appointment updated successfully!")
    allowed_roles = [User.Role.ADMIN, User.Role.FRONT_DESK, User.Role.DOCTOR,
                    User.Role.NURSE, User.Role.OT, User.Role.SLP, User.Role.ABA]
    
    def get_success_url(self):
        """Redirect to appointment detail."""
        return reverse_lazy('appointments:appointment_detail', kwargs={'pk': self.object.pk})
    
    def get_form(self, form_class=None):
        """Disable status field."""
        form = super().get_form(form_class)
        
        # Make status read-only (use state transition views instead)
        if 'status' in form.fields:
            form.fields['status'].disabled = True
            form.fields['status'].help_text = 'Use action buttons to change status'
        
        return form
    
    def get_context_data(self, **kwargs):
        """Add form title to context."""
        context = super().get_context_data(**kwargs)
        context['form_title'] = _('Update Appointment: %(number)s') % {'number': self.object.appointment_number}
        context['submit_text'] = _('Update Appointment')
        return context


# State Machine Transition Views

class AppointmentConfirmView(LoginRequiredMixin, RolePermissionMixin, AuditLogMixin, View):
    """
    Confirm appointment (BOOKED → CONFIRMED).
    
    Features:
    - Update status to CONFIRMED
    - Set confirmation timestamp
    - Send confirmation notification
    """
    allowed_roles = [User.Role.ADMIN, User.Role.FRONT_DESK]
    
    def post(self, request, pk):
        """Confirm appointment."""
        appointment = get_object_or_404(
            Appointment,
            pk=pk,
            tenant=request.user.tenant
        )
        
        # Check if transition is valid
        if appointment.status != Appointment.Status.BOOKED:
            messages.error(request, _('Appointment cannot be confirmed from current status.'))
            return redirect('appointments:appointment_detail', pk=pk)
        
        # Update status
        appointment.status = Appointment.Status.CONFIRMED
        appointment.confirmation_at = timezone.now()
        appointment.save()
        
        # Send notification
        self._send_notification(appointment, 'confirmed')
        
        messages.success(request, _('Appointment confirmed successfully!'))
        return redirect('appointments:appointment_detail', pk=pk)
    
    def _send_notification(self, appointment, event_type):
        """Send notification for appointment event."""
        # TODO: Implement notification
        pass


class AppointmentRescheduleView(LoginRequiredMixin, RolePermissionMixin, AuditLogMixin,
                               SuccessMessageMixin, UpdateView):
    """
    Reschedule appointment.
    
    Features:
    - Change date/time
    - Record reschedule reason
    - Update status to RESCHEDULED
    - Send notification
    """
    model = Appointment
    form_class = RescheduleForm
    template_name = 'appointments/appointment_reschedule.html'
    success_message = _("Appointment rescheduled successfully!")
    allowed_roles = [User.Role.ADMIN, User.Role.FRONT_DESK]
    
    def get_success_url(self):
        """Redirect to appointment detail."""
        return reverse_lazy('appointments:appointment_detail', kwargs={'pk': self.object.pk})
    
    def form_valid(self, form):
        """Update status and send notification."""
        # Update status
        form.instance.status = Appointment.Status.RESCHEDULED
        form.instance.reschedule_at = timezone.now()
        
        # Save
        response = super().form_valid(form)
        
        # Send notification
        self._send_notification(self.object, 'rescheduled')
        
        return response
    
    def _send_notification(self, appointment, event_type):
        """Send notification."""
        # TODO: Implement notification
        pass


class AppointmentCancelView(LoginRequiredMixin, RolePermissionMixin, AuditLogMixin, View):
    """
    Cancel appointment.
    
    Features:
    - Update status to CANCELLED
    - Record cancellation reason
    - Send notification
    """
    allowed_roles = [User.Role.ADMIN, User.Role.FRONT_DESK, User.Role.DOCTOR,
                    User.Role.NURSE, User.Role.OT, User.Role.SLP, User.Role.ABA]
    
    def post(self, request, pk):
        """Cancel appointment."""
        appointment = get_object_or_404(
            Appointment,
            pk=pk,
            tenant=request.user.tenant
        )
        
        # Get cancellation reason
        cancel_reason = request.POST.get('cancel_reason', '')
        
        # Update status
        appointment.status = Appointment.Status.CANCELLED
        appointment.cancel_reason = cancel_reason
        appointment.cancel_at = timezone.now()
        appointment.save()
        
        # Send notification
        self._send_notification(appointment, 'cancelled')
        
        messages.success(request, _('Appointment cancelled successfully!'))
        return redirect('appointments:appointment_detail', pk=pk)
    
    def _send_notification(self, appointment, event_type):
        """Send notification."""
        # TODO: Implement notification
        pass


class AppointmentArriveView(LoginRequiredMixin, RolePermissionMixin, AuditLogMixin, View):
    """
    Mark patient as arrived (CONFIRMED → ARRIVED).
    
    Features:
    - Update status to ARRIVED
    - Set arrival timestamp
    - Trigger check-in workflow
    """
    allowed_roles = [User.Role.ADMIN, User.Role.FRONT_DESK]
    
    def post(self, request, pk):
        """Mark patient as arrived."""
        appointment = get_object_or_404(
            Appointment,
            pk=pk,
            tenant=request.user.tenant
        )
        
        # Check if transition is valid
        if appointment.status != Appointment.Status.CONFIRMED:
            messages.error(request, _('Patient can only arrive for confirmed appointments.'))
            return redirect('appointments:appointment_detail', pk=pk)
        
        # Update status
        appointment.status = Appointment.Status.ARRIVED
        appointment.arrival_at = timezone.now()
        appointment.save()
        
        messages.success(request, _('Patient marked as arrived!'))
        return redirect('appointments:appointment_detail', pk=pk)


class AppointmentStartView(LoginRequiredMixin, RolePermissionMixin, AuditLogMixin, View):
    """
    Start appointment (ARRIVED → IN_PROGRESS).
    
    Features:
    - Update status to IN_PROGRESS
    - Set start timestamp
    - Redirect to appropriate clinical form
    """
    allowed_roles = [User.Role.DOCTOR, User.Role.NURSE, User.Role.OT, 
                    User.Role.SLP, User.Role.ABA]
    
    def post(self, request, pk):
        """Start appointment."""
        appointment = get_object_or_404(
            Appointment,
            pk=pk,
            tenant=request.user.tenant,
            provider=request.user  # Only provider can start their appointment
        )
        
        # Check if transition is valid
        if appointment.status != Appointment.Status.ARRIVED:
            messages.error(request, _('Appointment can only be started after patient arrives.'))
            return redirect('appointments:appointment_detail', pk=pk)
        
        # Update status
        appointment.status = Appointment.Status.IN_PROGRESS
        appointment.start_at = timezone.now()
        appointment.save()
        
        messages.success(request, _('Appointment started!'))
        
        # Redirect to appropriate clinical form based on clinic
        return self._redirect_to_clinical_form(appointment)
    
    def _redirect_to_clinical_form(self, appointment):
        """Redirect to appropriate clinical form based on clinic specialty."""
        clinic_specialty = appointment.clinic.specialty
        
        if clinic_specialty == Clinic.Specialty.MEDICAL:
            return redirect('medical:consultation_create', appointment_id=appointment.pk)
        elif clinic_specialty == Clinic.Specialty.NURSING:
            return redirect('nursing:encounter_create', appointment_id=appointment.pk)
        elif clinic_specialty == Clinic.Specialty.ABA:
            return redirect('aba:consult_create', appointment_id=appointment.pk)
        elif clinic_specialty == Clinic.Specialty.OT:
            return redirect('ot:consult_create', appointment_id=appointment.pk)
        elif clinic_specialty == Clinic.Specialty.SLP:
            return redirect('slp:consult_create', appointment_id=appointment.pk)
        else:
            return redirect('appointments:appointment_detail', pk=appointment.pk)


class AppointmentCompleteView(LoginRequiredMixin, RolePermissionMixin, AuditLogMixin, View):
    """
    Complete appointment (IN_PROGRESS → COMPLETED).
    
    Features:
    - Update status to COMPLETED
    - Set end timestamp
    - Trigger post-appointment workflow (invoice, follow-up)
    """
    allowed_roles = [User.Role.DOCTOR, User.Role.NURSE, User.Role.OT, 
                    User.Role.SLP, User.Role.ABA]
    
    def post(self, request, pk):
        """Complete appointment."""
        appointment = get_object_or_404(
            Appointment,
            pk=pk,
            tenant=request.user.tenant,
            provider=request.user
        )
        
        # Check if transition is valid
        if appointment.status != Appointment.Status.IN_PROGRESS:
            messages.error(request, _('Only in-progress appointments can be completed.'))
            return redirect('appointments:appointment_detail', pk=pk)
        
        # Update status
        appointment.status = Appointment.Status.COMPLETED
        appointment.end_at = timezone.now()
        appointment.save()
        
        # Trigger post-appointment workflow
        self._trigger_post_appointment_workflow(appointment)
        
        messages.success(request, _('Appointment completed successfully!'))
        return redirect('appointments:appointment_detail', pk=pk)
    
    def _trigger_post_appointment_workflow(self, appointment):
        """Trigger post-appointment tasks."""
        # TODO: Implement post-appointment workflow
        # - Create invoice
        # - Schedule follow-up
        # - Send satisfaction survey
        pass


class AppointmentNoShowView(LoginRequiredMixin, RolePermissionMixin, AuditLogMixin, View):
    """
    Mark appointment as no-show.
    
    Features:
    - Update status to NO_SHOW
    - Record timestamp
    - Send notification
    """
    allowed_roles = [User.Role.ADMIN, User.Role.FRONT_DESK]
    
    def post(self, request, pk):
        """Mark as no-show."""
        appointment = get_object_or_404(
            Appointment,
            pk=pk,
            tenant=request.user.tenant
        )
        
        # Update status
        appointment.status = Appointment.Status.NO_SHOW
        appointment.no_show_at = timezone.now()
        appointment.save()
        
        # Send notification
        self._send_notification(appointment, 'no_show')
        
        messages.warning(request, _('Appointment marked as no-show.'))
        return redirect('appointments:appointment_detail', pk=pk)
    
    def _send_notification(self, appointment, event_type):
        """Send notification."""
        # TODO: Implement notification
        pass


# ============================================================================
# Patient Confirmation Views (Phase 5)
# ============================================================================


class ConfirmAppointmentView(View):
    """
    Patient-facing appointment confirmation view.
    
    Features:
    - Public access (no login required)
    - Token-based authentication
    - Confirm or decline appointment
    - Mobile-friendly interface
    - Metadata tracking (IP, user agent)
    """
    
    def get(self, request, token):
        """Display confirmation page."""
        from .confirmation_service import ConfirmationService
        
        # Get confirmation by token
        confirmation = ConfirmationService.get_confirmation_by_token(token)
        
        if not confirmation:
            return self._render_error(
                request,
                _('Invalid Confirmation Link'),
                _('This confirmation link is invalid or has expired. Please contact the clinic.')
            )
        
        # Check if already processed
        if confirmation.status in ['CONFIRMED', 'DECLINED']:
            return self._render_already_processed(request, confirmation)
        
        # Check if expired
        if confirmation.is_expired:
            return self._render_error(
                request,
                _('Link Expired'),
                _('This confirmation link has expired. Please contact the clinic to reschedule.')
            )
        
        # Render confirmation page
        context = {
            'confirmation': confirmation,
            'appointment': confirmation.appointment,
            'patient': confirmation.appointment.patient,
            'token': token,
        }
        
        return render(request, 'appointments/confirm_appointment.html', context)
    
    def post(self, request, token):
        """Process confirmation or decline."""
        from .confirmation_service import ConfirmationService
        
        # Get confirmation
        confirmation = ConfirmationService.get_confirmation_by_token(token)
        
        if not confirmation:
            return JsonResponse({
                'success': False,
                'error': _('Invalid confirmation link')
            }, status=400)
        
        # Get action (confirm or decline)
        action = request.POST.get('action')
        
        if action == 'confirm':
            # Confirm appointment
            success, message = ConfirmationService.confirm_appointment(
                confirmation=confirmation,
                method='LINK',
                ip_address=self._get_client_ip(request),
                user_agent=request.META.get('HTTP_USER_AGENT', '')
            )
            
            if success:
                return self._render_success(request, confirmation, 'confirmed')
            else:
                return self._render_error(request, _('Confirmation Failed'), message)
        
        elif action == 'decline':
            # Get decline reason
            reason = request.POST.get('reason', 'Patient declined')
            
            # Decline appointment
            success, message = ConfirmationService.decline_appointment(
                confirmation=confirmation,
                reason=reason,
                ip_address=self._get_client_ip(request),
                user_agent=request.META.get('HTTP_USER_AGENT', '')
            )
            
            if success:
                return self._render_success(request, confirmation, 'declined')
            else:
                return self._render_error(request, _('Decline Failed'), message)
        
        else:
            return JsonResponse({
                'success': False,
                'error': _('Invalid action')
            }, status=400)
    
    def _render_error(self, request, title, message):
        """Render error page."""
        context = {
            'error_title': title,
            'error_message': message,
        }
        return render(request, 'appointments/confirmation_error.html', context)
    
    def _render_success(self, request, confirmation, action):
        """Render success page."""
        context = {
            'confirmation': confirmation,
            'appointment': confirmation.appointment,
            'action': action,
        }
        return render(request, 'appointments/confirmation_success.html', context)
    
    def _render_already_processed(self, request, confirmation):
        """Render already processed page."""
        context = {
            'confirmation': confirmation,
            'appointment': confirmation.appointment,
            'status': confirmation.status,
        }
        return render(request, 'appointments/confirmation_already_processed.html', context)
    
    def _get_client_ip(self, request):
        """Get client IP address."""
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            ip = x_forwarded_for.split(',')[0]
        else:
            ip = request.META.get('REMOTE_ADDR')
        return ip


# ============================================================================
# Availability API Views
# ============================================================================


class AvailableSlotsView(LoginRequiredMixin, View):
    """
    API endpoint to get available time slots for a provider on a specific date.
    
    Features:
    - Returns JSON list of available slots
    - Checks provider schedule
    - Excludes booked appointments
    - Supports custom duration
    """
    
    def get(self, request):
        """Get available slots."""
        from datetime import datetime
        from .availability_service import AvailabilityService
        
        # Get parameters
        provider_id = request.GET.get('provider')
        date_str = request.GET.get('date')
        duration = int(request.GET.get('duration', 30))
        
        # Validate parameters
        if not provider_id or not date_str:
            return JsonResponse({
                'success': False,
                'error': _('Provider and date are required')
            }, status=400)
        
        try:
            # Parse date
            date = datetime.strptime(date_str, '%Y-%m-%d').date()
            
            # Get available slots
            slots = AvailabilityService.get_available_slots(
                provider_id=provider_id,
                date=date,
                duration=duration
            )
            
            return JsonResponse({
                'success': True,
                'slots': slots,
                'provider_id': provider_id,
                'date': date_str,
                'duration': duration
            })
            
        except ValueError as e:
            return JsonResponse({
                'success': False,
                'error': _('Invalid date format: %(error)s') % {'error': str(e)}
            }, status=400)
        except Exception as e:
            return JsonResponse({
                'success': False,
                'error': _('Error getting available slots: %(error)s') % {'error': str(e)}
            }, status=500)


class AppointmentQuickViewView(LoginRequiredMixin, TenantFilterMixin, DetailView):
    """
    Quick view for appointment details (used in calendar modal).
    Returns a partial HTML template for AJAX loading.
    """
    model = Appointment
    template_name = 'appointments/appointment_quick_view.html'
    context_object_name = 'appointment'
    
    def get_queryset(self):
        """Filter by tenant."""
        return super().get_queryset().select_related(
            'patient', 'clinic', 'provider__user', 'room'
        )


class AppointmentEventsView(LoginRequiredMixin, TenantFilterMixin, View):
    """
    API endpoint for calendar events.
    Returns appointments in FullCalendar-compatible JSON format.
    """
    
    def get(self, request):
        """Get appointments as calendar events."""
        from datetime import datetime, timedelta
        
        # Get date range from query params
        start_str = request.GET.get('start')
        end_str = request.GET.get('end')
        
        if not start_str or not end_str:
            return JsonResponse({'error': _('start and end parameters are required')}, status=400)
        
        # Parse dates
        try:
            start_date = datetime.fromisoformat(start_str.replace('Z', '+00:00')).date()
            end_date = datetime.fromisoformat(end_str.replace('Z', '+00:00')).date()
        except ValueError:
            return JsonResponse({'error': _('Invalid date format')}, status=400)
        
        # Get appointments in date range
        queryset = Appointment.objects.filter(
            tenant=request.user.tenant,
            scheduled_date__gte=start_date,
            scheduled_date__lte=end_date
        ).select_related('patient', 'provider__user', 'clinic', 'room')
        
        # Apply filters
        service = request.GET.get('service', '').strip()
        if service:
            queryset = queryset.filter(service_type__icontains=service)
        
        provider_id = request.GET.get('provider', '').strip()
        if provider_id:
            queryset = queryset.filter(provider_id=provider_id)
        
        status_filter = request.GET.get('status', '').strip()
        if status_filter:
            queryset = queryset.filter(status=status_filter)
        
        # Build events list
        events = []
        for appointment in queryset:
            # Calculate end time
            start_datetime = datetime.combine(
                appointment.scheduled_date,
                appointment.scheduled_time
            )
            end_datetime = start_datetime + timedelta(minutes=appointment.duration)
            
            events.append({
                'id': str(appointment.id),
                'patient_name': appointment.patient.full_name_en,
                'service_name': appointment.service_type,
                'provider_name': appointment.provider.user.get_full_name(),
                'room_name': appointment.room.name if appointment.room else '',
                'start_time': start_datetime.isoformat(),
                'end_time': end_datetime.isoformat(),
                'status': appointment.status,
            })
        
        return JsonResponse(events, safe=False)


class DeclineAppointmentView(View):
    """
    Quick decline view (alternative to confirm page).
    
    Features:
    - Direct decline link
    - Optional reason
    - Confirmation message
    """
    
    def get(self, request, token):
        """Display decline confirmation page."""
        from .confirmation_service import ConfirmationService
        
        # Get confirmation
        confirmation = ConfirmationService.get_confirmation_by_token(token)
        
        if not confirmation:
            return render(request, 'appointments/confirmation_error.html', {
                'error_title': _('Invalid Link'),
                'error_message': _('This link is invalid or has expired.')
            })
        
        # Check if already processed
        if confirmation.status in ['CONFIRMED', 'DECLINED']:
            context = {
                'confirmation': confirmation,
                'appointment': confirmation.appointment,
                'status': confirmation.status,
            }
            return render(request, 'appointments/confirmation_already_processed.html', context)
        
        # Render decline form
        context = {
            'confirmation': confirmation,
            'appointment': confirmation.appointment,
            'token': token,
        }
        return render(request, 'appointments/decline_appointment.html', context)
    
    def post(self, request, token):
        """Process decline."""
        from .confirmation_service import ConfirmationService
        
        # Get confirmation
        confirmation = ConfirmationService.get_confirmation_by_token(token)
        
        if not confirmation:
            return JsonResponse({
                'success': False,
                'error': _('Invalid confirmation link')
            }, status=400)
        
        # Get reason
        reason = request.POST.get('reason', _('Patient declined'))
        
        # Decline appointment
        success, message = ConfirmationService.decline_appointment(
            confirmation=confirmation,
            reason=reason,
            ip_address=self._get_client_ip(request),
            user_agent=request.META.get('HTTP_USER_AGENT', '')
        )
        
        if success:
            context = {
                'confirmation': confirmation,
                'appointment': confirmation.appointment,
                'action': 'declined',
            }
            return render(request, 'appointments/confirmation_success.html', context)
        else:
            return render(request, 'appointments/confirmation_error.html', {
                'error_title': _('Decline Failed'),
                'error_message': message
            })
    
    def _get_client_ip(self, request):
        """Get client IP address."""
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            ip = x_forwarded_for.split(',')[0]
        else:
            ip = request.META.get('REMOTE_ADDR')
        return ip


class AppointmentPDFView(LoginRequiredMixin, TenantFilterMixin, View):
    """
    Generate PDF for appointment details.
    
    Features:
    - Appointment information
    - Patient details
    - Provider and clinic information
    - Instructions from clinical documents if available
    - Professional formatting with Arabic support
    """
    
    def get(self, request, pk):
        """Generate and return PDF."""
        from reportlab.lib.pagesizes import A4
        from reportlab.lib.units import inch
        from reportlab.lib import colors
        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
        from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, Image
        from reportlab.pdfgen import canvas
        from reportlab.pdfbase import pdfmetrics
        from reportlab.pdfbase.ttfonts import TTFont
        from reportlab.lib.enums import TA_CENTER, TA_RIGHT, TA_LEFT
        from io import BytesIO
        import os
        from django.conf import settings
        import arabic_reshaper
        from bidi.algorithm import get_display
        
        # Get appointment
        appointment = get_object_or_404(
            Appointment.objects.select_related(
                'patient', 'provider__user', 'clinic', 'room', 'tenant'
            ),
            pk=pk,
            tenant=request.user.tenant
        )
        
        # Create PDF buffer
        buffer = BytesIO()
        
        # Create PDF document
        doc = SimpleDocTemplate(
            buffer,
            pagesize=A4,
            rightMargin=0.75*inch,
            leftMargin=0.75*inch,
            topMargin=1.5*inch,
            bottomMargin=0.75*inch
        )
        
        # Container for PDF elements
        elements = []
        
        # Register Arabic font
        try:
            pdfmetrics.registerFont(TTFont('Arabic', '/System/Library/Fonts/SFArabic.ttf'))
            ARABIC_FONT_AVAILABLE = True
        except Exception as e:
            ARABIC_FONT_AVAILABLE = False
        
        # Styles
        styles = getSampleStyleSheet()
        
        # Helper function for Arabic text
        def format_arabic(text):
            """Format Arabic text for proper display in PDF."""
            if not text:
                return ""
            reshaped_text = arabic_reshaper.reshape(text)
            return get_display(reshaped_text)
        
        # Custom styles
        title_style = ParagraphStyle(
            'CustomTitle',
            parent=styles['Heading1'],
            fontSize=18,
            textColor=colors.HexColor('#0d6efd'),
            spaceAfter=20,
            alignment=TA_CENTER
        )
        heading_style = ParagraphStyle(
            'CustomHeading',
            parent=styles['Heading2'],
            fontSize=14,
            textColor=colors.HexColor('#212529'),
            spaceAfter=12,
            spaceBefore=12
        )
        normal_style = styles['Normal']
        
        # Header with logo and tenant info
        tenant = appointment.tenant
        header_data = []
        
        # Try to add logo if available from tenant settings
        logo_path = None
        try:
            from core.models import TenantSetting, SettingTemplate
            logo_setting = TenantSetting.objects.filter(
                tenant=tenant,
                template__key='basic_logo'
            ).first()
            
            if logo_setting and logo_setting.file_value:
                logo_path = os.path.join(settings.MEDIA_ROOT, str(logo_setting.file_value))
                if os.path.exists(logo_path):
                    logo = Image(logo_path, width=0.8*inch, height=0.8*inch)
                    logo.hAlign = 'LEFT'
                else:
                    logo_path = None
        except Exception as e:
            # If logo retrieval fails, continue without logo
            logo_path = None
        
        # Create header table
        if logo_path:
            tenant_info_html = f'<b>{tenant.name}</b><br/>'
            if tenant.name_ar and ARABIC_FONT_AVAILABLE:
                tenant_info_html += f'<font name="Arabic" size=11>{format_arabic(tenant.name_ar)}</font><br/>'
            
            header_data = [[logo, Paragraph(tenant_info_html, ParagraphStyle(
                'TenantInfo',
                parent=styles['Normal'],
                fontSize=12,
                alignment=TA_CENTER
            ))]]
            header_table = Table(header_data, colWidths=[2*inch, 4*inch])
            header_table.setStyle(TableStyle([
                ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
                ('ALIGN', (0, 0), (0, 0), 'LEFT'),
                ('ALIGN', (1, 0), (1, 0), 'CENTER'),
            ]))
            elements.append(header_table)
        else:
            # No logo, just tenant name
            tenant_name_html = f'<b>{tenant.name}</b><br/>'
            if tenant.name_ar and ARABIC_FONT_AVAILABLE:
                tenant_name_html += f'<font name="Arabic" size=14>{format_arabic(tenant.name_ar)}</font>'
            
            tenant_name = Paragraph(tenant_name_html, 
                                   ParagraphStyle('TenantName', parent=styles['Heading1'], fontSize=16, alignment=TA_CENTER))
            elements.append(tenant_name)
        
        elements.append(Spacer(1, 0.15*inch))
        
        # Title
        title_html = f"Appointment Details - {appointment.appointment_number}<br/>"
        if ARABIC_FONT_AVAILABLE:
            title_html += f'<font name="Arabic" size=16>{format_arabic("تفاصيل الموعد")}</font>'
        title = Paragraph(title_html, title_style)
        elements.append(title)
        elements.append(Spacer(1, 0.15*inch))
        
        # Appointment Information Section
        heading_html = "Appointment Information / "
        if ARABIC_FONT_AVAILABLE:
            heading_html += f'<font name="Arabic" size=12>{format_arabic("معلومات الموعد")}</font>'
        elements.append(Paragraph(heading_html, heading_style))
        
        # Build appointment data with Arabic font support using Paragraphs
        appointment_data = []
        cell_style = ParagraphStyle('Cell', parent=styles['Normal'], fontSize=10)
        label_style = ParagraphStyle('Label', parent=styles['Normal'], fontSize=10, fontName='Helvetica-Bold')
        
        label_html = "Appointment Number"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("رقم الموعد")}</font>'
        appointment_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(appointment.appointment_number, cell_style)
        ])
        
        label_html = "Status"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("الحالة")}</font>'
        appointment_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(appointment.get_status_display(), cell_style)
        ])
        
        label_html = "Service Type"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("نوع الخدمة")}</font>'
        appointment_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(appointment.service_type, cell_style)
        ])
        
        label_html = "Date"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("التاريخ")}</font>'
        appointment_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(appointment.scheduled_date.strftime('%A, %B %d, %Y'), cell_style)
        ])
        
        label_html = "Time"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("الوقت")}</font>'
        appointment_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(f"{appointment.scheduled_time.strftime('%H:%M')} ({appointment.duration} minutes)", cell_style)
        ])
        
        label_html = "Clinic"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("العيادة")}</font>'
        clinic_value = appointment.clinic.name_en
        if appointment.clinic.name_ar and ARABIC_FONT_AVAILABLE:
            clinic_value += f' / <font name="Arabic" size=9>{format_arabic(appointment.clinic.name_ar)}</font>'
        appointment_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(clinic_value, cell_style)
        ])
        
        label_html = "Room"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("الغرفة")}</font>'
        room_value = f"{appointment.room.room_number} - {appointment.room.name}" if appointment.room else 'Not assigned'
        appointment_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(room_value, cell_style)
        ])
        
        label_html = "Provider"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("مقدم الخدمة")}</font>'
        appointment_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(f"{appointment.provider.user.get_full_name()} ({appointment.provider.user.get_role_display()})", cell_style)
        ])
        
        appointment_table = Table(appointment_data, colWidths=[2.5*inch, 3.5*inch])
        appointment_table.setStyle(TableStyle([
            ('BACKGROUND', (0, 0), (0, -1), colors.HexColor('#f8f9fa')),
            ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
            ('ALIGN', (0, 0), (0, -1), 'RIGHT'),
            ('ALIGN', (1, 0), (1, -1), 'LEFT'),
            ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
            ('FONTNAME', (1, 0), (1, -1), 'Helvetica'),
            ('FONTSIZE', (0, 0), (-1, -1), 10),
            ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
            ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
            ('LEFTPADDING', (0, 0), (-1, -1), 8),
            ('RIGHTPADDING', (0, 0), (-1, -1), 8),
            ('TOPPADDING', (0, 0), (-1, -1), 6),
            ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
        ]))
        elements.append(appointment_table)
        elements.append(Spacer(1, 0.3*inch))
        
        # Patient Information Section
        heading_html = "Patient Information / "
        if ARABIC_FONT_AVAILABLE:
            heading_html += f'<font name="Arabic" size=12>{format_arabic("معلومات المريض")}</font>'
        elements.append(Paragraph(heading_html, heading_style))
        
        patient = appointment.patient
        patient_name_ar = f"{patient.first_name_ar} {patient.last_name_ar}" if patient.first_name_ar and patient.last_name_ar else ""
        
        # Build patient data with Arabic font support using Paragraphs
        patient_data = []
        
        label_html = "Name"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("الاسم")}</font>'
        patient_value = f"{patient.first_name_en} {patient.last_name_en}"
        if patient_name_ar and ARABIC_FONT_AVAILABLE:
            patient_value += f' / <font name="Arabic" size=9>{format_arabic(patient_name_ar)}</font>'
        patient_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(patient_value, cell_style)
        ])
        
        label_html = "MRN"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("رقم السجل الطبي")}</font>'
        patient_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(patient.mrn, cell_style)
        ])
        
        label_html = "Date of Birth"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("تاريخ الميلاد")}</font>'
        patient_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(patient.date_of_birth.strftime('%Y-%m-%d'), cell_style)
        ])
        
        label_html = "Gender"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("الجنس")}</font>'
        patient_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(patient.get_sex_display(), cell_style)
        ])
        
        label_html = "Phone"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("الهاتف")}</font>'
        patient_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(str(patient.phone), cell_style)
        ])
        
        label_html = "Email"
        if ARABIC_FONT_AVAILABLE:
            label_html += f' / <font name="Arabic" size=9>{format_arabic("البريد الإلكتروني")}</font>'
        patient_data.append([
            Paragraph(label_html + ':', label_style),
            Paragraph(patient.email if patient.email else 'Not provided', cell_style)
        ])
        
        patient_table = Table(patient_data, colWidths=[2.5*inch, 3.5*inch])
        patient_table.setStyle(TableStyle([
            ('BACKGROUND', (0, 0), (0, -1), colors.HexColor('#f8f9fa')),
            ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
            ('ALIGN', (0, 0), (0, -1), 'RIGHT'),
            ('ALIGN', (1, 0), (1, -1), 'LEFT'),
            ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
            ('FONTNAME', (1, 0), (1, -1), 'Helvetica'),
            ('FONTSIZE', (0, 0), (-1, -1), 10),
            ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
            ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
            ('LEFTPADDING', (0, 0), (-1, -1), 8),
            ('RIGHTPADDING', (0, 0), (-1, -1), 8),
            ('TOPPADDING', (0, 0), (-1, -1), 6),
            ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
        ]))
        elements.append(patient_table)
        elements.append(Spacer(1, 0.3*inch))
        
        # Notes Section (if available)
        if appointment.notes:
            heading_html = "Notes / "
            if ARABIC_FONT_AVAILABLE:
                heading_html += f'<font name="Arabic" size=12>{format_arabic("ملاحظات")}</font>'
            elements.append(Paragraph(heading_html, heading_style))
            notes_text = Paragraph(appointment.notes, normal_style)
            elements.append(notes_text)
            elements.append(Spacer(1, 0.2*inch))
        
        # Instructions Section (from clinical documents)
        instructions = self._get_clinical_instructions(appointment)
        if instructions:
            heading_html = "Clinical Instructions / "
            if ARABIC_FONT_AVAILABLE:
                heading_html += f'<font name="Arabic" size=12>{format_arabic("التعليمات السريرية")}</font>'
            elements.append(Paragraph(heading_html, heading_style))
            for instruction in instructions:
                instruction_text = Paragraph(f"• {instruction}", normal_style)
                elements.append(instruction_text)
                elements.append(Spacer(1, 0.1*inch))
        
        # Footer with generation info
        elements.append(Spacer(1, 0.5*inch))
        footer_text = f"Generated on: {timezone.now().strftime('%Y-%m-%d %H:%M:%S')}"
        footer = Paragraph(footer_text, ParagraphStyle(
            'Footer',
            parent=styles['Normal'],
            fontSize=8,
            textColor=colors.grey,
            alignment=1
        ))
        elements.append(footer)
        
        # Build PDF
        doc.build(elements)
        
        # Get PDF value
        pdf = buffer.getvalue()
        buffer.close()
        
        # Create response
        response = HttpResponse(content_type='application/pdf')
        
        # Check if view parameter is set to inline
        view_mode = request.GET.get('view', 'download')
        if view_mode == 'inline':
            response['Content-Disposition'] = f'inline; filename="appointment_{appointment.appointment_number}.pdf"'
        else:
            response['Content-Disposition'] = f'attachment; filename="appointment_{appointment.appointment_number}.pdf"'
        
        response.write(pdf)
        
        return response
    
    def _get_clinical_instructions(self, appointment):
        """Extract instructions from clinical documents."""
        instructions = []
        
        # Import models
        try:
            from nursing.models import NursingEncounter
            from medical.models import MedicalConsultation, MedicalFollowUp
            from aba.models import ABAConsult
            from ot.models import OTConsult, OTSession
            from slp.models import SLPConsult, SLPAssessment, SLPIntervention
            
            # Check nursing encounter
            nursing = NursingEncounter.objects.filter(appointment=appointment).first()
            if nursing and hasattr(nursing, 'instructions') and nursing.instructions:
                instructions.append(f"Nursing: {nursing.instructions}")
            
            # Check medical consultation
            medical_consult = MedicalConsultation.objects.filter(appointment=appointment).first()
            if medical_consult and hasattr(medical_consult, 'instructions') and medical_consult.instructions:
                instructions.append(f"Medical Consultation: {medical_consult.instructions}")
            
            # Check medical follow-up
            medical_followup = MedicalFollowUp.objects.filter(appointment=appointment).first()
            if medical_followup and hasattr(medical_followup, 'instructions') and medical_followup.instructions:
                instructions.append(f"Medical Follow-up: {medical_followup.instructions}")
            
            # Check ABA
            aba = ABAConsult.objects.filter(appointment=appointment).first()
            if aba and hasattr(aba, 'recommendations') and aba.recommendations:
                instructions.append(f"ABA Recommendations: {aba.recommendations}")
            
            # Check OT consultation
            ot_consult = OTConsult.objects.filter(appointment=appointment).first()
            if ot_consult and hasattr(ot_consult, 'recommendations') and ot_consult.recommendations:
                instructions.append(f"OT Recommendations: {ot_consult.recommendations}")
            
            # Check OT session
            ot_session = OTSession.objects.filter(appointment=appointment).first()
            if ot_session and hasattr(ot_session, 'home_program') and ot_session.home_program:
                instructions.append(f"OT Home Program: {ot_session.home_program}")
            
            # Check SLP consultation
            slp_consult = SLPConsult.objects.filter(appointment=appointment).first()
            if slp_consult and hasattr(slp_consult, 'recommendations') and slp_consult.recommendations:
                instructions.append(f"SLP Recommendations: {slp_consult.recommendations}")
            
            # Check SLP assessment
            slp_assessment = SLPAssessment.objects.filter(appointment=appointment).first()
            if slp_assessment and hasattr(slp_assessment, 'recommendations') and slp_assessment.recommendations:
                instructions.append(f"SLP Assessment Recommendations: {slp_assessment.recommendations}")
            
            # Check SLP intervention
            slp_intervention = SLPIntervention.objects.filter(appointment=appointment).first()
            if slp_intervention and hasattr(slp_intervention, 'home_program') and slp_intervention.home_program:
                instructions.append(f"SLP Home Program: {slp_intervention.home_program}")
            
        except Exception as e:
            # If any model doesn't exist or has issues, just skip it
            pass
        
        return instructions


class AppointmentEmailPDFView(LoginRequiredMixin, TenantFilterMixin, View):
    """
    Email appointment PDF to patient.
    
    Features:
    - Generate PDF
    - Send via email with optional custom message
    - Uses existing email infrastructure
    """
    
    def post(self, request, pk):
        """Send appointment PDF via email."""
        from django.core.mail import EmailMessage
        from django.template.loader import render_to_string
        from io import BytesIO
        
        # Get appointment
        appointment = get_object_or_404(
            Appointment.objects.select_related(
                'patient', 'provider__user', 'clinic', 'room', 'tenant'
            ),
            pk=pk,
            tenant=request.user.tenant
        )
        
        # Get email address and message from form
        email_address = request.POST.get('email_address', '').strip()
        custom_message = request.POST.get('email_message', '').strip()
        
        # Validate email
        if not email_address:
            messages.error(request, _('Email address is required.'))
            return redirect('appointments:appointment_detail', pk=pk)
        
        try:
            # Generate PDF using the same logic as AppointmentPDFView
            pdf_view = AppointmentPDFView()
            pdf_view.request = request
            
            # Create a mock request with GET parameters to generate PDF
            from django.test import RequestFactory
            factory = RequestFactory()
            pdf_request = factory.get(f'/appointments/{pk}/pdf/')
            pdf_request.user = request.user
            
            # Generate PDF
            pdf_response = pdf_view.get(pdf_request, pk)
            pdf_content = pdf_response.content
            
            # Prepare email subject
            subject = f"Appointment Details - {appointment.appointment_number}"
            
            # Prepare email body
            context = {
                'appointment': appointment,
                'patient': appointment.patient,
                'custom_message': custom_message,
                'tenant': appointment.tenant,
            }
            
            # Create email body (plain text)
            email_body = f"""
Dear {appointment.patient.first_name_en} {appointment.patient.last_name_en},

Please find attached the details for your appointment.

Appointment Number: {appointment.appointment_number}
Date: {appointment.scheduled_date.strftime('%A, %B %d, %Y')}
Time: {appointment.scheduled_time.strftime('%H:%M')}
Clinic: {appointment.clinic.name_en}
Provider: {appointment.provider.user.get_full_name()}

"""
            
            if custom_message:
                email_body += f"\n{custom_message}\n\n"
            
            email_body += f"""
Best regards,
{appointment.tenant.name}
"""
            
            # Create email
            email = EmailMessage(
                subject=subject,
                body=email_body,
                from_email=None,  # Will use DEFAULT_FROM_EMAIL from settings
                to=[email_address],
            )
            
            # Attach PDF
            email.attach(
                f'appointment_{appointment.appointment_number}.pdf',
                pdf_content,
                'application/pdf'
            )
            
            # Send email
            email.send(fail_silently=False)
            
            messages.success(
                request,
                _('Appointment PDF has been sent to %(email)s successfully!') % {'email': email_address}
            )
            
        except Exception as e:
            messages.error(
                request,
                _('Failed to send email: %(error)s') % {'error': str(e)}
            )
        
        return redirect('appointments:appointment_detail', pk=pk)