"""
Test Field Comparison Fix

Test that True vs True and numeric values are compared correctly.
"""

from services.mongo import MongoService
from services.json_loader import JSONLoader
from services.diff_engine import DiffEngine
from services.settings_service import SettingsService

def test_field_comparison():
    """Test field-level comparison with normalization."""
    print("=" * 80)
    print("Test Field Comparison Fix")
    print("=" * 80)
    
    settings_service = SettingsService()
    config = settings_service.config
    
    mongo_service = MongoService()
    if not mongo_service.connect():
        print("❌ Failed to connect")
        return False
    
    loader = JSONLoader(
        config['json_sources']['base_path'],
        config['collections']
    )
    
    diff_engine = DiffEngine(config['collections'])
    
    # Load data
    collection_name = 'people'
    source_name = 'ba_glf_2018'
    
    print(f"\nLoading {collection_name} from {source_name}...")
    json_records = loader.load_collection_from_source(collection_name, source_name)
    print(f"Loaded {len(json_records)} JSON records")
    
    collection = mongo_service.get_collection(collection_name)
    db_records = list(collection.find().limit(100))
    print(f"Loaded {len(db_records)} MongoDB records")
    
    # Run comparison
    print("\nRunning comparison...")
    results = diff_engine.compare_collections(
        collection_name,
        json_records,
        db_records
    )
    
    print(f"\nResults:")
    print(f"  Exact matches: {results['summary']['exact_match_count']}")
    print(f"  Duplicates: {results['summary']['duplicate_count']}")
    print(f"  New records: {results['summary']['new_record_count']}")
    
    # Check duplicates for field comparison
    if results['duplicates']:
        print(f"\n✅ Found {len(results['duplicates'])} duplicates")
        
        # Check first duplicate
        dup = results['duplicates'][0]
        comparison = dup.get('comparison', {})
        differences = comparison.get('differences', {})
        
        print(f"\nSample duplicate analysis:")
        print(f"  Total fields: {len(dup['json_record'])}")
        print(f"  Different fields: {len(differences)}")
        print(f"  Matching fields: {len(comparison.get('matching_fields', []))}")
        
        # Look for boolean fields
        json_rec = dup['json_record']
        bool_fields = []
        numeric_fields = []
        
        for field, value in json_rec.items():
            if isinstance(value, bool) or value in ('True', 'False'):
                bool_fields.append(field)
            elif isinstance(value, (int, float)):
                numeric_fields.append(field)
        
        print(f"\n  Boolean fields found: {len(bool_fields)}")
        if bool_fields:
            print(f"    Examples: {bool_fields[:3]}")
        
        print(f"  Numeric fields found: {len(numeric_fields)}")
        if numeric_fields:
            print(f"    Examples: {numeric_fields[:3]}")
        
        # Check if any boolean fields are marked as different
        bool_diffs = [f for f in bool_fields if f in differences]
        if bool_diffs:
            print(f"\n  ⚠️  Boolean fields marked as different: {bool_diffs}")
            for field in bool_diffs[:3]:
                diff = differences[field]
                print(f"    {field}:")
                print(f"      JSON: {diff['json_value']} (type: {type(diff['json_value']).__name__})")
                print(f"      DB:   {diff['db_value']} (type: {type(diff['db_value']).__name__})")
        else:
            print(f"\n  ✅ No boolean fields marked as different (normalization working!)")
        
        # Check numeric fields
        numeric_diffs = [f for f in numeric_fields if f in differences]
        if numeric_diffs:
            print(f"\n  Numeric fields marked as different: {len(numeric_diffs)}")
            for field in numeric_diffs[:3]:
                diff = differences[field]
                print(f"    {field}:")
                print(f"      JSON: {diff['json_value']} (type: {type(diff['json_value']).__name__})")
                print(f"      DB:   {diff['db_value']} (type: {type(diff['db_value']).__name__})")
        
        # Test specific cases
        print(f"\n  Testing specific normalization cases:")
        
        # Test True vs True
        test_cases = [
            (True, True, "bool vs bool"),
            (True, "True", "bool vs string 'True'"),
            ("True", True, "string 'True' vs bool"),
            (1, 1.0, "int vs float"),
            (180, 180.0, "int 180 vs float 180.0"),
        ]
        
        for val1, val2, desc in test_cases:
            norm1 = diff_engine._normalize_value(val1)
            norm2 = diff_engine._normalize_value(val2)
            match = norm1 == norm2
            status = "✅ MATCH" if match else "❌ DIFFERENT"
            print(f"    {status}: {desc}")
            print(f"      {val1} ({type(val1).__name__}) → {norm1} ({type(norm1).__name__})")
            print(f"      {val2} ({type(val2).__name__}) → {norm2} ({type(norm2).__name__})")
    
    print("\n" + "=" * 80)
    return True


if __name__ == "__main__":
    try:
        test_field_comparison()
    except Exception as e:
        print(f"\n❌ Error: {e}")
        import traceback
        traceback.print_exc()