"""
Contract test for POST /healthcare/appointments endpoint.
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


class HealthcareAppointmentsPostContractTest(TestCase):
    def setUp(self):
        self.client = APIClient()
        self.appointments_url = '/api/v1/healthcare/appointments/'

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

        # Valid appointment data
        self.appointment_data = {
            'patient_id': 'patient-001',
            'doctor_id': 'doctor-001',
            'appointment_datetime': '2024-02-15T14:30:00+08:00',
            'duration': 30,
            'type': 'CONSULTATION',
            'reason': 'Regular checkup for diabetes management',
            'notes': 'Patient reports occasional dizziness. Need to review medication dosage.',
            'priority': 'NORMAL',
            'is_virtual': False,
            'location': {
                'room': 'Consultation Room A',
                'floor': '2nd Floor',
                'building': 'Main Medical Center'
            },
            'reminders': [
                {
                    'type': 'SMS',
                    'time_before': 1440,  # 24 hours
                    'message': 'Reminder: Your appointment is tomorrow at 2:30 PM'
                },
                {
                    'type': 'EMAIL',
                    'time_before': 60,  # 1 hour
                    'message': 'Your appointment is in 1 hour'
                }
            ],
            'follow_up': {
                'required': True,
                'interval_days': 30,
                'notes': 'Follow up to check medication effectiveness'
            }
        }

    def test_create_appointment_success(self):
        """Test successful appointment creation."""
        response = self.client.post(
            self.appointments_url,
            data=json.dumps(self.appointment_data),
            content_type='application/json',
            **self.tenant_auth
        )

        # This should fail before implementation
        assert response.status_code == status.HTTP_201_CREATED

        data = response.json()
        assert 'id' in data
        assert data['patient_id'] == self.appointment_data['patient_id']
        assert data['doctor_id'] == self.appointment_data['doctor_id']
        assert data['appointment_datetime'] == self.appointment_data['appointment_datetime']
        assert data['duration'] == self.appointment_data['duration']
        assert data['type'] == self.appointment_data['type']
        assert data['reason'] == self.appointment_data['reason']
        assert data['status'] == 'SCHEDULED'  # Default status

        # Should have timestamps
        assert 'created_at' in data
        assert 'updated_at' in data

        # Should have tenant_id from context
        assert 'tenant_id' in data

        # Should include location information
        assert 'location' in data
        assert data['location']['room'] == self.appointment_data['location']['room']

    def test_create_appointment_unauthorized(self):
        """Test appointment creation without authentication."""
        response = self.client.post(
            self.appointments_url,
            data=json.dumps(self.appointment_data),
            content_type='application/json'
        )

        assert response.status_code == status.HTTP_401_UNAUTHORIZED

    def test_create_appointment_missing_required_fields(self):
        """Test appointment creation with missing required fields."""
        incomplete_data = self.appointment_data.copy()
        del incomplete_data['patient_id']

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(incomplete_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST

        data = response.json()
        assert 'patient_id' in data.get('errors', {})

    def test_create_appointment_invalid_datetime(self):
        """Test appointment creation with invalid datetime format."""
        invalid_data = self.appointment_data.copy()
        invalid_data['appointment_datetime'] = 'invalid-datetime-format'

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(invalid_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST

    def test_create_appointment_past_datetime(self):
        """Test appointment creation with past datetime."""
        invalid_data = self.appointment_data.copy()
        invalid_data['appointment_datetime'] = '2020-01-01T10:00:00+08:00'  # Past date

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(invalid_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST

    def test_create_appointment_invalid_type(self):
        """Test appointment creation with invalid type."""
        invalid_data = self.appointment_data.copy()
        invalid_data['type'] = 'INVALID_TYPE'

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(invalid_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST

    def test_create_appointment_negative_duration(self):
        """Test appointment creation with negative duration."""
        invalid_data = self.appointment_data.copy()
        invalid_data['duration'] = -30

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(invalid_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST

    def test_create_appointment_doctor_availability_conflict(self):
        """Test appointment creation with doctor availability conflict."""
        # First request should succeed (if implemented)
        first_response = self.client.post(
            self.appointments_url,
            data=json.dumps(self.appointment_data),
            content_type='application/json',
            **self.tenant_auth
        )

        if first_response.status_code == status.HTTP_201_CREATED:
            # Second request with same doctor and overlapping time should fail
            conflicting_data = self.appointment_data.copy()
            conflicting_data['patient_id'] = 'patient-002'  # Different patient
            conflicting_data['appointment_datetime'] = '2024-02-15T14:45:00+08:00'  # Overlapping time

            second_response = self.client.post(
                self.appointments_url,
                data=json.dumps(conflicting_data),
                content_type='application/json',
                **self.tenant_auth
            )
            assert second_response.status_code == status.HTTP_409_CONFLICT

    def test_create_appointment_virtual_consultation(self):
        """Test appointment creation with virtual consultation."""
        virtual_data = self.appointment_data.copy()
        virtual_data['is_virtual'] = True
        virtual_data['virtual_consultation'] = {
            'platform': 'ZOOM',
            'link': 'https://zoom.us/j/123456789',
            'instructions': 'Please join 5 minutes early. Test your audio and video.',
            'meeting_id': '123456789',
            'password': 'health2024'
        }

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(virtual_data),
            content_type='application/json',
            **self.tenant_auth
        )

        if response.status_code == status.HTTP_201_CREATED:
            data = response.json()
            assert data['is_virtual'] is True
            assert 'virtual_consultation' in data
            virtual_info = data['virtual_consultation']
            assert virtual_info['platform'] == 'ZOOM'

    def test_create_appointment_emergency(self):
        """Test emergency appointment creation."""
        emergency_data = self.appointment_data.copy()
        emergency_data['type'] = 'EMERGENCY'
        emergency_data['priority'] = 'URGENT'
        emergency_data['reason'] = 'Chest pain and shortness of breath'

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(emergency_data),
            content_type='application/json',
            **self.tenant_auth
        )

        if response.status_code == status.HTTP_201_CREATED:
            data = response.json()
            assert data['type'] == 'EMERGENCY'
            assert data['priority'] == 'URGENT'

    def test_create_appointment_with_attachments(self):
        """Test appointment creation with attachments."""
        attachment_data = self.appointment_data.copy()
        attachment_data['attachments'] = [
            {
                'type': 'MEDICAL_REPORT',
                'name': 'Blood Test Results.pdf',
                'url': 'https://storage.example.com/blood-test-123.pdf',
                'uploaded_at': '2024-02-10T10:00:00Z'
            },
            {
                'type': 'PRESCRIPTION',
                'name': 'Previous Prescription.jpg',
                'url': 'https://storage.example.com/prescription-456.jpg',
                'uploaded_at': '2024-02-08T14:30:00Z'
            }
        ]

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(attachment_data),
            content_type='application/json',
            **self.tenant_auth
        )

        if response.status_code == status.HTTP_201_CREATED:
            data = response.json()
            assert 'attachments' in data
            assert len(data['attachments']) == 2
            assert data['attachments'][0]['type'] == 'MEDICAL_REPORT'

    def test_create_appointment_insurance_verification(self):
        """Test appointment creation with insurance verification."""
        insurance_data = self.appointment_data.copy()
        insurance_data['insurance'] = {
            'provider': 'Malaysia National Insurance',
            'policy_number': 'MNI-123456789',
            'verification_required': True,
            'pre_authorization_code': 'PA-2024-001'
        }

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(insurance_data),
            content_type='application/json',
            **self.tenant_auth
        )

        if response.status_code == status.HTTP_201_CREATED:
            data = response.json()
            assert 'insurance' in data
            assert data['insurance']['verification_required'] is True

    def test_create_appointment_with_cancellation_policy(self):
        """Test appointment creation with cancellation policy."""
        policy_data = self.appointment_data.copy()
        policy_data['cancellation_policy'] = {
            'can_cancel_until': '2024-02-14T14:30:00+08:00',  # 24 hours before
            'cancellation_fee': 50.00,
            'fee_applies_after': '2024-02-14T14:30:00+08:00'
        }

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(policy_data),
            content_type='application/json',
            **self.tenant_auth
        )

        if response.status_code == status.HTTP_201_CREATED:
            data = response.json()
            assert 'cancellation_policy' in data

    def test_create_appointment_malformed_reminders(self):
        """Test appointment creation with malformed reminders JSON."""
        invalid_data = self.appointment_data.copy()
        invalid_data['reminders'] = 'invalid reminders format'

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(invalid_data),
            content_type='application/json',
            **self.tenant_auth
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST

    def test_create_appointment_tenant_isolation(self):
        """Test that appointment creation respects tenant isolation."""
        response = self.client.post(
            self.appointments_url,
            data=json.dumps(self.appointment_data),
            content_type='application/json',
            **self.tenant_auth
        )

        if response.status_code == status.HTTP_201_CREATED:
            data = response.json()
            # Appointment should be created in the authenticated tenant's context
            assert 'tenant_id' in data
            # This will be validated once implementation exists

    def test_create_appointment_scheduling_validation(self):
        """Test that appointment creation validates business hours and scheduling rules."""
        # Test with off-hours appointment
        off_hours_data = self.appointment_data.copy()
        off_hours_data['appointment_datetime'] = '2024-02-15T22:00:00+08:00'  # 10 PM

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(off_hours_data),
            content_type='application/json',
            **self.tenant_auth
        )

        # This should fail if clinic hours are enforced
        # This will be validated once implementation exists
        if response.status_code == status.HTTP_400_BAD_REQUEST:
            pass  # Expected behavior
        elif response.status_code == status.HTTP_201_CREATED:
            pass  # Also acceptable if 24/7 appointments are allowed

    def test_create_appointment_with_consent(self):
        """Test appointment creation with patient consent."""
        consent_data = self.appointment_data.copy()
        consent_data['consents'] = [
            {
                'type': 'TREATMENT',
                'given_at': '2024-02-10T10:00:00Z',
                'expires_at': None,
                'scope': 'This appointment only'
            },
            {
                'type': 'TELEMEDICINE',
                'given_at': '2024-02-10T10:00:00Z',
                'expires_at': '2024-02-15T16:30:00Z',
                'scope': 'Virtual consultation if needed'
            }
        ]

        response = self.client.post(
            self.appointments_url,
            data=json.dumps(consent_data),
            content_type='application/json',
            **self.tenant_auth
        )

        if response.status_code == status.HTTP_201_CREATED:
            data = response.json()
            assert 'consents' in data
            assert len(data['consents']) == 2