"""
Integration test for healthcare module operations.
This test MUST fail before implementation.
"""

import pytest
from django.test import TestCase
from django.urls import reverse
from rest_framework.test import APIClient
from rest_framework import status
import json
from datetime import datetime, timedelta


class HealthcareOperationsIntegrationTest(TestCase):
    def setUp(self):
        self.client = APIClient()

        # Tenant authentication header
        self.tenant_auth = {'HTTP_AUTHORIZATION': 'Bearer tenant_token'}

        # Test patient data
        self.patient_data = {
            'ic_number': '900101-10-1234',
            'name': 'Ahmad bin Hassan',
            'gender': 'MALE',
            'date_of_birth': '1990-01-01',
            'phone': '+60123456789',
            'email': 'ahmad.hassan@example.com',
            'address': {
                'street': '123 Jalan Healthcare',
                'city': 'Kuala Lumpur',
                'state': 'Wilayah Persekutuan',
                'postal_code': '50400',
                'country': 'Malaysia'
            },
            'blood_type': 'O+',
            'allergies': ['Penicillin'],
            'medications': ['Metformin 500mg']
        }

        # Test doctor data
        self.doctor_data = {
            'name': 'Dr. Sarah Johnson',
            'specialization': 'General Practitioner',
            'license_number': 'L12345',
            'department': 'Primary Care',
            'phone': '+60312345678',
            'email': 'sarah.johnson@hospital.com'
        }

    def test_complete_patient_workflow(self):
        """Test complete patient workflow from registration to treatment."""
        # Step 1: Patient registration (should fail before implementation)
        patient_response = self.client.post(
            '/api/v1/healthcare/patients/',
            data=json.dumps(self.patient_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert patient_response.status_code == status.HTTP_201_CREATED
        patient_data = patient_response.json()

        # Verify patient structure
        assert 'id' in patient_data
        assert patient_data['ic_number'] == self.patient_data['ic_number']
        assert patient_data['name'] == self.patient_data['name']
        assert patient_data['age'] == 34  # Calculated from DOB
        assert patient_data['status'] == 'ACTIVE'

        # Step 2: Create doctor
        doctor_response = self.client.post(
            '/api/v1/healthcare/doctors/',
            data=json.dumps(self.doctor_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert doctor_response.status_code == status.HTTP_201_CREATED
        doctor_data = doctor_response.json()

        # Step 3: Schedule appointment
        appointment_data = {
            'patient_id': patient_data['id'],
            'doctor_id': doctor_data['id'],
            'appointment_datetime': '2024-02-15T14:30:00+08:00',
            'duration': 30,
            'type': 'CONSULTATION',
            'reason': 'Regular checkup for diabetes management',
            'priority': 'NORMAL'
        }

        appointment_response = self.client.post(
            '/api/v1/healthcare/appointments/',
            data=json.dumps(appointment_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert appointment_response.status_code == status.HTTP_201_CREATED
        appointment_data = appointment_response.json()

        assert appointment_data['status'] == 'SCHEDULED'

        # Step 4: Update appointment status to in-progress
        status_update_response = self.client.put(
            f'/api/v1/healthcare/appointments/{appointment_data["id"]}/status/',
            data=json.dumps({'status': 'IN_PROGRESS'}),
            content_type='application/json',
            **self.tenant_auth
        )

        assert status_update_response.status_code == status.HTTP_200_OK

        # Step 5: Create medical record
        medical_record_data = {
            'patient_id': patient_data['id'],
            'appointment_id': appointment_data['id'],
            'doctor_id': doctor_data['id'],
            'diagnosis': 'Type 2 Diabetes - well controlled',
            'treatment': 'Continue current medication regimen',
            'prescriptions': [
                {
                    'medication': 'Metformin',
                    'dosage': '500mg',
                    'frequency': 'Twice daily',
                    'duration': '30 days',
                    'instructions': 'Take with meals'
                }
            ],
            'vitals': {
                'blood_pressure': '120/80',
                'heart_rate': 72,
                'temperature': 36.5,
                'weight': 75.5,
                'height': 175.0
            },
            'notes': 'Patient reports good compliance with medication. Blood sugar levels well controlled.'
        }

        record_response = self.client.post(
            '/api/v1/healthcare/medical-records/',
            data=json.dumps(medical_record_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert record_response.status_code == status.HTTP_201_CREATED
        record_data = record_response.json()

        # Step 6: Complete appointment
        complete_response = self.client.put(
            f'/api/v1/healthcare/appointments/{appointment_data["id"]}/status/',
            data=json.dumps({'status': 'COMPLETED'}),
            content_type='application/json',
            **self.tenant_auth
        )

        assert complete_response.status_code == status.HTTP_200_OK

        # Step 7: Schedule follow-up appointment
        follow_up_data = {
            'patient_id': patient_data['id'],
            'doctor_id': doctor_data['id'],
            'appointment_datetime': '2024-03-15T14:30:00+08:00',
            'duration': 20,
            'type': 'FOLLOW_UP',
            'reason': 'Diabetes follow-up'
        }

        follow_up_response = self.client.post(
            '/api/v1/healthcare/appointments/',
            data=json.dumps(follow_up_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert follow_up_response.status_code == status.HTTP_201_CREATED

    def test_medical_records_management(self):
        """Test medical records management and history."""
        # Create patient first
        patient_response = self.client.post(
            '/api/v1/healthcare/patients/',
            data=json.dumps(self.patient_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert patient_response.status_code == status.HTTP_201_CREATED
        patient_data = patient_response.json()

        # Create multiple medical records over time
        records_data = [
            {
                'diagnosis': 'Hypertension',
                'treatment': 'Lifestyle modifications',
                'prescriptions': [
                    {
                        'medication': 'Lisinopril',
                        'dosage': '10mg',
                        'frequency': 'Once daily'
                    }
                ]
            },
            {
                'diagnosis': 'Annual checkup - normal',
                'treatment': 'Continue healthy lifestyle',
                'vitals': {
                    'blood_pressure': '118/76',
                    'heart_rate': 68,
                    'cholesterol': 180
                }
            }
        ]

        created_records = []
        for record_data in records_data:
            full_record_data = {
                'patient_id': patient_data['id'],
                'doctor_id': 'doctor-001',
                'diagnosis': record_data['diagnosis'],
                'treatment': record_data['treatment'],
                **{k: v for k, v in record_data.items() if k not in ['diagnosis', 'treatment']}
            }

            record_response = self.client.post(
                '/api/v1/healthcare/medical-records/',
                data=json.dumps(full_record_data),
                content_type='application/json',
                **self.tenant_auth
            )

            assert record_response.status_code == status.HTTP_201_CREATED
            created_records.append(record_response.json())

        # Test medical history retrieval
        history_response = self.client.get(
            f'/api/v1/healthcare/patients/{patient_data["id"]}/medical-history/',
            **self.tenant_auth
        )

        assert history_response.status_code == status.HTTP_200_OK
        history_data = history_response.json()

        assert 'medical_records' in history_data
        assert 'conditions' in history_data
        assert 'medications' in history_data
        assert 'allergies' in history_data

        # Verify records are chronological
        records = history_data['medical_records']
        assert len(records) == len(created_records)

        # Test record search and filtering
        search_response = self.client.get(
            f'/api/v1/healthcare/medical-records/',
            data={'patient_id': patient_data['id'], 'diagnosis': 'Hypertension'},
            **self.tenant_auth
        )

        assert search_response.status_code == status.HTTP_200_OK
        search_results = search_response.json()['records']

        assert len(search_results) > 0
        assert any('Hypertension' in record['diagnosis'] for record in search_results)

    def test_prescription_management(self):
        """Test prescription management and dispensing."""
        # Create patient
        patient_response = self.client.post(
            '/api/v1/healthcare/patients/',
            data=json.dumps(self.patient_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert patient_response.status_code == status.HTTP_201_CREATED
        patient_data = patient_response.json()

        # Create prescription
        prescription_data = {
            'patient_id': patient_data['id'],
            'doctor_id': 'doctor-001',
            'medications': [
                {
                    'name': 'Amoxicillin',
                    'dosage': '500mg',
                    'frequency': 'Three times daily',
                    'duration': '7 days',
                    'quantity': 21,
                    'instructions': 'Take after meals',
                    'refills_allowed': 0
                },
                {
                    'name': 'Ibuprofen',
                    'dosage': '400mg',
                    'frequency': 'As needed for pain',
                    'duration': '3 days',
                    'quantity': 9,
                    'instructions': 'Take with food',
                    'refills_allowed': 1
                }
            ],
            'diagnosis': 'Bacterial infection',
            'notes': 'Complete full course of antibiotics'
        }

        prescription_response = self.client.post(
            '/api/v1/healthcare/prescriptions/',
            data=json.dumps(prescription_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert prescription_response.status_code == status.HTTP_201_CREATED
        prescription_data = prescription_response.json()

        # Test prescription status management
        dispense_data = {
            'dispensed_by': 'pharmacist-001',
            'dispensed_at': datetime.now().isoformat(),
            'notes': 'Patient counseled on medication use'
        }

        dispense_response = self.client.post(
            f'/api/v1/healthcare/prescriptions/{prescription_data["id"]}/dispense/',
            data=json.dumps(dispense_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert dispense_response.status_code == status.HTTP_200_OK

        # Test refill request
        refill_response = self.client.post(
            f'/api/v1/healthcare/prescriptions/{prescription_data["id"]}/refill/',
            data=json.dumps({}),
            content_type='application/json',
            **self.tenant_auth
        )

        assert refill_response.status_code == status.HTTP_200_OK

    def test_laboratory_and_imaging_orders(self):
        """Test laboratory and imaging order management."""
        # Create patient
        patient_response = self.client.post(
            '/api/v1/healthcare/patients/',
            data=json.dumps(self.patient_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert patient_response.status_code == status.HTTP_201_CREATED
        patient_data = patient_response.json()

        # Create lab order
        lab_order_data = {
            'patient_id': patient_data['id'],
            'doctor_id': 'doctor-001',
            'tests': [
                {
                    'test_code': 'CBC',
                    'test_name': 'Complete Blood Count',
                    'priority': 'ROUTINE',
                    'clinical_indication': 'Annual checkup'
                },
                {
                    'test_code': 'HBA1C',
                    'test_name': 'Hemoglobin A1C',
                    'priority': 'ROUTINE',
                    'clinical_indication': 'Diabetes monitoring'
                }
            ],
            'notes': 'Patient fasting for 12 hours'
        }

        lab_order_response = self.client.post(
            '/api/v1/healthcare/laboratory-orders/',
            data=json.dumps(lab_order_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert lab_order_response.status_code == status.HTTP_201_CREATED
        lab_order = lab_order_response.json()

        # Update lab results
        results_data = {
            'results': [
                {
                    'test_code': 'CBC',
                    'result_value': 'Normal',
                    'reference_range': '4.5-5.5 x 10^12/L',
                    'units': 'x 10^12/L',
                    'status': 'NORMAL'
                },
                {
                    'test_code': 'HBA1C',
                    'result_value': '6.2',
                    'reference_range': '< 5.7%',
                    'units': '%',
                    'status': 'ABNORMAL',
                    'notes': 'Slightly elevated - monitor'
                }
            ],
            'interpreted_by': 'Dr. Lab Specialist',
            'interpretation': 'HbA1c shows prediabetes range'
        }

        results_response = self.client.post(
            f'/api/v1/healthcare/laboratory-orders/{lab_order["id"]}/results/',
            data=json.dumps(results_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert results_response.status_code == status.HTTP_200_OK

    def test_billing_and_insurance_integration(self):
        """Test billing and insurance claim processing."""
        # Create patient with insurance
        patient_with_insurance = self.patient_data.copy()
        patient_with_insurance['insurance'] = {
            'provider': 'Malaysia National Insurance',
            'policy_number': 'MNI-123456789',
            'coverage_details': 'Full coverage',
            'expiry_date': '2024-12-31'
        }

        patient_response = self.client.post(
            '/api/v1/healthcare/patients/',
            data=json.dumps(patient_with_insurance),
            content_type='application/json',
            **self.tenant_auth
        )

        assert patient_response.status_code == status.HTTP_201_CREATED
        patient_data = patient_response.json()

        # Create consultation and generate bill
        billing_data = {
            'patient_id': patient_data['id'],
            'services': [
                {
                    'service_code': 'CONSULT_GP',
                    'description': 'General Practitioner Consultation',
                    'amount': 150.00,
                    'quantity': 1
                },
                {
                    'service_code': 'LAB_CBC',
                    'description': 'Complete Blood Count',
                    'amount': 50.00,
                    'quantity': 1
                }
            ],
            'insurance_claim': {
                'provider': patient_data['insurance']['provider'],
                'policy_number': patient_data['insurance']['policy_number'],
                'pre_authorization_code': 'PA-2024-001'
            }
        }

        billing_response = self.client.post(
            '/api/v1/healthcare/billing/',
            data=json.dumps(billing_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert billing_response.status_code == status.HTTP_201_CREATED
        billing_data = billing_response.json()

        # Verify insurance claim processing
        assert 'insurance_coverage' in billing_data
        assert 'patient_responsibility' in billing_data
        assert 'claim_status' in billing_data

    def test_healthcare_compliance_and_reporting(self):
        """Test healthcare compliance and reporting features."""
        # Test PDPA compliance (Personal Data Protection Act)
        compliance_response = self.client.get(
            '/api/v1/healthcare/compliance/data-protection/',
            **self.tenant_auth
        )

        assert compliance_response.status_code == status.HTTP_200_OK
        compliance_data = compliance_response.json()

        assert 'consent_records' in compliance_data
        assert 'data_access_logs' in compliance_data
        assert 'retention_policies' in compliance_data

        # Test clinical reporting
        clinical_report_response = self.client.get(
            '/api/v1/healthcare/reports/clinical/',
            data={
                'period': 'monthly',
                'year': 2024,
                'month': 1
            },
            **self.tenant_auth
        )

        assert clinical_report_response.status_code == status.HTTP_200_OK
        clinical_report = clinical_report_response.json()

        assert 'patient_visits' in clinical_report
        assert 'common_diagnoses' in clinical_report
        assert 'prescription_trends' in clinical_report

        # Test adverse event reporting
        adverse_event_data = {
            'patient_id': 'patient-001',
            'event_type': 'MEDICATION_ERROR',
            'description': 'Wrong dosage administered',
            'severity': 'MINOR',
            'date_occurred': datetime.now().isoformat(),
            'reported_by': 'nurse-001',
            'actions_taken': 'Corrected dosage, patient monitored'
        }

        adverse_response = self.client.post(
            '/api/v1/healthcare/adverse-events/',
            data=json.dumps(adverse_event_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert adverse_response.status_code == status.HTTP_201_CREATED

    def test_telemedicine_integration(self):
        """Test telemedicine and virtual consultation features."""
        # Create virtual appointment
        virtual_appointment_data = {
            'patient_id': 'patient-001',
            'doctor_id': 'doctor-001',
            'appointment_datetime': '2024-02-15T15:00:00+08:00',
            'duration': 20,
            'type': 'CONSULTATION',
            'is_virtual': True,
            'virtual_consultation': {
                'platform': 'ZOOM',
                'link': 'https://zoom.us/j/123456789',
                'instructions': 'Join 5 minutes early, test audio/video',
                'meeting_id': '123456789',
                'password': 'health2024'
            },
            'reason': 'Follow-up consultation'
        }

        virtual_response = self.client.post(
            '/api/v1/healthcare/appointments/',
            data=json.dumps(virtual_appointment_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert virtual_response.status_code == status.HTTP_201_CREATED
        virtual_appointment = virtual_response.json()

        assert virtual_appointment['is_virtual'] is True
        assert 'virtual_consultation' in virtual_appointment

        # Test telemedicine session logging
        session_log_data = {
            'appointment_id': virtual_appointment['id'],
            'start_time': '2024-02-15T15:00:00Z',
            'end_time': '2024-02-15T15:18:00Z',
            'duration_minutes': 18,
            'connection_quality': 'GOOD',
            'technical_issues': None,
            'notes': 'Successful virtual consultation'
        }

        session_log_response = self.client.post(
            '/api/v1/healthcare/telemedicine/session-logs/',
            data=json.dumps(session_log_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert session_log_response.status_code == status.HTTP_201_CREATED

    def test_emergency_management(self):
        """Test emergency case management and triage."""
        # Create emergency appointment
        emergency_data = {
            'patient_id': 'patient-001',
            'doctor_id': 'doctor-emergency',
            'appointment_datetime': datetime.now().isoformat(),
            'duration': 60,
            'type': 'EMERGENCY',
            'priority': 'URGENT',
            'reason': 'Chest pain and shortness of breath',
            'triage_level': 'YELLOW'
        }

        emergency_response = self.client.post(
            '/api/v1/healthcare/appointments/',
            data=json.dumps(emergency_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert emergency_response.status_code == status.HTTP_201_CREATED
        emergency_appointment = emergency_response.json()

        assert emergency_appointment['type'] == 'EMERGENCY'
        assert emergency_appointment['priority'] == 'URGENT'

        # Test emergency response protocol
        protocol_response = self.client.get(
            f'/api/v1/healthcare/emergency/protocols/{emergency_appointment["triage_level"]}/',
            **self.tenant_auth
        )

        assert protocol_response.status_code == status.HTTP_200_OK
        protocol_data = protocol_response.json()

        assert 'response_time_target' in protocol_data
        assert 'required_actions' in protocol_data
        assert 'staffing_requirements' in protocol_data