import pytest
from fastapi.testclient import TestClient
from sqlmodel import Session, SQLModel, create_engine
from sqlmodel.pool import StaticPool
from datetime import date, datetime
from main import app
from db import get_session
from app.models.AnnuityInsuranceModel import AnnuityInsuranceModel

# Test database setup
@pytest.fixture(name="session")
def session_fixture():
    engine = create_engine(
        "sqlite:///:memory:",
        connect_args={"check_same_thread": False},
        poolclass=StaticPool,
    )
    SQLModel.metadata.create_all(engine)
    with Session(engine) as session:
        yield session

@pytest.fixture(name="client")
def client_fixture(session: Session):
    def get_session_override():
        return session
    
    app.dependency_overrides[get_session] = get_session_override
    client = TestClient(app)
    yield client
    app.dependency_overrides.clear()

# Test data
@pytest.fixture
def sample_annuity_insurance_data():
    return {
        "first_name": "John",
        "last_name": "Smith",
        "date_of_birth": "1975-05-15",
        "gender": "Male",
        "marital_status": "Married",
        "citizenship_status": "US Citizen",
        "email": "john.smith@email.com",
        "phone_number": "(555) 123-4567",
        "address": "123 Main Street",
        "city": "Los Angeles",
        "state": "CA",
        "zip_code": "90210",
        "annual_income": 85000.0,
        "net_worth": 250000.0,
        "liquid_assets": 50000.0,
        "investment_objective": "Growth",
        "risk_tolerance": "Moderate",
        "initial_investment": 25000.0,
        "payment_frequency": "Single",
        "purchase_type": "Qualified",
        "source_of_funds": "IRA",
        "premium_mode": "Single Premium",
        "payout_start_age": 65,
        "accumulation_period": 10,
        "payout_option": "Life Only",
        "beneficiary_type": "Spouse",
        "death_benefit_option": "Standard",
        "index_strategy": "S&P 500",
        "guaranteed_income_rider": True,
        "enhanced_withdrawal_benefit": False,
        "replacement_existing_annuity": False,
        "existing_annuity_company": None,
        "replacement_value": None,
        "financial_objective_statement": "Retirement planning and income generation",
        "e_sign_consent": True,
        "data_sharing_consent": True,
        "privacy_notice_acknowledged": True
    }

class TestAnnuityInsuranceAPI:
    """Test Annuity Insurance API endpoints"""
    
    def test_create_annuity_insurance_success(self, client: TestClient, sample_annuity_insurance_data):
        """Test successful annuity insurance quote creation"""
        response = client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        assert response.status_code == 200
        
        data = response.json()
        assert data["first_name"] == sample_annuity_insurance_data["first_name"]
        assert data["last_name"] == sample_annuity_insurance_data["last_name"]
        assert data["email"] == sample_annuity_insurance_data["email"]
        assert data["initial_investment"] == sample_annuity_insurance_data["initial_investment"]
        assert data["quote_status"] == "Draft"
        assert "id" in data
        assert "created_at" in data
    
    def test_create_annuity_insurance_invalid_age(self, client: TestClient, sample_annuity_insurance_data):
        """Test annuity insurance creation with invalid age"""
        sample_annuity_insurance_data["date_of_birth"] = "2010-01-01"  # Too young
        response = client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        assert response.status_code == 422
        assert "at least 18 years old" in response.json()["detail"][0]["msg"]
    
    def test_create_annuity_insurance_invalid_investment(self, client: TestClient, sample_annuity_insurance_data):
        """Test annuity insurance creation with invalid investment amount"""
        sample_annuity_insurance_data["initial_investment"] = 1000.0  # Below minimum
        response = client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        assert response.status_code == 422
        assert "2500" in str(response.json()["detail"])
    
    def test_get_annuity_insurance_success(self, client: TestClient, sample_annuity_insurance_data):
        """Test successful retrieval of annuity insurance quote"""
        # Create a quote first
        create_response = client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        quote_id = create_response.json()["id"]
        
        # Retrieve the quote
        response = client.get(f"/api/v1/annuity-insurance/{quote_id}")
        assert response.status_code == 200
        
        data = response.json()
        assert data["id"] == quote_id
        assert data["first_name"] == sample_annuity_insurance_data["first_name"]
        assert data["initial_investment"] == sample_annuity_insurance_data["initial_investment"]
    
    def test_get_annuity_insurance_not_found(self, client: TestClient):
        """Test retrieval of non-existent annuity insurance quote"""
        response = client.get("/api/v1/annuity-insurance/999")
        assert response.status_code == 404
        assert "not found" in response.json()["detail"]
    
    def test_get_all_annuity_insurance_quotes(self, client: TestClient, sample_annuity_insurance_data):
        """Test retrieval of all annuity insurance quotes"""
        # Create multiple quotes
        client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        
        sample_annuity_insurance_data["first_name"] = "Jane"
        sample_annuity_insurance_data["email"] = "jane.smith@email.com"
        client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        
        # Get all quotes
        response = client.get("/api/v1/annuity-insurance/")
        assert response.status_code == 200
        
        data = response.json()
        assert len(data) == 2
        assert all("id" in quote for quote in data)
    
    def test_update_annuity_insurance_success(self, client: TestClient, sample_annuity_insurance_data):
        """Test successful update of annuity insurance quote"""
        # Create a quote first
        create_response = client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        quote_id = create_response.json()["id"]
        
        # Update the quote
        update_data = {
            "initial_investment": 50000.0,
            "payout_start_age": 67,
            "quote_status": "Pending"
        }
        response = client.put(f"/api/v1/annuity-insurance/{quote_id}", json=update_data)
        assert response.status_code == 200
        
        data = response.json()
        assert data["initial_investment"] == 50000.0
        assert data["payout_start_age"] == 67
        assert data["quote_status"] == "Pending"
    
    def test_update_annuity_insurance_not_found(self, client: TestClient):
        """Test update of non-existent annuity insurance quote"""
        update_data = {"initial_investment": 50000.0}
        response = client.put("/api/v1/annuity-insurance/999", json=update_data)
        assert response.status_code == 404
        assert "not found" in response.json()["detail"]
    
    def test_delete_annuity_insurance_success(self, client: TestClient, sample_annuity_insurance_data):
        """Test successful deletion of annuity insurance quote"""
        # Create a quote first
        create_response = client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        quote_id = create_response.json()["id"]
        
        # Delete the quote
        response = client.delete(f"/api/v1/annuity-insurance/{quote_id}")
        assert response.status_code == 200
        assert "deleted successfully" in response.json()["message"]
        
        # Verify it's deleted
        get_response = client.get(f"/api/v1/annuity-insurance/{quote_id}")
        assert get_response.status_code == 404
    
    def test_delete_annuity_insurance_not_found(self, client: TestClient):
        """Test deletion of non-existent annuity insurance quote"""
        response = client.delete("/api/v1/annuity-insurance/999")
        assert response.status_code == 404
        assert "not found" in response.json()["detail"]
    
    def test_search_by_name(self, client: TestClient, sample_annuity_insurance_data):
        """Test search by applicant name"""
        # Create a quote
        client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        
        # Search by name
        response = client.get("/api/v1/annuity-insurance/search/name?first_name=John&last_name=Smith")
        assert response.status_code == 200
        
        data = response.json()
        assert len(data) >= 1
        assert data[0]["first_name"] == "John"
        assert data[0]["last_name"] == "Smith"
    
    def test_search_by_email(self, client: TestClient, sample_annuity_insurance_data):
        """Test search by email address"""
        # Create a quote
        client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        
        # Search by email
        response = client.get("/api/v1/annuity-insurance/search/email/john.smith@email.com")
        assert response.status_code == 200
        
        data = response.json()
        assert len(data) >= 1
        assert data[0]["email"] == "john.smith@email.com"
    
    def test_filter_by_status(self, client: TestClient, sample_annuity_insurance_data):
        """Test filter by quote status"""
        # Create a quote
        client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        
        # Filter by status
        response = client.get("/api/v1/annuity-insurance/filter/status/Draft")
        assert response.status_code == 200
        
        data = response.json()
        assert len(data) >= 1
        assert all(quote["quote_status"] == "Draft" for quote in data)
    
    def test_filter_by_investment_amount(self, client: TestClient, sample_annuity_insurance_data):
        """Test filter by investment amount range"""
        # Create a quote
        client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        
        # Filter by investment amount
        response = client.get("/api/v1/annuity-insurance/filter/investment?min_amount=20000&max_amount=30000")
        assert response.status_code == 200
        
        data = response.json()
        assert len(data) >= 1
        assert all(20000 <= quote["initial_investment"] <= 30000 for quote in data)
    
    def test_filter_by_investment_amount_invalid_range(self, client: TestClient):
        """Test filter by investment amount with invalid range"""
        response = client.get("/api/v1/annuity-insurance/filter/investment?min_amount=30000&max_amount=20000")
        assert response.status_code == 400
        assert "cannot be greater than" in response.json()["detail"]
    
    def test_filter_by_payment_frequency(self, client: TestClient, sample_annuity_insurance_data):
        """Test filter by payment frequency"""
        # Create a quote
        client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        
        # Filter by payment frequency
        response = client.get("/api/v1/annuity-insurance/filter/payment-frequency/Single")
        assert response.status_code == 200
        
        data = response.json()
        assert len(data) >= 1
        assert all(quote["payment_frequency"] == "Single" for quote in data)

class TestAnnuityInsuranceValidation:
    """Test Annuity Insurance data validation"""
    
    def test_required_fields_validation(self, client: TestClient):
        """Test validation of required fields"""
        incomplete_data = {
            "first_name": "John",
            "last_name": "Smith",
            "email": "john@email.com"
            # Missing required fields
        }
        
        response = client.post("/api/v1/annuity-insurance/", json=incomplete_data)
        assert response.status_code == 422
        
        errors = response.json()["detail"]
        required_fields = ["date_of_birth", "gender", "citizenship_status", "phone_number", "address"]
        error_fields = [error["loc"][-1] for error in errors if error["type"] == "missing"]
        
        for field in required_fields:
            assert field in error_fields
    
    def test_email_validation(self, client: TestClient, sample_annuity_insurance_data):
        """Test email format validation"""
        sample_annuity_insurance_data["email"] = "invalid-email"
        
        response = client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        assert response.status_code == 422
        assert "email" in str(response.json()["detail"]).lower()
    
    def test_investment_amount_validation(self, client: TestClient, sample_annuity_insurance_data):
        """Test investment amount validation"""
        sample_annuity_insurance_data["initial_investment"] = 1000.0  # Below minimum
        
        response = client.post("/api/v1/annuity-insurance/", json=sample_annuity_insurance_data)
        assert response.status_code == 422
        assert "2500" in str(response.json()["detail"])

if __name__ == "__main__":
    pytest.main([__file__])