"""
Configuración de base de datos con soporte multi-tenant
- Base de datos compartida (core_db) para tenants pequeños/medianos
- Bases de datos dedicadas para clientes enterprise
"""

import logging
from contextlib import contextmanager
from typing import AsyncGenerator, Dict, Generator, Optional

from sqlalchemy import create_engine
from sqlalchemy.exc import ProgrammingError
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
from sqlalchemy.orm import Session, declarative_base, sessionmaker

from .config import settings

logger = logging.getLogger(__name__)

# Base declarativa para modelos ORM
Base = declarative_base()

# Engine y SessionLocal para base de datos core (sincrónico)
core_engine = create_engine(
    settings.core_database_url,
    pool_pre_ping=True,
    pool_size=10,
    max_overflow=20,
    echo=False,
)

CoreSessionLocal = sessionmaker(
    autocommit=False, autoflush=False, bind=core_engine)

# Engine asíncrono para operaciones async
async_core_engine = create_async_engine(
    settings.async_core_database_url,
    pool_pre_ping=True,
    pool_size=10,
    max_overflow=20,
    echo=settings.DEBUG,
)

AsyncCoreSessionLocal = async_sessionmaker(
    async_core_engine, class_=AsyncSession, expire_on_commit=False
)

# Cache de engines para tenants con BD dedicada
_tenant_engines: Dict[str, any] = {}


def get_core_db() -> Generator[Session, None, None]:
    """
    Dependency para obtener sesión de base de datos core (compartida)
    Uso en FastAPI: db: Session = Depends(get_core_db)
    """
    db = CoreSessionLocal()
    try:
        yield db
    finally:
        db.close()


async def get_async_core_db() -> AsyncGenerator[AsyncSession, None]:
    """
    Dependency para obtener sesión asíncrona de base de datos core
    """
    async with AsyncCoreSessionLocal() as session:
        try:
            yield session
        finally:
            await session.close()


def get_tenant_engine(tenant_id: int, db_config: dict):
    """
    Obtiene o crea un engine para un tenant con BD dedicada

    Args:
        tenant_id: ID del tenant
        db_config: Configuración de BD {host, port, name, user, password}

    Returns:
        Engine de SQLAlchemy para el tenant
    """
    if tenant_id not in _tenant_engines:
        db_url = f"postgresql://{db_config['user']}:{db_config['password']}@{db_config['host']}:{db_config['port']}/{db_config['name']}"
        _tenant_engines[tenant_id] = create_engine(
            db_url, pool_pre_ping=True, pool_size=5, max_overflow=10
        )
    return _tenant_engines[tenant_id]


@contextmanager
def get_tenant_db(
    tenant_id: int, db_config: Optional[dict] = None
) -> Generator[Session, None, None]:
    """
    Context manager para obtener sesión de BD de un tenant específico

    Si db_config es None, usa la BD core (compartida)
    Si db_config está presente, usa la BD dedicada del tenant

    Uso:
        with get_tenant_db(tenant_id, config) as db:
            # operaciones con db
    """
    if db_config is None:
        # Tenant en BD compartida
        db = CoreSessionLocal()
    else:
        # Tenant con BD dedicada
        engine = get_tenant_engine(tenant_id, db_config)
        SessionLocal = sessionmaker(
            autocommit=False, autoflush=False, bind=engine)
        db = SessionLocal()

    try:
        yield db
    finally:
        db.close()


def init_db():
    """
    Inicializa las tablas de la base de datos core
    """
    try:
        Base.metadata.create_all(bind=core_engine, checkfirst=True)
    except ProgrammingError as e:
        # Si la tabla ya existe, es seguro continuar
        if "already exists" in str(e):
            logger.warning(
                f"Algunas tablas ya existen en la base de datos: {e}")
        else:
            raise


async def init_async_db():
    """
    Inicializa las tablas de la base de datos core (async)
    """
    async with async_core_engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
