AlphaPulse/backend/src/alphapulse/api/settings.py

"""环境变量页：模型接入配置、交易所模拟盘 key。密钥只写不读，接口只返回末 4 位"""

import time
from datetime import datetime
from decimal import Decimal
from typing import Annotated, Literal

from fastapi import APIRouter, Depends, HTTPException, status
from pydantic import BaseModel, Field, HttpUrl, StringConstraints, model_validator
from sqlalchemy import func, select, update
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession

from alphapulse.ai import llm
from alphapulse.core.auth import require_admin
from alphapulse.core.crypto import encrypt
from alphapulse.core.db import get_session
from alphapulse.core.redis import redis
from alphapulse.models import AiProvider, TradingAccount, TradingAnalysis, TradingCredential, TradingSymbol
from alphapulse.trading.client import ExchangeError, create_client
from alphapulse.trading.snapshot import STATUS_KEY

router = APIRouter(prefix="/api/settings", tags=["settings"], dependencies=[Depends(require_admin)])

Protocol = Literal["openai", "anthropic"]
# 从页面粘贴时容易带上首尾空格，模型名带空格会被上游当成另一个模型（404）
Name = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=64)]
Model = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=128)]
ApiCredential = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=128)]


class ProviderOut(BaseModel):
    id: int
    name: str
    protocol: Protocol
    base_url: str
    api_key_hint: str
    model: str
    max_tokens: int
    context_window: int
    reasoning_effort: llm.Effort | None
    is_default: bool
    updated_at: datetime


class ProviderIn(BaseModel):
    name: Name
    protocol: Protocol
    base_url: HttpUrl
    api_key: Annotated[str, Field(min_length=1)]
    model: Model
    max_tokens: Annotated[int, Field(ge=256, le=128000)] = 8192
    context_window: Annotated[int, Field(ge=4096, le=2000000)] = 200000
    reasoning_effort: llm.Effort | None = None
    is_default: bool = False


class ProviderPatch(BaseModel):
    name: Name | None = None
    protocol: Protocol | None = None
    base_url: HttpUrl | None = None
    # 为空表示不修改
    api_key: str | None = None
    model: Model | None = None
    max_tokens: Annotated[int | None, Field(ge=256, le=128000)] = None
    context_window: Annotated[int | None, Field(ge=4096, le=2000000)] = None
    # 显式传 null 表示不传思考强度
    reasoning_effort: llm.Effort | None = None
    is_default: bool | None = None


class TestResult(BaseModel):
    ok: bool
    elapsed_ms: int
    reply: str | None = None
    error: str | None = None


def key_fields(api_key: str) -> dict:
    api_key = api_key.strip()
    return {"api_key_encrypted": encrypt(api_key), "api_key_hint": api_key[-4:]}


async def get_provider(session: AsyncSession, provider_id: int) -> AiProvider:
    provider = await session.get(AiProvider, provider_id)
    if provider is None:
        raise HTTPException(status.HTTP_404_NOT_FOUND, "模型配置不存在")
    return provider


async def commit_unique(session: AsyncSession) -> None:
    try:
        await session.commit()
    except IntegrityError:
        raise HTTPException(status.HTTP_409_CONFLICT, "名称已存在") from None


@router.get("/providers")
async def list_providers(session: Annotated[AsyncSession, Depends(get_session)]) -> list[ProviderOut]:
    rows = await session.scalars(select(AiProvider).order_by(AiProvider.id))
    return [ProviderOut.model_validate(p, from_attributes=True) for p in rows]


@router.post("/providers", status_code=status.HTTP_201_CREATED)
async def create_provider(body: ProviderIn, session: Annotated[AsyncSession, Depends(get_session)]) -> ProviderOut:
    # 第一套配置自动成为默认
    is_default = body.is_default or await session.scalar(select(AiProvider.id).limit(1)) is None
    if is_default:
        await session.execute(update(AiProvider).values(is_default=False))
    provider = AiProvider(
        **body.model_dump(exclude={"api_key", "base_url", "is_default"}),
        base_url=str(body.base_url), is_default=is_default, **key_fields(body.api_key),
    )
    session.add(provider)
    await commit_unique(session)
    return ProviderOut.model_validate(provider, from_attributes=True)


@router.patch("/providers/{provider_id}")
async def patch_provider(provider_id: int, body: ProviderPatch, session: Annotated[AsyncSession, Depends(get_session)]) -> ProviderOut:
    provider = await get_provider(session, provider_id)
    values = body.model_dump(exclude_unset=True, exclude={"api_key", "base_url", "is_default"})
    # reasoning_effort 显式传 null 表示清除，其他字段为 null 时忽略
    for field, value in values.items():
        if value is not None or field == "reasoning_effort":
            setattr(provider, field, value)
    if body.base_url is not None:
        provider.base_url = str(body.base_url)
    if body.api_key and body.api_key.strip():
        for field, value in key_fields(body.api_key).items():
            setattr(provider, field, value)
    if body.is_default:
        await session.execute(update(AiProvider).where(AiProvider.id != provider_id).values(is_default=False))
        provider.is_default = True
    await commit_unique(session)
    await session.refresh(provider)
    return ProviderOut.model_validate(provider, from_attributes=True)


@router.delete("/providers/{provider_id}")
async def delete_provider(provider_id: int, session: Annotated[AsyncSession, Depends(get_session)]) -> None:
    provider = await get_provider(session, provider_id)
    await session.delete(provider)
    await session.flush()
    if provider.is_default:
        # 删掉默认配置后，让最早的一套成为默认，避免 Chat 没有可用配置
        first = await session.scalar(select(AiProvider).order_by(AiProvider.id).limit(1))
        if first:
            first.is_default = True
    await session.commit()


@router.post("/providers/{provider_id}/test")
async def test_provider(provider_id: int, session: Annotated[AsyncSession, Depends(get_session)]) -> TestResult:
    provider = await get_provider(session, provider_id)
    started = time.monotonic()
    try:
        completion = None
        async for event in llm.stream(provider, "只回复 OK。", [{"role": "user", "text": "ping"}], [], provider.reasoning_effort):
            if isinstance(event, llm.Completion):
                completion = event
    except llm.LlmError as e:
        return TestResult(ok=False, elapsed_ms=round((time.monotonic() - started) * 1000), error=str(e))
    return TestResult(ok=True, elapsed_ms=round((time.monotonic() - started) * 1000), reply=completion.text[:200])


# ---------- 模拟盘 ----------

ExchangeName = Literal["binance", "bybit"]


class ExchangeOut(BaseModel):
    exchange: ExchangeName
    configured_exchanges: list[ExchangeName]
    configured: bool
    api_key_hint: str | None
    running: bool
    updated_at: datetime | None


class ExchangeIn(BaseModel):
    # key 和 secret 成对生效，修改时两个都要填
    exchange: ExchangeName | None = None
    api_key: ApiCredential | None = None
    api_secret: ApiCredential | None = None

    @model_validator(mode="after")
    def paired_credentials(self):
        if (self.api_key is None) != (self.api_secret is None):
            raise ValueError("API Key 和 Secret Key 必须同时填写")
        if self.exchange is None and self.api_key is None:
            raise ValueError("请选择交易所或填写凭证")
        return self


class ExchangeTestResult(BaseModel):
    ok: bool
    elapsed_ms: int
    available_usdt: str | None = None
    wallet_usdt: str | None = None
    # 双向持仓模式；引擎使用单向持仓，启动时会切换
    dual_side_position: bool | None = None
    error: str | None = None


async def any_running(session: AsyncSession) -> bool:
    return bool(await session.scalar(select(func.count()).where(TradingSymbol.running)))


async def exchange_out(session: AsyncSession, account: TradingAccount | None) -> ExchangeOut:
    exchange = account.exchange if account else "binance"
    credential = await session.get(TradingCredential, exchange)
    configured = list(await session.scalars(select(TradingCredential.exchange).where(TradingCredential.api_key_encrypted.is_not(None))))
    return ExchangeOut(
        exchange=exchange, configured_exchanges=configured,
        configured=bool(credential and credential.api_key_encrypted), api_key_hint=credential.api_key_hint if credential else None,
        running=await any_running(session), updated_at=credential.updated_at if credential else None,
    )


async def editable_account(session: AsyncSession) -> TradingAccount:
    account = await session.get(TradingAccount, 1)
    if await any_running(session):
        raise HTTPException(status.HTTP_409_CONFLICT, "有币种正在交易，请先全部停止再修改交易所或 key")
    if await session.scalar(select(func.count()).where(TradingAnalysis.status == "running")):
        raise HTTPException(status.HTTP_409_CONFLICT, "有分析正在进行，请等待完成后再修改交易所或 key")
    return account or TradingAccount(id=1, exchange="binance")


async def ensure_no_positions(session: AsyncSession, exchange: str) -> None:
    credential = await session.get(TradingCredential, exchange)
    if credential and credential.api_key_encrypted:
        try:
            async with create_client(credential) as client:
                positions = await client.positions()
        except ExchangeError as e:
            raise HTTPException(status.HTTP_502_BAD_GATEWAY, f"无法确认当前交易所持仓，请稍后再试：{e}") from None
        if any(Decimal(p["positionAmt"]) != 0 for p in positions):
            raise HTTPException(status.HTTP_409_CONFLICT, "当前模拟账户仍有持仓，请先平仓再切换交易所或修改 key")


@router.get("/exchange")
async def get_exchange(session: Annotated[AsyncSession, Depends(get_session)]) -> ExchangeOut:
    return await exchange_out(session, await session.get(TradingAccount, 1))


@router.put("/exchange")
async def put_exchange(body: ExchangeIn, session: Annotated[AsyncSession, Depends(get_session)]) -> ExchangeOut:
    account = await editable_account(session)
    await ensure_no_positions(session, account.exchange)
    exchange = body.exchange or account.exchange
    credential = None
    if body.api_key is not None:
        credential = await session.get(TradingCredential, exchange) or TradingCredential(exchange=exchange)
        credential.api_key_encrypted = encrypt(body.api_key)
        credential.api_secret_encrypted = encrypt(body.api_secret)
        credential.api_key_hint = body.api_key[-4:]
        session.add(credential)
    account.exchange = exchange
    session.add(account)
    # 停止状态下仍可能排有手动分析；切换后不能把旧请求交给另一家交易所。
    await session.execute(update(TradingSymbol).values(analysis_requested_at=None, analysis_reasons=[]))
    await session.commit()
    if credential is not None:
        await session.refresh(credential)
    await redis.delete(STATUS_KEY)
    return await exchange_out(session, account)


@router.delete("/exchange")
async def delete_exchange(session: Annotated[AsyncSession, Depends(get_session)]) -> ExchangeOut:
    account = await editable_account(session)
    await ensure_no_positions(session, account.exchange)
    credential = await session.get(TradingCredential, account.exchange)
    if credential:
        credential.api_key_encrypted = credential.api_secret_encrypted = credential.api_key_hint = None
    await session.commit()
    if credential is not None:
        await session.refresh(credential)
    await redis.delete(STATUS_KEY)
    return await exchange_out(session, account)


@router.post("/exchange/test")
async def test_exchange(session: Annotated[AsyncSession, Depends(get_session)]) -> ExchangeTestResult:
    account = await session.get(TradingAccount, 1)
    credential = await session.get(TradingCredential, account.exchange) if account else None
    if credential is None or credential.api_key_encrypted is None:
        raise HTTPException(status.HTTP_400_BAD_REQUEST, "还没有填写当前交易所的模拟盘 key")
    started = time.monotonic()
    try:
        async with create_client(credential) as client:
            info = await client.account()
            dual = await client.position_mode()
    except ExchangeError as e:
        hint = "（请在所选交易所的模拟交易账户创建 key，确认合约权限及 IP 白名单；Bybit Testnet 和实盘 key 均不可用）" if e.code in (-2015, 10003, 10005, 10010) else ""
        return ExchangeTestResult(ok=False, elapsed_ms=round((time.monotonic() - started) * 1000), error=f"{e}{hint}")
    return ExchangeTestResult(
        ok=True, elapsed_ms=round((time.monotonic() - started) * 1000),
        available_usdt=info["availableBalance"], wallet_usdt=info["totalWalletBalance"], dual_side_position=dual,
    )