"""
Simulator views for testing external notification APIs.

This module provides API endpoints that:
- Simulate external email and SMS services
- Receive and process HIS journey events
- Create journeys, send surveys, and trigger notifications
"""
import logging
from datetime import datetime, timedelta
from django.conf import settings
from django.core.mail import send_mail
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status
import json

from .serializers import HISJourneyEventSerializer, HISJourneyEventListSerializer
from .models import HISRequestLog
from apps.journeys.models import (
    JourneyType,
    PatientJourneyTemplate,
    PatientJourneyInstance,
    PatientJourneyStageInstance,
    StageStatus
)
from apps.organizations.models import Hospital, Department, Patient
from apps.surveys.models import SurveyTemplate, SurveyInstance
from apps.notifications.services import NotificationService
import time


def make_json_serializable(data):
    """
    Convert datetime objects to ISO strings for JSON serialization.
    
    Recursively processes dictionaries and lists to ensure all datetime
    objects are converted to ISO format strings for storage in JSON fields.
    
    Args:
        data: Data structure that may contain datetime objects
    
    Returns:
        Data structure with datetime objects converted to ISO strings
    """
    if isinstance(data, dict):
        return {k: make_json_serializable(v) for k, v in data.items()}
    elif isinstance(data, list):
        return [make_json_serializable(item) for item in data]
    elif isinstance(data, datetime):
        return data.isoformat()
    else:
        return data

logger = logging.getLogger(__name__)

# Request counter for tracking
request_counter = {'email': 0, 'sms': 0}

# Request history (last 10 requests)
request_history = []


def log_simulator_request(channel, payload, status, response_data=None, error_message=None, 
                          processing_time_ms=None, request=None):
    """
    Log simulator request to history, file, and database.
    
    Args:
        channel: Channel type (email, sms, his_event)
        payload: Request payload data
        status: Request status (success, failed, partial, sent)
        response_data: Response data from simulator
        error_message: Error message if failed
        processing_time_ms: Processing time in milliseconds
        request: HTTP request object for IP/user agent
    """
    # Log to in-memory history (keeps last 10)
    request_id = len(request_history) + 1
    entry = {
        'id': request_id,
        'channel': channel,
        'timestamp': datetime.now().isoformat(),
        'status': status,
        'payload': payload
    }
    request_history.append(entry)
    
    if len(request_history) > 10:
        request_history.pop(0)
    
    # Log to file
    logger.info(f"[Simulator] {channel.upper()} Request #{request_id}: {status}")
    
    # Log to database
    try:
        # Convert datetime objects to ISO strings for JSON serialization
        serializable_response_data = make_json_serializable(response_data) if response_data else None
        
        log_entry = HISRequestLog(
            channel=channel,
            payload=payload,
            status=status,
            response_data=serializable_response_data,
            processing_time_ms=processing_time_ms,
            error_message=error_message,
            ip_address=request.META.get('REMOTE_ADDR') if request else None,
            user_agent=request.META.get('HTTP_USER_AGENT') if request else None
        )
        
        # Extract channel-specific fields
        if channel == 'email':
            log_entry.recipient = payload.get('to')
            log_entry.subject = payload.get('subject')
            message = payload.get('message', '')
            log_entry.message_preview = message[:500] if message else None
        elif channel == 'sms':
            log_entry.recipient = payload.get('to')
            message = payload.get('message', '')
            log_entry.message_preview = message[:500] if message else None
        elif channel == 'his_event':
            # Extract from first event if it's a list
            events = payload.get('events', [])
            if events and isinstance(events, list) and len(events) > 0:
                first_event = events[0]
                log_entry.patient_id = first_event.get('mrn')
                log_entry.journey_id = first_event.get('encounter_id')
                log_entry.hospital_code = first_event.get('hospital_code')
                log_entry.event_type = first_event.get('event_type')
                log_entry.visit_type = first_event.get('visit_type')
                log_entry.department = first_event.get('department')
        
        log_entry.save()
        logger.info(f"[Simulator] Logged to database with ID: {log_entry.request_id}")
        
    except Exception as e:
        logger.error(f"[Simulator] Failed to log to database: {str(e)}")


@csrf_exempt
@require_http_methods(["POST"])
def email_simulator(request):
    """
    Simulate external email API endpoint.
    
    Accepts POST request with JSON payload:
    {
        "to": "recipient@example.com",
        "subject": "Email subject",
        "message": "Plain text message",
        "html_message": "Optional HTML content"
    }
    
    Sends real email via Django SMTP and returns 200 OK.
    """
    request_counter['email'] += 1
    start_time = time.time()
    
    try:
        # Parse request body
        data = json.loads(request.body)
        
        # Validate required fields
        required_fields = ['to', 'subject', 'message']
        missing_fields = [field for field in required_fields if field not in data]
        
        if missing_fields:
            processing_time = int((time.time() - start_time) * 1000)
            response = {
                'success': False,
                'error': f'Missing required fields: {", ".join(missing_fields)}'
            }
            log_simulator_request('email', data, 'failed', 
                                response_data=response,
                                error_message=response['error'],
                                processing_time_ms=processing_time,
                                request=request)
            return JsonResponse(response, status=400)
        
        # Extract fields
        to_email = data['to']
        subject = data['subject']
        message = data['message']
        html_message = data.get('html_message', None)
        
        # Log the request
        logger.info(f"[Email Simulator] Sending email to {to_email}: {subject}")
        
        # Print formatted email to terminal
        print(f"\n{'╔' + '═'*68 + '╗'}")
        print(f"║{' ' * 15}📧 EMAIL SIMULATOR{' ' * 34}║")
        print(f"╠{'═'*68}╣")
        print(f"║ Request #: {request_counter['email']:<52} ║")
        print(f"╠{'═'*68}╣")
        print(f"║ To:      {to_email:<52} ║")
        print(f"║ Subject: {subject[:52]:<52} ║")
        print(f"╠{'═'*68}╣")
        print(f"║ Message:{' '*55} ║")
        
        # Word wrap message
        words = message.split()
        line = "║         "
        for word in words:
            if len(line) + len(word) + 1 > 68:
                print(f"{line:<68} ║")
                line = "║         " + word
            else:
                if line == "║         ":
                    line += word
                else:
                    line += " " + word
        
        # Print last line if not empty
        if line != "║         ":
            print(f"{line:<68} ║")
        
        # Print HTML section if present
        if html_message:
            print(f"╠{'═'*68}╣")
            print(f"║ HTML Message:{' '*48} ║")
            html_preview = html_message[:200].replace('\n', ' ')
            print(f"║ {html_preview:<66} ║")
            if len(html_message) > 200:
                print(f"║ ... ({len(html_message)} total characters){' '*30} ║")
        
        print(f"╚{'═'*68}╝\n")
        
        # Send real email via Django SMTP
        try:
            send_mail(
                subject=subject,
                message=message,
                from_email=settings.DEFAULT_FROM_EMAIL,
                recipient_list=[to_email],
                html_message=html_message,
                fail_silently=False
            )
            logger.info(f"[Email Simulator] Email sent via SMTP to {to_email}")
            email_status = 'sent'
        except Exception as email_error:
            logger.error(f"[Email Simulator] SMTP Error: {str(email_error)}")
            # Log as 'partial' since we displayed it but failed to send
            email_status = 'partial'
            processing_time = int((time.time() - start_time) * 1000)
            # Return error response
            response = {
                'success': False,
                'error': f'Email displayed but failed to send via SMTP: {str(email_error)}',
                'data': {
                    'to': to_email,
                    'subject': subject,
                    'message_length': len(message),
                    'has_html': html_message is not None,
                    'displayed': True,
                    'sent': False
                }
            }
            log_simulator_request('email', data, email_status,
                                response_data=response,
                                error_message=response['error'],
                                processing_time_ms=processing_time,
                                request=request)
            return JsonResponse(response, status=500)
        
        processing_time = int((time.time() - start_time) * 1000)
        # Log success
        logger.info(f"[Email Simulator] Email sent successfully to {to_email}")
        
        response = {
            'success': True,
            'message': 'Email sent successfully',
            'data': {
                'to': to_email,
                'subject': subject,
                'message_length': len(message),
                'has_html': html_message is not None
            }
        }
        
        log_simulator_request('email', data, email_status,
                            response_data=response,
                            processing_time_ms=processing_time,
                            request=request)
        
        return JsonResponse(response, status=200)
        
    except json.JSONDecodeError:
        processing_time = int((time.time() - start_time) * 1000)
        response = {
            'success': False,
            'error': 'Invalid JSON format'
        }
        log_simulator_request('email', {}, 'failed',
                            response_data=response,
                            error_message=response['error'],
                            processing_time_ms=processing_time,
                            request=request)
        return JsonResponse(response, status=400)
        
    except Exception as e:
        processing_time = int((time.time() - start_time) * 1000)
        logger.error(f"[Email Simulator] Error: {str(e)}")
        response = {
            'success': False,
            'error': str(e)
        }
        log_simulator_request('email', data if 'data' in locals() else {}, 'failed',
                            response_data=response,
                            error_message=str(e),
                            processing_time_ms=processing_time,
                            request=request)
        return JsonResponse(response, status=500)


@csrf_exempt
@require_http_methods(["POST"])
def sms_simulator(request):
    """
    Simulate external SMS API endpoint.
    
    Accepts POST request with JSON payload:
    {
        "to": "+966501234567",
        "message": "SMS message text"
    }
    
    Prints SMS to terminal with formatted output and returns 200 OK.
    """
    request_counter['sms'] += 1
    start_time = time.time()
    
    try:
        # Parse request body
        data = json.loads(request.body)
        
        # Validate required fields
        required_fields = ['to', 'message']
        missing_fields = [field for field in required_fields if field not in data]
        
        if missing_fields:
            processing_time = int((time.time() - start_time) * 1000)
            response = {
                'success': False,
                'error': f'Missing required fields: {", ".join(missing_fields)}'
            }
            log_simulator_request('sms', data, 'failed',
                                response_data=response,
                                error_message=response['error'],
                                processing_time_ms=processing_time,
                                request=request)
            return JsonResponse(response, status=400)
        
        # Extract fields
        to_phone = data['to']
        message = data['message']
        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        
        # Log the request
        logger.info(f"[SMS Simulator] Sending SMS to {to_phone}")
        
        # Print formatted SMS to terminal
        print(f"\n{'╔' + '═'*68 + '╗'}")
        print(f"║{' ' * 15}📱 SMS SIMULATOR{' ' * 35}║")
        print(f"╠{'═'*68}╣")
        print(f"║ Request #: {request_counter['sms']:<52} ║")
        print(f"╠{'═'*68}╣")
        print(f"║ To:      {to_phone:<52} ║")
        print(f"║ Time:    {timestamp:<52} ║")
        print(f"╠{'═'*68}╣")
        print(f"║ Message:{' '*55} ║")
        
        # Word wrap message
        words = message.split()
        line = "║         "
        for word in words:
            if len(line) + len(word) + 1 > 68:
                print(f"{line:<68} ║")
                line = "║         " + word
            else:
                if line == "║         ":
                    line += word
                else:
                    line += " " + word
        
        # Print last line if not empty
        if line != "║         ":
            print(f"{line:<68} ║")
        
        print(f"╚{'═'*68}╝\n")
        
        processing_time = int((time.time() - start_time) * 1000)
        # Log success
        logger.info(f"[SMS Simulator] SMS sent to {to_phone}: {message[:50]}...")
        
        response = {
            'success': True,
            'message': 'SMS sent successfully',
            'data': {
                'to': to_phone,
                'message_length': len(message)
            }
        }
        
        log_simulator_request('sms', data, 'sent',
                            response_data=response,
                            processing_time_ms=processing_time,
                            request=request)
        
        return JsonResponse(response, status=200)
        
    except json.JSONDecodeError:
        processing_time = int((time.time() - start_time) * 1000)
        response = {
            'success': False,
            'error': 'Invalid JSON format'
        }
        log_simulator_request('sms', {}, 'failed',
                            response_data=response,
                            error_message=response['error'],
                            processing_time_ms=processing_time,
                            request=request)
        return JsonResponse(response, status=400)
        
    except Exception as e:
        processing_time = int((time.time() - start_time) * 1000)
        logger.error(f"[SMS Simulator] Error: {str(e)}")
        response = {
            'success': False,
            'error': str(e)
        }
        log_simulator_request('sms', data if 'data' in locals() else {}, 'failed',
                            response_data=response,
                            error_message=str(e),
                            processing_time_ms=processing_time,
                            request=request)
        return JsonResponse(response, status=500)


@csrf_exempt
@require_http_methods(["GET"])
def health_check(request):
    """
    Health check endpoint for simulator.
    
    Returns simulator status and statistics.
    """
    return JsonResponse({
        'status': 'healthy',
        'timestamp': datetime.now().isoformat(),
        'statistics': {
            'total_requests': request_counter['email'] + request_counter['sms'],
            'email_requests': request_counter['email'],
            'sms_requests': request_counter['sms']
        },
        'recent_requests': request_history[-5:]  # Last 5 requests
    }, status=200)


@csrf_exempt
@require_http_methods(["GET"])
def reset_simulator(request):
    """
    Reset simulator statistics and history.

    Clears request counter and history.
    """
    global request_counter, request_history
    request_counter = {'email': 0, 'sms': 0}
    request_history = []
    
    logger.info("[Simulator] Reset statistics and history")
    
    return JsonResponse({
        'success': True,
        'message': 'Simulator reset successfully'
    }, status=200)


from rest_framework.permissions import AllowAny
from rest_framework.decorators import permission_classes

# Import HIS adapter and serializers
from apps.integrations.services.his_adapter import HISAdapter
from apps.integrations.serializers import HISPatientDataSerializer

@api_view(['POST'])
@permission_classes([AllowAny])
def his_patient_data_handler(request):
    """
    HIS Patient Data API Endpoint - Real HIS Format
    
    Receives patient data from HIS simulator in real HIS format:
    - Creates or updates patient records
    - Creates journey instances with stage completions
    - Sends post-discharge surveys when patient is discharged
    
    Expected payload (real HIS format):
    {
        "FetchPatientDataTimeStampList": [{
            "Type": "Patient Demographic details",
            "PatientID": "123456",
            "AdmissionID": "789012",
            "HospitalID": "1",
            "HospitalName": "ALH-main",
            "AdmitDate": "05-Jun-2025 11:06",
            "DischargeDate": "05-Jun-2025 15:30",
            "SSN": "1234567890",
            "PatientName": "Ahmed Mohammed",
            "MobileNo": "0501234567",
            ...
        }],
        "FetchPatientDataTimeStampVisitDataList": [
            {"Type": "Consultation", "BillDate": "05-Jun-2025 11:06"},
            {"Type": "Doctor Visited", "BillDate": "05-Jun-2025 11:20"},
            ...
        ],
        "Code": 200,
        "Status": "Success"
    }
    """
    start_time = time.time()
    
    try:
        # Validate request data using HIS serializer
        # print("---------------------------------------------")
        serializer = HISPatientDataSerializer(data=request.data)
        if not serializer.is_valid():
            processing_time = int((time.time() - start_time) * 1000)
            return Response(
                {'error': 'Invalid HIS data format', 'details': serializer.errors},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        # Process HIS data using adapter
        result = HISAdapter.process_his_data(serializer.validated_data)
        
        processing_time = int((time.time() - start_time) * 1000)
        
        if not result['success']:
            # Log the failed request
            log_simulator_request('his_event', request.data, 'failed',
                                response_data={'error': result['message']},
                                error_message=result['message'],
                                processing_time_ms=processing_time,
                                request=request)
            
            return Response(
                {'error': result['message']},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        # Prepare success response - only survey-related data (no journey data)
        response_data = {
            'success': True,
            'message': result['message'],
            'patient_id': str(result['patient'].id) if result['patient'] else None,
            'patient_mrn': result['patient'].mrn if result['patient'] else None,
            'patient_name': result['patient'].get_full_name() if result['patient'] else None,
            'patient_type': result.get('patient_type'),
            'survey_id': str(result['survey'].id) if result['survey'] else None,
            'survey_sent': result['survey_sent'],
            'survey_url': result['survey_url']
        }
        
        # Log the successful request
        log_simulator_request('his_event', request.data, 'success',
                            response_data=response_data,
                            processing_time_ms=processing_time,
                            request=request)
        
        return Response(response_data, status=status.HTTP_200_OK)
        
    except Exception as e:
        processing_time = int((time.time() - start_time) * 1000)
        logger.error(f"[HIS Patient Data Handler] Error: {str(e)}", exc_info=True)
        
        # Log the failed request
        log_simulator_request('his_event', request.data, 'failed',
                            response_data={'error': str(e)},
                            error_message=str(e),
                            processing_time_ms=processing_time,
                            request=request)
        
        return Response(
            {'error': 'Internal server error', 'details': str(e)},
            status=status.HTTP_500_INTERNAL_SERVER_ERROR
        )


@api_view(['POST'])
@permission_classes([AllowAny])
def his_events_handler(request):
    """
    HIS Events API Endpoint - Legacy Format
    
    Receives patient journey events from HIS simulator:
    - Creates or updates patient records
    - Creates journey instances
    - Processes stage completions
    - Sends post-discharge surveys when journey is complete
    
    Expected payload:
    {
        "events": [
            {
                "encounter_id": "ENC-2024-001",
                "mrn": "MRN-12345",
                "national_id": "1234567890",
                "first_name": "Ahmed",
                "last_name": "Mohammed",
                "phone": "+966501234567",
                "email": "patient@example.com",
                "event_type": "OPD_STAGE_1_REGISTRATION",
                "timestamp": "2024-01-20T10:30:00Z",
                "visit_type": "opd",
                "department": "Cardiology",
                "hospital_code": "ALH-main"
            }
        ]
    }
    
    NOTE: This endpoint is kept for backward compatibility.
    New integrations should use /api/simulator/his-patient-data/
    """
    start_time = time.time()
    
    try:
        # Validate request data
        serializer = HISJourneyEventListSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(
                {'error': 'Invalid data', 'details': serializer.errors},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        events_data = serializer.validated_data['events']
        
        # Process each event
        results = []
        survey_invitations_sent = []
        
        for event_data in events_data:
            result = process_his_event(event_data)
            results.append(result)
            
            # Track if survey was sent
            if result.get('survey_sent'):
                survey_invitations_sent.append({
                    'encounter_id': event_data['encounter_id'],
                    'survey_id': result['survey_id'],
                    'survey_url': result['survey_url']
                })
        
        processing_time = int((time.time() - start_time) * 1000)
        
        response_data = {
            'success': True,
            'message': f'Processed {len(events_data)} events successfully',
            'results': results,
            'surveys_sent': len(survey_invitations_sent),
            'survey_details': survey_invitations_sent
        }
        
        # Log the successful request
        log_simulator_request('his_event', request.data, 'success',
                            response_data=response_data,
                            processing_time_ms=processing_time,
                            request=request)
        
        return Response(response_data, status=status.HTTP_200_OK)
        
    except Exception as e:
        processing_time = int((time.time() - start_time) * 1000)
        logger.error(f"[HIS Events Handler] Error: {str(e)}", exc_info=True)
        
        # Log the failed request
        log_simulator_request('his_event', request.data, 'failed',
                            response_data={'error': str(e)},
                            error_message=str(e),
                            processing_time_ms=processing_time,
                            request=request)
        
        return Response(
            {'error': 'Internal server error', 'details': str(e)},
            status=status.HTTP_500_INTERNAL_SERVER_ERROR
        )


def process_his_event(event_data):
    """
    Process a single HIS journey event
    
    Steps:
    1. Get or create patient
    2. Get or create journey instance
    3. Find and update stage instance
    4. Check if journey is complete and send survey if needed
    """
    try:
        # 1. Get or create patient
        patient = get_or_create_patient(event_data)
        
        # 2. Get or create journey instance
        journey_instance = get_or_create_journey_instance(event_data, patient)
        
        # 3. Find and update stage instance
        stage_instance = update_stage_instance(journey_instance, event_data)
        
        result = {
            'encounter_id': event_data['encounter_id'],
            'patient_id': str(patient.id) if patient else None,
            'journey_id': str(journey_instance.id),
            'stage_id': str(stage_instance.id) if stage_instance else None,
            'stage_status': stage_instance.status if stage_instance else 'not_found',
            'survey_sent': False
        }
        
        # 4. Check if journey is complete and send survey
        if journey_instance.is_complete():
            survey_result = send_post_discharge_survey(journey_instance, patient)
            if survey_result:
                result.update(survey_result)
        
        return result
        
    except Exception as e:
        logger.error(f"[Process HIS Event] Error for encounter {event_data.get('encounter_id')}: {str(e)}", exc_info=True)
        return {
            'encounter_id': event_data.get('encounter_id'),
            'error': str(e),
            'success': False
        }


def get_or_create_patient(event_data):
    """Get or create patient from event data"""
    try:
        patient, created = Patient.objects.get_or_create(
            mrn=event_data['mrn'],
            defaults={
                'first_name': event_data['first_name'],
                'last_name': event_data['last_name'],
                'phone': event_data['phone'],
                'email': event_data['email'],
                'national_id': event_data.get('national_id', ''),
            }
        )
        logger.info(f"{'Created' if created else 'Found'} patient {patient.mrn}: {patient.get_full_name()}")
        return patient
    except Exception as e:
        logger.error(f"Error creating patient: {str(e)}")
        raise


def get_or_create_journey_instance(event_data, patient):
    """Get or create journey instance for this encounter"""
    try:
        # Get hospital from event data or default to ALH-main
        hospital_code = event_data.get('hospital_code', 'ALH-main')
        hospital = Hospital.objects.filter(code=hospital_code).first()
        if not hospital:
            raise ValueError(f"Hospital with code '{hospital_code}' not found. Please run seed_journey_surveys command first.")
        
        # Map visit_type to JourneyType
        journey_type_map = {
            'ems': JourneyType.EMS,
            'inpatient': JourneyType.INPATIENT,
            'opd': JourneyType.OPD
        }
        journey_type = journey_type_map.get(event_data['visit_type'])
        
        if not journey_type:
            raise ValueError(f"Invalid visit_type: {event_data['visit_type']}")
        
        # Get journey template
        journey_template = PatientJourneyTemplate.objects.filter(
            hospital=hospital,
            journey_type=journey_type,
            is_active=True
        ).first()
        
        if not journey_template:
            raise ValueError(f"No active journey template found for {journey_type}")
        
        # Get or create journey instance
        journey_instance, created = PatientJourneyInstance.objects.get_or_create(
            encounter_id=event_data['encounter_id'],
            defaults={
                'journey_template': journey_template,
                'patient': patient,
                'hospital': hospital,
                'status': 'active'
            }
        )
        
        # Create stage instances if this is a new journey
        if created:
            for stage_template in journey_template.stages.filter(is_active=True):
                PatientJourneyStageInstance.objects.create(
                    journey_instance=journey_instance,
                    stage_template=stage_template,
                    status=StageStatus.PENDING
                )
            logger.info(f"Created new journey instance {journey_instance.id} with {journey_template.stages.count()} stages")
        
        return journey_instance
        
    except Exception as e:
        logger.error(f"Error creating journey instance: {str(e)}")
        raise


def update_stage_instance(journey_instance, event_data):
    """Find and update stage instance based on event_type"""
    try:
        # Find stage template by trigger_event_code
        stage_template = journey_instance.journey_template.stages.filter(
            trigger_event_code=event_data['event_type'],
            is_active=True
        ).first()
        
        if not stage_template:
            logger.warning(f"No stage template found for event_type: {event_data['event_type']}")
            return None
        
        # Get or create stage instance
        stage_instance, created = PatientJourneyStageInstance.objects.get_or_create(
            journey_instance=journey_instance,
            stage_template=stage_template,
            defaults={
                'status': StageStatus.PENDING
            }
        )
        
        # Complete the stage
        if stage_instance.status != StageStatus.COMPLETED:
            from django.utils import timezone
            stage_instance.status = StageStatus.COMPLETED
            stage_instance.completed_at = timezone.now()
            stage_instance.save()
            logger.info(f"Completed stage {stage_template.name} for journey {journey_instance.encounter_id}")
        else:
            logger.info(f"Stage {stage_template.name} already completed for journey {journey_instance.encounter_id}")
        
        return stage_instance
        
    except Exception as e:
        logger.error(f"Error updating stage instance: {str(e)}")
        raise


def send_post_discharge_survey(journey_instance, patient):
    """
    Send post-discharge survey to patient
    
    Creates a survey instance and sends invitation via email and SMS
    """
    try:
        # Check if journey template has post-discharge survey enabled
        journey_template = journey_instance.journey_template
        if not journey_template.send_post_discharge_survey:
            return None
        
        # Check if survey already sent for this journey
        existing_survey = SurveyInstance.objects.filter(
            journey_instance=journey_instance
        ).first()
        
        if existing_survey:
            logger.info(f"Survey already sent for journey {journey_instance.encounter_id}")
            return None
        
        # Get survey template from journey template
        # Use first stage's survey template as the comprehensive survey
        first_stage = journey_template.stages.filter(is_active=True).order_by('order').first()
        if not first_stage or not first_stage.survey_template:
            logger.warning(f"No survey template found for journey {journey_instance.encounter_id}")
            return None
        
        survey_template = first_stage.survey_template
        
        # Create survey instance
        survey_instance = SurveyInstance.objects.create(
            survey_template=survey_template,
            patient=patient,
            journey_instance=journey_instance,
            hospital=journey_instance.hospital,
            delivery_channel='email',  # Primary channel is email
            status='pending',
            recipient_email=patient.email,
            recipient_phone=patient.phone
        )
        
        logger.info(f"Created survey instance {survey_instance.id} for journey {journey_instance.encounter_id}")
        
        # Send survey invitation via email
        try:
            email_log = NotificationService.send_survey_invitation(survey_instance, language='en')
            logger.info(f"Survey invitation sent via email to {patient.email}")
        except Exception as e:
            logger.error(f"Error sending survey email: {str(e)}")
        
        # Also send via SMS (as backup)
        try:
            sms_log = NotificationService.send_sms(
                phone=patient.phone,
                message=f"Your experience survey is ready: {survey_instance.get_survey_url()}",
                related_object=survey_instance,
                metadata={'survey_id': str(survey_instance.id)}
            )
            logger.info(f"Survey invitation sent via SMS to {patient.phone}")
        except Exception as e:
            logger.error(f"Error sending survey SMS: {str(e)}")
        
        # Return survey details
        return {
            'survey_sent': True,
            'survey_id': str(survey_instance.id),
            'survey_url': survey_instance.get_survey_url(),
            'delivery_channel': 'email_and_sms'
        }
        
    except Exception as e:
        logger.error(f"Error sending post-discharge survey: {str(e)}", exc_info=True)
        return {
            'survey_sent': False,
            'error': str(e)
        }