#!/usr/bin/env python
"""
Focused test script that tests the most important functionality
without getting caught up in serialization format complexities
"""

import sys
from datetime import datetime
from models import (
    UserStatus, UserType, SkillLevel, EmploymentType,
    Candidate, Employer, Location, Skill
)


def test_model_creation():
    """Test that we can create models successfully"""
    print("🧪 Testing model creation...")
    
    # Create supporting objects
    location = Location(city="Austin", country="USA")
    skill = Skill(name="Python", category="Programming", level=SkillLevel.ADVANCED)
    
    # Create candidate
    candidate = Candidate(
        email="test@example.com",
        user_type=UserType.CANDIDATE,
        username="test_candidate",
        created_at=datetime.now(),
        updated_at=datetime.now(),
        status=UserStatus.ACTIVE,
        first_name="John",
        last_name="Doe",
        full_name="John Doe",
        skills=[skill],
        experience=[],
        education=[],
        preferred_job_types=[EmploymentType.FULL_TIME],
        location=location,
        languages=[],
        certifications=[]
    )
    
    # Create employer
    employer = Employer(
        user_type=UserType.EMPLOYER,
        first_name="Mary",
        last_name="Smith",
        full_name="Mary Smith",
        email="hr@company.com",
        created_at=datetime.now(),
        updated_at=datetime.now(),
        status=UserStatus.ACTIVE,
        company_name="Test Company",
        industry="Technology",
        company_size="50-200",
        company_description="A test company",
        location=location
    )
    
    print(f"✅ Candidate: {candidate.first_name} {candidate.last_name}")
    print(f"✅ Employer: {employer.company_name}")
    print(f"✅ User types: {candidate.user_type}, {employer.user_type}")
    
    return candidate, employer

def test_json_api_format():
    """Test JSON serialization in API format (the most important use case)"""
    print("\n📡 Testing JSON API format...")
    
    candidate, employer = test_model_creation()
    
    # Serialize to JSON (API format)
    candidate_json = candidate.model_dump_json(by_alias=True)
    employer_json = employer.model_dump_json(by_alias=True)
    
    print(f"✅ Candidate JSON: {len(candidate_json)} chars")
    print(f"✅ Employer JSON: {len(employer_json)} chars")
    
    # Deserialize from JSON
    candidate_back = Candidate.model_validate_json(candidate_json)
    employer_back = Employer.model_validate_json(employer_json)
    
    # Verify data integrity
    assert candidate_back.email == candidate.email
    assert candidate_back.first_name == candidate.first_name
    assert employer_back.company_name == employer.company_name
    
    print("✅ JSON round-trip successful")
    print("✅ Data integrity verified")
    
    return True

def test_api_dict_format():
    """Test dictionary format with aliases (for API requests/responses)"""
    print("\n📊 Testing API dictionary format...")
    
    candidate, employer = test_model_creation()
    
    # Create API format dictionaries
    candidate_dict = candidate.model_dump(by_alias=True)
    employer_dict = employer.model_dump(by_alias=True)
    
    # Verify camelCase aliases are used
    assert "firstName" in candidate_dict
    assert "lastName" in candidate_dict
    assert "createdAt" in candidate_dict
    assert "companyName" in employer_dict
    
    print("✅ API format dictionaries created")
    print("✅ CamelCase aliases verified")
    
    # Test deserializing from API format
    candidate_back = Candidate.model_validate(candidate_dict)
    employer_back = Employer.model_validate(employer_dict)
    
    assert candidate_back.email == candidate.email
    assert employer_back.company_name == employer.company_name
    
    print("✅ API format round-trip successful")
    
    return True

def test_validation_constraints():
    """Test that validation constraints work"""
    print("\n🔒 Testing validation constraints...")

    try:
        # Create a candidate with invalid email
        Candidate(
            user_type=UserType.CANDIDATE,
            email="invalid-email",
            username="test_invalid",
            created_at=datetime.now(),
            updated_at=datetime.now(),
            status=UserStatus.ACTIVE,
            first_name="Jane",
            last_name="Doe",
            full_name="Jane Doe"
        )
        print("❌ Validation should have failed but didn't")
        return False
    except ValueError as e:
        print(f"✅ Validation error caught: {e}")    
    return True

def test_enum_values():
    """Test that enum values work correctly"""
    print("\n📋 Testing enum values...")
    
    # Test that enum values are properly handled
    candidate, employer = test_model_creation()
    
    # Check enum values in serialization
    candidate_dict = candidate.model_dump(by_alias=True)
    
    assert candidate_dict["status"] == "active"
    assert candidate_dict["userType"] == "candidate"
    assert employer.user_type == UserType.EMPLOYER
    
    print("✅ Enum values correctly serialized")
    print(f"✅ User types: candidate={candidate.user_type}, employer={employer.user_type}")
    
    return True

def main():
    """Run all focused tests"""
    print("🎯 Focused Pydantic Model Tests")
    print("=" * 40)
    
    try:
        test_model_creation()
        test_json_api_format()
        test_api_dict_format() 
        test_validation_constraints()
        test_enum_values()
        
        print("\n🎉 All focused tests passed!")
        print("=" * 40)
        print("✅ Models work correctly")
        print("✅ JSON API format works")
        print("✅ Validation constraints work")
        print("✅ Enum values work")
        print("✅ Ready for type generation!")
        
        return True
        
    except Exception as e:
        print(f"\n❌ Test failed: {type(e).__name__}: {e}")
        import traceback
        traceback.print_exc()
        print(f"\n❌ {traceback.format_exc()}")
        return False

if __name__ == "__main__":
    success = main()
    sys.exit(0 if success else 1)