#!/usr/bin/env python
"""
Test script to verify all survey mapping CRUD operations work correctly with UUIDs.
This tests CREATE, READ, UPDATE, and DELETE operations.

Run with: python manage.py shell < test_survey_mapping_crud.py
Or: python -c "import os; os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'PX360.settings'); import django; django.setup(); exec(open('test_survey_mapping_crud.py').read())"
"""

import sys
import os

# Add current directory to path
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from apps.integrations.models import SurveyTemplateMapping
from apps.integrations.serializers import SurveyTemplateMappingSerializer
from apps.organizations.models import Hospital
from apps.surveys.models import SurveyTemplate
from django.core.exceptions import ValidationError

print("=" * 70)
print("SURVEY MAPPING CRUD OPERATIONS TEST")
print("=" * 70)

# Get test data
hospitals = Hospital.objects.all()
survey_templates = SurveyTemplate.objects.all()

if hospitals.count() < 1:
    print("ERROR: Need at least 1 hospital to test")
    sys.exit(1)

if survey_templates.count() < 1:
    print("ERROR: Need at least 1 survey template to test")
    sys.exit(1)

hospital = hospitals.first()
survey_template = survey_templates.filter(hospital=hospital).first()

if not survey_template:
    # If no template for the first hospital, use the first template
    survey_template = survey_templates.first()

# Clean up any existing mappings for this hospital and patient type
existing_mappings = SurveyTemplateMapping.objects.filter(
    hospital=hospital,
    patient_type='2'
)
count = existing_mappings.count()
if count > 0:
    print(f"\nCleaning up {count} existing mappings for testing...")
    existing_mappings.delete()
    print(f"✓ Cleaned up {count} existing mappings")

print(f"\nTest Data:")
print(f"  Hospital: {hospital.name} (ID: {hospital.id})")
print(f"  Survey Template: {survey_template.name} (ID: {survey_template.id})")
print(f"  Patient Type: 2 (Outpatient)")

# Test 1: CREATE operation
print("\n" + "=" * 70)
print("TEST 1: CREATE - Creating new survey mapping")
print("=" * 70)

try:
    # Test direct model creation
    mapping = SurveyTemplateMapping(
        hospital=hospital,
        patient_type='2',
        survey_template=survey_template,
        is_active=True
    )
    mapping.save()
    print(f"✓ SUCCESS: Created mapping with ID: {mapping.id}")
    print(f"  Hospital ID type: {type(mapping.hospital_id)}")
    print(f"  Survey Template ID type: {type(mapping.survey_template_id)}")
    
    # Test serializer creation (should fail due to unique constraint - this is expected!)
    serializer_data = {
        'hospital': str(hospital.id),
        'patient_type': '2',
        'survey_template': str(survey_template.id),
        'is_active': True
    }
    serializer = SurveyTemplateMappingSerializer(data=serializer_data)
    if serializer.is_valid():
        print(f"⚠ WARNING: Serializer validation passed (should have failed with unique constraint)")
    else:
        print(f"✓ SUCCESS: Unique constraint working correctly")
        print(f"  Expected error: {serializer.errors}")
    
except Exception as e:
    print(f"✗ FAILED: {e}")
    import traceback
    traceback.print_exc()
    sys.exit(1)

# Test 2: READ operation
print("\n" + "=" * 70)
print("TEST 2: READ - Retrieving survey mapping")
print("=" * 70)

try:
    # Retrieve the mapping
    retrieved_mapping = SurveyTemplateMapping.objects.get(id=mapping.id)
    print(f"✓ SUCCESS: Retrieved mapping")
    print(f"  Hospital: {retrieved_mapping.hospital.name}")
    print(f"  Patient Type: {retrieved_mapping.get_patient_type_display()}")
    print(f"  Survey Template: {retrieved_mapping.survey_template.name}")
    
    # Test serialization
    serializer = SurveyTemplateMappingSerializer(retrieved_mapping)
    data = serializer.data
    print(f"✓ SUCCESS: Serialized mapping")
    print(f"  Hospital ID in data: {data['hospital']}")
    print(f"  Survey Template ID in data: {data['survey_template']}")
    
except Exception as e:
    print(f"✗ FAILED: {e}")
    import traceback
    traceback.print_exc()
    sys.exit(1)

# Test 3: UPDATE operation
print("\n" + "=" * 70)
print("TEST 3: UPDATE - Updating survey mapping")
print("=" * 70)

try:
    # Change patient type from 2 to 3
    original_patient_type = mapping.patient_type
    mapping.patient_type = '3'  # Change to Emergency
    mapping.is_active = False
    mapping.save()
    
    print(f"✓ SUCCESS: Updated mapping")
    print(f"  Original patient type: {original_patient_type}")
    print(f"  New patient type: {mapping.patient_type}")
    print(f"  New active status: {mapping.is_active}")
    
    # Test serializer update
    update_data = {
        'hospital': str(hospital.id),
        'patient_type': '4',  # Day Case
        'survey_template': str(survey_template.id),
        'is_active': True
    }
    serializer = SurveyTemplateMappingSerializer(mapping, data=update_data, partial=True)
    if serializer.is_valid():
        updated_mapping = serializer.save()
        print(f"✓ SUCCESS: Serializer update passed")
        print(f"  Updated patient type via serializer: {updated_mapping.patient_type}")
    else:
        print(f"✗ FAILED: Serializer validation failed")
        print(f"  Errors: {serializer.errors}")
        sys.exit(1)
    
except Exception as e:
    print(f"✗ FAILED: {e}")
    import traceback
    traceback.print_exc()
    sys.exit(1)

# Test 4: DELETE operation
print("\n" + "=" * 70)
print("TEST 4: DELETE - Deleting survey mapping")
print("=" * 70)

try:
    mapping_id = mapping.id
    mapping.delete()
    print(f"✓ SUCCESS: Deleted mapping with ID: {mapping_id}")
    
    # Verify it's gone
    try:
        SurveyTemplateMapping.objects.get(id=mapping_id)
        print(f"✗ FAILED: Mapping still exists after delete")
        sys.exit(1)
    except SurveyTemplateMapping.DoesNotExist:
        print(f"✓ SUCCESS: Verified mapping is deleted")
    
except Exception as e:
    print(f"✗ FAILED: {e}")
    import traceback
    traceback.print_exc()
    sys.exit(1)

# Test 5: Edge case - Try to create duplicate mapping
print("\n" + "=" * 70)
print("TEST 5: EDGE CASE - Attempting duplicate mapping")
print("=" * 70)

try:
    # Create first mapping
    mapping1 = SurveyTemplateMapping(
        hospital=hospital,
        patient_type='2',
        survey_template=survey_template,
        is_active=True
    )
    mapping1.save()
    print(f"✓ Created first mapping")
    
    # Try to create duplicate
    mapping2 = SurveyTemplateMapping(
        hospital=hospital,
        patient_type='2',
        survey_template=survey_template,
        is_active=True
    )
    mapping2.save()
    print(f"⚠ WARNING: Duplicate mapping was created (no unique constraint)")
    # Clean up
    mapping1.delete()
    mapping2.delete()
    
except Exception as e:
    print(f"✓ SUCCESS: Duplicate prevented with error: {e}")
    # Clean up if first was created
    try:
        mapping1.delete()
    except:
        pass

# Test 6: Test with different patient types
print("\n" + "=" * 70)
print("TEST 6: MULTIPLE TYPES - Creating mappings for different patient types")
print("=" * 70)

test_types = [
    ('1', 'Inpatient'),
    ('2', 'Outpatient'),
    ('3', 'Emergency'),
    ('4', 'Day Case'),
    ('O', 'Outpatient (Type O)'),
    ('E', 'Emergency (Type E)'),
]

created_mappings = []
try:
    for patient_type, description in test_types:
        mapping = SurveyTemplateMapping(
            hospital=hospital,
            patient_type=patient_type,
            survey_template=survey_template,
            is_active=True
        )
        mapping.save()
        created_mappings.append(mapping)
        print(f"✓ Created mapping for: {description} (Type {patient_type})")
    
    print(f"✓ SUCCESS: Created {len(created_mappings)} mappings for different patient types")
    
except Exception as e:
    print(f"✗ FAILED: {e}")
    import traceback
    traceback.print_exc()
    # Clean up
    for m in created_mappings:
        m.delete()
    sys.exit(1)

# Clean up test mappings
print("\n" + "=" * 70)
print("CLEANUP - Removing test mappings")
print("=" * 70)

for m in created_mappings:
    m.delete()
print(f"✓ Cleaned up {len(created_mappings)} test mappings")

# Summary
print("\n" + "=" * 70)
print("TEST SUMMARY")
print("=" * 70)
print("✓ All CRUD operations working correctly with UUIDs")
print("✓ CREATE: New mappings can be created")
print("✓ READ: Mappings can be retrieved and serialized")
print("✓ UPDATE: Mappings can be modified")
print("✓ DELETE: Mappings can be removed")
print("✓ Multiple patient types: Different patient types work correctly")
print("\nThe UUID fix is working as expected!")
print("=" * 70)