# /opt/docker/dev/service_finder/backend/app/tests_internal/diagnostics/compare_schema.py
import asyncio
import sys
import os
from sqlalchemy.ext.asyncio import create_async_engine
from sqlalchemy import inspect
from app.database import Base
from app.core.config import settings

# Biztosítjuk az importálást
try:
    import app.models 
except ImportError as e:
    print(f"❌ KRITIKUS IMPORT HIBA: {e}")
    sys.exit(1)

async def compare():
    """ Teljes körű diagnosztika az összes DDD domain sémára. """
    print(f"🔗 Kapcsolódás az adatbázishoz...")
    engine = create_async_engine(str(settings.SQLALCHEMY_DATABASE_URI))
    
    def get_diff(connection):
        inspector = inspect(connection)
        
        # 1. Dinamikusan kigyűjtjük az összes sémát, amit a modellekben definiáltunk
        expected_schemas = sorted({t.schema for t in Base.metadata.sorted_tables if t.schema})
        all_db_schemas = inspector.get_schema_names()
        
        print(f"📋 Ellenőrizendő domainek: {', '.join(expected_schemas)}")
        
        mismatches = 0
        
        for sc in expected_schemas:
            if sc not in all_db_schemas:
                print(f"\n❌ KRITIKUS HIBA: A(z) '{sc}' séma fizikailag HIÁNYZIK az adatbázisból!")
                mismatches += 1
                continue

            db_tables = inspector.get_table_names(schema=sc)
            # Begyűjtjük a modelleket, amik ehhez a sémához tartoznak
            model_tables = [t.name for t in Base.metadata.sorted_tables if t.schema == sc]
            
            print(f"\n--- 🔍 DIAGNOSZTIKA: '{sc}' séma ({len(db_tables)} tábla a DB-ben) ---")
            
            for mt in model_tables:
                if mt not in db_tables:
                    print(f"❌ HIÁNYZÓ TÁBLA: {sc}.{mt}")
                    mismatches += 1
                else:
                    # Oszlopok ellenőrzése
                    db_cols = {c['name']: c for c in inspector.get_columns(mt, schema=sc)}
                    
                    # SQLAlchemy metadata kulcs keresése (séma.tábla formátum)
                    table_key = f"{sc}.{mt}"
                    if table_key not in Base.metadata.tables:
                        # Fallback ha nincs séma előtag a kulcsban (ritka)
                        table_key = mt
                        
                    model_cols = Base.metadata.tables[table_key].columns
                    
                    missing_cols = [m.name for m in model_cols if m.name not in db_cols]
                    if missing_cols:
                        print(f"⚠️  {mt:30} | HIÁNYZÓ OSZLOPOK: {missing_cols}")
                        mismatches += 1
                    else:
                        print(f"✅ {mt:30} | Rendben.")
                        
        return mismatches

    try:
        async with engine.connect() as conn:
            err_count = await conn.run_sync(get_diff)
            if err_count == 0:
                print(f"\n✨ GRATULÁLOK! Az adatbázis és a modellek 100%-ban szinkronban vannak. ✨")
            else:
                print(f"\n--- ⚠️ Összegzés: {err_count} eltérés található. ---\n")
    except Exception as e:
        print(f"❌ HIBA: {e}")
        import traceback
        traceback.print_exc()
    finally:
        await engine.dispose()

if __name__ == "__main__":
    asyncio.run(compare())

    # docker compose exec api python -m app.tests_internal.diagnostics.compare_schema