"""
Comprehensive tests for all insurance types with minimal essential coverage
"""
import pytest
import uuid
from datetime import date, timedelta

@pytest.fixture
def sample_data():
    return {
        "commercial_auto": {
            "business_name": "Test Transport Co",
            "contact_name": "John Driver",
            "email_address": f"test_{uuid.uuid4().hex[:8]}@example.com",
            "phone_number": "(555) 123-4567",
            "business_address": "123 Fleet St, City, CA 12345",
            "type_of_business": "Transportation",
            "business_entity_type": "Corporation",
            "years_in_business": 5,
            "annual_revenue": 100000.00,
            "number_of_vehicles": 5,
            "vehicle_list": "[]",
            "vehicle_use_type": "Commercial",
            "radius_of_operation": "Regional",
            "garaging_zip_codes": "12345",
            "vehicles_cross_state_lines": True,
            "driver_list": "[]",
            "drivers_under_25": False,
            "mvr_violations_past_3_years": False,
            "accidents_claims_past_5_years": False,
            "desired_coverage_types": "Liability",
            "desired_coverage_limits": 1000000.00,
            "desired_policy_start_date": (date.today() + timedelta(days=30)).isoformat(),
            "transaction_no": "TX123456"
        },
        "group_health": {
            "company_name": "Test Corp",
            "industry_sic_code": "8999",
            "company_address": "456 Business Ave, City, CA 12345",
            "city": "City",
            "state": "CA",
            "zip_code": "12345",
            "number_of_employees": 50,
            "number_of_employees_to_be_covered": 50,
            "type_of_coverage_requested": "PPO",
            "desired_coverage_start_date": (date.today() + timedelta(days=30)).isoformat(),
            "broker_agent_involved": False,
            "contact_person_name": "HR Manager",
            "contact_email": f"test_{uuid.uuid4().hex[:8]}@example.com",
            "contact_phone": "(555) 234-5678",
            "transaction_no": "TX654321"
        },
        "umbrella": {
            "full_name": "John Umbrella",
            "date_of_birth": "1985-05-15",
            "email_address": f"test_{uuid.uuid4().hex[:8]}@example.com",
            "mobile_phone": "(555) 345-6789",
            "residential_address": "789 Safe St, City, CA 12345",
            "state_of_residence": "CA",
            "home_ownership": "Own",
            "owns_rental_property": False,
            "number_of_vehicles": 2,
            "owns_boat_atv_rv": False,
            "teen_drivers_in_home": False,
            "high_risk_pets": False,
            "liability_claims_last_5_years": False,
            "annual_household_income": 150000.00,
            "total_net_worth": 300000.00,
            "desired_coverage_amount": "2000000.00",
            "preferred_contact_method": "Email"
        }
    }

class TestAllInsuranceTypes:
    """Test all insurance types with basic CRUD operations"""
    
    @pytest.mark.parametrize("insurance_type,endpoint", [
        ("commercial_auto", "/api/v1/commercial-auto/quotes"),
        ("group_health", "/api/v1/group-health/quotes"),
        ("umbrella", "/api/v1/umbrella-insurance/"),
        ("ocean_marine", "/api/v1/ocean-marine/quotes"),
        ("commercial_property", "/api/v1/commercial-property/quotes"),
        ("workers_compensation", "/api/v1/workers-compensation/quotes")
    ])
    def test_insurance_endpoints_exist(self, insurance_type, endpoint):
        """Test that all insurance endpoints are accessible"""
        from main import app
        from fastapi.testclient import TestClient
        client = TestClient(app)
        
        response = client.get(endpoint)
        assert response.status_code == 200
        assert isinstance(response.json(), list)

    def test_commercial_auto_operations(self, sample_data):
        from main import app
        from fastapi.testclient import TestClient
        client = TestClient(app)
        
        data = sample_data["commercial_auto"]
        
        # Create
        response = client.post("/api/v1/commercial-auto/quotes", json=data)
        assert response.status_code == 201
        result = response.json()
        assert result["business_name"] == data["business_name"]
        
        # Read
        policy_id = result["id"]
        get_response = client.get(f"/api/v1/commercial-auto/quotes/{policy_id}")
        assert get_response.status_code == 200
        
        pdf_response = client.get(f"/api/v1/commercial-auto/quotes/{policy_id}/download-pdf")
        assert pdf_response.status_code == 200

    def test_group_health_operations(self, sample_data):
        from main import app
        from fastapi.testclient import TestClient
        client = TestClient(app)
        
        data = sample_data["group_health"]
        
        # Create
        response = client.post("/api/v1/group-health/quotes", json=data)
        assert response.status_code == 201
        result = response.json()
        assert result["company_name"] == data["company_name"]
        
        # Read
        policy_id = result["id"]
        get_response = client.get(f"/api/v1/group-health/quotes/{policy_id}")
        assert get_response.status_code == 200

    def test_umbrella_operations(self, sample_data):
        from main import app
        from fastapi.testclient import TestClient
        client = TestClient(app)
        
        data = sample_data["umbrella"]
        
        # Create
        response = client.post("/api/v1/umbrella-insurance/", json=data)
        assert response.status_code == 200
        result = response.json()
        assert result["full_name"] == data["full_name"]
        
        # Read
        policy_id = result["id"]
        get_response = client.get(f"/api/v1/umbrella-insurance/{policy_id}/download-pdf")
        assert get_response.status_code == 200

class TestValidation:
    """Test input validation across insurance types"""
    
    def test_invalid_email_validation(self):
        from main import app
        from fastapi.testclient import TestClient
        client = TestClient(app)
        
        invalid_data = {
            "full_name": "Test User",
            "email_address": "invalid-email",
            "phone_number": "(555) 123-4567",
            "state": "Illinois",
            "zip_code": "61820",
            "farm_name": "Test Farm",
            "total_acres_owned": 100,
            "farm_type": ["Crop"],
            "perils_to_cover": ["Hail"],
            "preferred_contact_method": "Email"
        }
        
        response = client.post("/api/v1/agriculture-insurance/", json=invalid_data)
        assert response.status_code == 422

    def test_invalid_phone_validation(self):
        from main import app
        from fastapi.testclient import TestClient
        client = TestClient(app)
        
        invalid_data = {
            "business_name": "Test Business",
            "contact_name": "Test Contact",
            "email_address": "test@example.com",
            "phone_number": "invalid-phone",
            "business_address": "123 Test St",
            "type_of_business": "Retail",
            "years_in_business": 5,
            "annual_revenue": 100000,
            "number_of_employees": 10,
            "property_owned_or_leased": "Owned",
            "property_addresses": ["123 Test St"],
            "square_footage": 1000,
            "building_construction_type": "Brick",
            "year_built": 2000,
            "business_personal_property_value": 50000,
            "building_value": 200000,
            "prior_claims_last_5_years": False,
            "desired_coverage_start_date": (date.today() + timedelta(days=30)).isoformat(),
            "desired_property_coverage_limit": 500000,
            "desired_general_liability_coverage_limit": 1000000,
            "security_safety_features": ["Alarm"]
        }
        
        response = client.post("/api/v1/business-owner-policy/", json=invalid_data)
        assert response.status_code == 422