"""
DRF Serializers for Referrals app.
"""

from rest_framework import serializers
from .models import Referral, ReferralAutoRule
from core.serializers import PatientListSerializer, ClinicSerializer


class ReferralListSerializer(serializers.ModelSerializer):
    """Lightweight serializer for referral lists."""
    
    patient_name = serializers.CharField(source='patient.get_full_name', read_only=True)
    from_clinic_name = serializers.CharField(source='from_clinic.name_en', read_only=True)
    to_clinic_name = serializers.CharField(source='to_clinic.name_en', read_only=True)
    from_provider_name = serializers.CharField(source='from_provider.get_full_name', read_only=True)
    status_display = serializers.CharField(source='get_status_display', read_only=True)
    urgency_display = serializers.CharField(source='get_urgency_display', read_only=True)
    
    class Meta:
        model = Referral
        fields = [
            'id', 'patient', 'patient_name',
            'from_clinic', 'from_clinic_name',
            'to_clinic', 'to_clinic_name',
            'from_provider', 'from_provider_name',
            'is_internal', 'external_provider_name',
            'urgency', 'urgency_display',
            'status', 'status_display',
            'created_at'
        ]
        read_only_fields = ['id', 'created_at']


class ReferralDetailSerializer(serializers.ModelSerializer):
    """Detailed serializer for referral detail views."""
    
    patient = PatientListSerializer(read_only=True)
    from_clinic = ClinicSerializer(read_only=True)
    to_clinic = ClinicSerializer(read_only=True)
    from_provider_name = serializers.CharField(source='from_provider.get_full_name', read_only=True)
    to_provider_name = serializers.CharField(source='to_provider.get_full_name', read_only=True)
    status_display = serializers.CharField(source='get_status_display', read_only=True)
    urgency_display = serializers.CharField(source='get_urgency_display', read_only=True)
    
    class Meta:
        model = Referral
        fields = [
            'id', 'patient', 'from_clinic', 'to_clinic',
            'from_provider', 'from_provider_name',
            'to_provider', 'to_provider_name',
            'is_internal', 'external_provider_name', 'external_provider_contact',
            'reason', 'clinical_summary',
            'urgency', 'urgency_display',
            'status', 'status_display',
            'response_notes', 'responded_at', 'completed_at',
            'notes', 'created_at', 'updated_at'
        ]
        read_only_fields = ['id', 'created_at', 'updated_at', 'responded_at', 'completed_at']


class ReferralCreateSerializer(serializers.ModelSerializer):
    """Serializer for creating referrals."""
    
    class Meta:
        model = Referral
        fields = [
            'patient', 'from_clinic', 'to_clinic',
            'from_provider', 'to_provider',
            'external_provider_name', 'external_provider_contact',
            'reason', 'clinical_summary', 'urgency', 'notes'
        ]
    
    def validate(self, data):
        """Validate referral data."""
        # Check if internal or external
        to_clinic = data.get('to_clinic')
        external_provider_name = data.get('external_provider_name')
        
        if not to_clinic and not external_provider_name:
            raise serializers.ValidationError(
                "Either to_clinic or external_provider_name must be provided"
            )
        
        if to_clinic and external_provider_name:
            raise serializers.ValidationError(
                "Cannot specify both internal clinic and external provider"
            )
        
        # Set is_internal flag
        data['is_internal'] = bool(to_clinic)
        
        return data


class ReferralResponseSerializer(serializers.Serializer):
    """Serializer for referral responses (accept/reject)."""
    
    response_notes = serializers.CharField(required=True)
    
    def validate_response_notes(self, value):
        """Ensure response notes are provided."""
        if not value or not value.strip():
            raise serializers.ValidationError("Response notes are required")
        return value


class ReferralAutoRuleSerializer(serializers.ModelSerializer):
    """Serializer for ReferralAutoRule model."""
    
    from_clinic_name = serializers.CharField(source='from_clinic.name_en', read_only=True)
    to_clinic_name = serializers.CharField(source='to_clinic.name_en', read_only=True)
    
    class Meta:
        model = ReferralAutoRule
        fields = [
            'id', 'from_clinic', 'from_clinic_name',
            'to_clinic', 'to_clinic_name',
            'condition', 'is_active'
        ]
        read_only_fields = ['id']