# coding=utf-8
"""
@Time   :2026/6/24
@Author :tao.chen
"""
from common.logging import logger
from spark_executor.core.connection_store import ConnectionStore, store
from spark_executor.models import Connection


def save_connection(
    *,
    name: str,
    master: str,
    deploy_mode: str = "cluster",
    yarn_rm_url: str | None = None,
    spark_conf: dict[str, str] | None = None,
    ssl_verify: bool | None = None,
    ssl_ca_bundle: str | None = None,
    auth_type: str = "none",
    auth_user: str | None = None,
   auth_password: str | None = None,
   auth_principal: str | None = None,
   auth_keytab: str | None = None,
    url_allowlist: list[str] | None = None,
) -> dict[str, str]:
    logger.debug(
        f"save_connection enter name={name} master={master} deploy_mode={deploy_mode} "
        f"yarn_rm_url={yarn_rm_url} spark_conf_keys={list((spark_conf or {}).keys())}"
    )
    conn = Connection(
        name=name,
        master=master,
        deploy_mode=deploy_mode,
        yarn_rm_url=yarn_rm_url,
        spark_conf=spark_conf or {},
        ssl_verify=ssl_verify,
        ssl_ca_bundle=ssl_ca_bundle,
        auth_type=auth_type,
        auth_user=auth_user,
        auth_password=auth_password,
       auth_principal=auth_principal,
       auth_keytab=auth_keytab,
        url_allowlist=url_allowlist or [],
   )
    store.save(conn)
    return {"name": name, "status": "SAVED"}


def update_connection(name: str, **fields) -> dict[str, object]:
    """Update an existing Connection's mutable fields.

    `name` is the identifier (immutable). PATCH semantics: only the fields
    you pass are changed. To clear an optional field (e.g. `yarn_rm_url`),
    use `delete_connection(name=...)` followed by `save_connection(...)`.

   Mutable fields: master, deploy_mode, yarn_rm_url, spark_conf,
   ssl_verify, ssl_ca_bundle, auth_type, auth_user, auth_password,
    auth_principal, auth_keytab, url_allowlist.
    """
    logger.debug(f"update_connection enter name={name} fields={sorted(fields.keys())}")
    return store.update(name, **fields).model_dump()


def list_connections() -> list[dict[str, object]]:
    logger.debug("list_connections enter")
    return [c.model_dump() for c in store.list_all()]


def get_connection(name: str) -> dict[str, object]:
    logger.debug(f"get_connection enter name={name}")
    conn = store.get(name)
    if conn is None:
        raise KeyError(f"Unknown connection: {name}")
    return conn.model_dump()


def delete_connection(name: str) -> dict[str, str]:
    logger.debug(f"delete_connection enter name={name}")
    removed = store.delete(name)
    if not removed:
        raise KeyError(f"Unknown connection: {name}")
    return {"name": name, "status": "DELETED"}