"""CRUD de databases de Metabase."""

from .client import MetabaseClient


def metabase_list_databases(
    client: MetabaseClient,
    include_tables: bool = False,
) -> list:
    """Lista las databases configuradas en Metabase.

    Endpoint: GET /api/database.

    Args:
        client: Cliente autenticado.
        include_tables: Si True, incluye las tablas de cada database en la respuesta.

    Returns:
        Lista de dicts, cada uno con campos de la database:
        - id: ID numerico de la database
        - name: Nombre dado en Metabase
        - engine: Motor de BD (sqlite, postgres, mysql, etc.)
        - details: Dict con parametros de conexion
        - is_full_sync: Si sincroniza el schema automaticamente
        - tables: Lista de tablas (solo si include_tables=True)

    Example:
        >>> dbs = metabase_list_databases(client)
        >>> for db in dbs:
        ...     print(db["id"], db["name"], db["engine"])

        >>> dbs = metabase_list_databases(client, include_tables=True)
        >>> for db in dbs:
        ...     print(db["name"], [t["name"] for t in db.get("tables", [])])
    """
    params = {}
    if include_tables:
        params["include"] = "tables"
    result = client.request("GET", "/api/database", params=params)
    if isinstance(result, dict) and "data" in result:
        return result["data"]
    return result


def metabase_add_database(
    client: MetabaseClient,
    name: str,
    engine: str,
    details: dict,
) -> dict:
    """Agrega una nueva database a Metabase.

    Endpoint: POST /api/database. Requiere permisos de superusuario.

    Args:
        client: Cliente autenticado con permisos admin.
        name: Nombre descriptivo para la database en Metabase.
        engine: Motor de base de datos. Ejemplos: "sqlite", "postgres",
            "mysql", "h2", "mongo", "bigquery".
        details: Dict con parametros de conexion especificos del engine.
            Para SQLite: {"db": "/ruta/al/archivo.db"}
            Para Postgres: {"host": "...", "port": 5432, "dbname": "...",
                           "user": "...", "password": "..."}

    Returns:
        Dict con la database creada, incluyendo el campo "id" asignado
        por Metabase y todos los campos de configuracion.

    Raises:
        httpx.HTTPStatusError: 400 si los datos de conexion son invalidos.

    Example:
        >>> db = metabase_add_database(client, "Mi SQLite", "sqlite", {"db": "/data/ops.db"})
        >>> print(db["id"], db["name"])
    """
    body = {
        "name": name,
        "engine": engine,
        "details": details,
    }
    return client.request("POST", "/api/database", json=body)


def metabase_get_database(client: MetabaseClient, database_id: int) -> dict:
    """Obtiene los detalles de una database de Metabase por su ID.

    Endpoint: GET /api/database/:id.

    Args:
        client: Cliente autenticado.
        database_id: ID numerico de la database.

    Returns:
        Dict con campos de la database: id, name, engine, details,
        is_full_sync, is_on_demand, auto_run_queries, created_at,
        updated_at, features, etc.

    Raises:
        httpx.HTTPStatusError: 404 si la database no existe.

    Example:
        >>> db = metabase_get_database(client, 2)
        >>> print(db["name"], db["engine"])
    """
    return client.request("GET", f"/api/database/{database_id}")