"""Debug hash comparison."""
from services.mongo import MongoService
from services.json_loader import JSONLoader
from services.diff_engine import DiffEngine
from services.settings_service import SettingsService
from services.json_flattener import JSONFlattener

s = SettingsService()
config = s.config

m = MongoService()
m.connect()

loader = JSONLoader(config['json_sources']['base_path'], config['collections'])
diff = DiffEngine(config['collections'])
flattener = JSONFlattener()

# Load one JSON record
json_records = loader.load_collection_from_source('people', 'ba_glf_2018')
json_rec = json_records[0]
json_code = json_rec.get('code')

print(f"JSON record code: {json_code}")
print(f"JSON record keys (non-meta): {len([k for k in json_rec.keys() if not k.startswith('_')])}")

# Find matching DB record
c = m.get_collection('people')

# Check type of code in DB
sample_db = c.find_one({'code': {'$exists': True}})
if sample_db:
    print(f"DB code type: {type(sample_db.get('code')).__name__} = {repr(sample_db.get('code'))}")

print(f"JSON code type: {type(json_code).__name__} = {repr(json_code)}")

# Try both string and int
db_doc = c.find_one({'code': json_code})
print(f"Found by original: {db_doc is not None}")

if not db_doc:
    db_doc = c.find_one({'code': str(json_code)})
    print(f"Found by str: {db_doc is not None}")

if not db_doc:
    try:
        db_doc = c.find_one({'code': int(json_code)})
        print(f"Found by int: {db_doc is not None}")
    except:
        pass

# Check if this code exists at all
all_codes = list(c.find({'code': {'$exists': True}}).limit(5))
print(f"\nSample DB codes: {[d.get('code') for d in all_codes]}")

if db_doc:
    # Flatten DB record
    db_flat = flattener.flatten(db_doc)
    print(f"DB record found!")
    print(f"DB record keys (non-meta): {len([k for k in db_flat.keys() if not k.startswith('_')])}")
    
    # Compute hashes
    json_hash = diff._compute_hash(json_rec)
    db_hash = diff._compute_hash(db_flat)
    
    print(f"\nHash comparison:")
    print(f"  JSON hash: {json_hash[:32]}...")
    print(f"  DB hash:   {db_hash[:32]}...")
    print(f"  Match: {json_hash == db_hash}")
    
    if json_hash != db_hash:
        # Find what's different
        print("\nAnalyzing difference...")
        
        # Get clean records (same logic as _compute_hash)
        excluded_prefixes = ('codes', 'created_at', 'updated_at')
        
        def should_exclude(key):
            if key.startswith('_'):
                return True
            for prefix in excluded_prefixes:
                if key == prefix or key.startswith(prefix + '.'):
                    return True
            return False
        
        json_clean = {k: v for k, v in json_rec.items() if not should_exclude(k)}
        db_clean = {k: v for k, v in db_flat.items() if not should_exclude(k)}
        
        print(f"  JSON clean keys: {len(json_clean)}")
        print(f"  DB clean keys: {len(db_clean)}")
        
        # Find differences
        all_keys = set(json_clean.keys()) | set(db_clean.keys())
        
        only_json = set(json_clean.keys()) - set(db_clean.keys())
        only_db = set(db_clean.keys()) - set(json_clean.keys())
        
        if only_json:
            print(f"\n  Only in JSON: {only_json}")
        if only_db:
            print(f"\n  Only in DB: {only_db}")
        
        # Check value differences
        common = set(json_clean.keys()) & set(db_clean.keys())
        value_diffs = []
        for k in common:
            jv = json_clean[k]
            dv = db_clean[k]
            if jv != dv:
                value_diffs.append((k, jv, dv))
        
        if value_diffs:
            print(f"\n  Value differences ({len(value_diffs)}):")
            for k, jv, dv in value_diffs[:10]:
                print(f"    {k}:")
                print(f"      JSON: {repr(jv)} ({type(jv).__name__})")
                print(f"      DB:   {repr(dv)} ({type(dv).__name__})")
else:
    print(f"DB record not found for code {json_code}")