"""用户面 API（神识阁数据源）：BYOK 密钥管理与用量查询。

灵台是神识唯一调用方：本端点鉴权后以 ``X-Hunjing-User-Id`` 代理转发；
密钥明文只进不出（登记请求体 → 神识加密落库，响应永远脱敏）。
"""

from fastapi import APIRouter, Depends, Request, status

from app.api.v1.deps import get_current_user
from app.core.errors import AppError
from app.kernel import Kernel
from app.schemas.auth import CurrentUser
from app.schemas.me import (
    ByokKeyListResponse,
    MyUsageResponse,
    RegisterByokKeyRequest,
)
from app.shenshi_client.client import ShenshiClient
from app.shenshi_client.types import ShenshiError

router = APIRouter(prefix="/me", tags=["me"])


def _shenshi(request: Request) -> ShenshiClient:
    kernel: Kernel | None = getattr(request.app.state, "kernel", None)
    if kernel is None:
        raise AppError("service_unavailable", "Kernel 未就绪。", status_code=503)
    return kernel.shenshi


@router.get("/byok-keys", response_model=ByokKeyListResponse)
async def list_byok_keys(
    request: Request, user: CurrentUser = Depends(get_current_user)
) -> ByokKeyListResponse:
    keys = await _shenshi(request).list_byok_keys(user.owner_scope)
    return ByokKeyListResponse(keys=keys)


@router.post("/byok-keys", status_code=status.HTTP_201_CREATED)
async def register_byok_key(
    payload: RegisterByokKeyRequest,
    request: Request,
    user: CurrentUser = Depends(get_current_user),
) -> dict:
    key = await _shenshi(request).register_byok_key(
        user.owner_scope,
        name=payload.name,
        type=payload.type,
        base_url=payload.base_url,
        api_key=payload.api_key,
        model=payload.model,
    )
    return key


@router.delete("/byok-keys/{key_id}", status_code=status.HTTP_204_NO_CONTENT)
async def revoke_byok_key(
    key_id: str, request: Request, user: CurrentUser = Depends(get_current_user)
) -> None:
    try:
        await _shenshi(request).revoke_byok_key(user.owner_scope, key_id)
    except ShenshiError as exc:
        raise AppError(exc.code, exc.message, status_code=404) from None


@router.get("/usage", response_model=MyUsageResponse)
async def my_usage(
    request: Request, user: CurrentUser = Depends(get_current_user)
) -> MyUsageResponse:
    data = await _shenshi(request).get_my_usage(user.owner_scope)
    return MyUsageResponse(rows=data.get("rows", []), quota=data.get("quota"))