import mysql.connector
import os

# Configuración
db_config = {
    "host": "localhost",
    "user": "root",
    "password": "vertrigo"
}

master_db = "educa25_docente"

def get_target_databases():
    targets = []
    try:
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor()
        cursor.execute("SHOW DATABASES LIKE '%educa25%'")
        dbs = [row[0] for row in cursor.fetchall()]
        
        for db in dbs:
            if db != master_db and 'intep' not in db and 'tiendagegar' not in db:
                targets.append(db)
                
        cursor.close()
        conn.close()
    except Exception as e:
        print(f"Error obteniendo bases de datos: {e}")
    return targets

def get_db_schema(db_name):
    schema = {}
    try:
        conn = mysql.connector.connect(**db_config, database=db_name)
        cursor = conn.cursor()
        
        # Obtener tablas
        cursor.execute("SHOW TABLES")
        tables = [t[0] for t in cursor.fetchall()]
        
        for table in tables:
            cursor.execute(f"DESCRIBE `{table}`")
            columns = {c[0]: {"type": c[1], "null": c[2], "key": c[3], "default": c[4], "extra": c[5]} for c in cursor.fetchall()}
            schema[table] = columns
            
        cursor.close()
        conn.close()
    except mysql.connector.Error as err:
        pass # Ignorar errores de BD no accesible por ahora
    return schema

def compare_schemas(master, target_name, target_schema):
    report = {
        "missing_tables": [],
        "extra_tables": [],
        "table_diffs": {}
    }
    
    master_tables = set(master.keys())
    target_tables = set(target_schema.keys())
    
    report["missing_tables"] = list(master_tables - target_tables)
    report["extra_tables"] = list(target_tables - master_tables)
    
    common_tables = master_tables & target_tables
    for table in common_tables:
        master_cols = master[table]
        target_cols = target_schema[table]
        
        master_col_names = set(master_cols.keys())
        target_col_names = set(target_cols.keys())
        
        col_diff = {
            "missing_cols": list(master_col_names - target_col_names),
            "extra_cols": list(target_col_names - master_col_names),
        }
        
        if col_diff["missing_cols"] or col_diff["extra_cols"]:
            report["table_diffs"][table] = col_diff
            
    return report

def main():
    targets_to_compare = get_target_databases()
    
    print(f"--- Iniciando Comparación con Master: {master_db} ---")
    print(f"Se compararán {len(targets_to_compare)} bases de datos.")
    
    master_schema = get_db_schema(master_db)
    if not master_schema:
        print("No se pudo obtener el esquema master.")
        return

    for target in targets_to_compare:
        target_schema = get_db_schema(target)
        if not target_schema:
            continue
            
        diff = compare_schemas(master_schema, target, target_schema)
        
        has_diffs = False
        output_buffer = [f"\n=== Resultados para {target} ==="]
        
        if diff['missing_tables']:
            has_diffs = True
            output_buffer.append(f"  [!] Tablas Faltantes ({len(diff['missing_tables'])}): {', '.join(diff['missing_tables'])}")
            
        if diff['extra_tables']:
            has_diffs = True
            output_buffer.append(f"  [i] Tablas Adicionales ({len(diff['extra_tables'])}): {', '.join(diff['extra_tables'])}")
            
        for table, col_diff in diff['table_diffs'].items():
            if col_diff['missing_cols']:
                has_diffs = True
                output_buffer.append(f"  [!] Tabla `{table}` le FALTAN campos (respecto a master): {', '.join(col_diff['missing_cols'])}")
            
            if col_diff['extra_cols']:
                has_diffs = True
                output_buffer.append(f"  [*] Tabla `{table}` tiene campos ADICIONALES: {', '.join(col_diff['extra_cols'])}")
                
        if has_diffs:
            print("\n".join(output_buffer))
        else:
            print(f"\n=== Resultados para {target} ===")
            print("  [OK] Idéntica a la master (tablas y campos).")

if __name__ == "__main__":
    main()