ForcePilot/backend/server/routers/channels_router.py

from __future__ import annotations

import csv
import codecs
import json
import re
from datetime import datetime
from io import StringIO
from typing import Any, Literal

from fastapi import APIRouter, Body, Depends, HTTPException, Path, Query, status
from fastapi.responses import StreamingResponse
from pydantic import BaseModel, Field
from sqlalchemy import asc, desc, func, select
from sqlalchemy.exc import DBAPIError, IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from starlette.responses import JSONResponse

from yuxi.channels.manager import get_channel_manager
from yuxi.channels.services.plugin_state_store import PluginStateStore, PostgresPluginStateStore
from yuxi.channels.exceptions import (
    ChannelAuthenticationError,
    ChannelException,
    ChannelNotConnectedError,
    ChannelRateLimitError,
    ChannelTimeoutError,
)
from yuxi.storage.postgres.models_business import User
from yuxi.storage.postgres.models_channels import (
    ChannelMsgRecord,
    ChannelPolicyConfig,
    ChannelThreadMapping,
    ChannelUserMapping,
)
from yuxi.utils.logging_config import logger

from server.utils.auth_middleware import get_admin_user, get_db

channels = APIRouter(prefix="/channels", tags=["channels"])


def _make_response(data: Any = None, code: int = 0, message: str = "ok") -> dict:
    return {"code": code, "data": data, "message": message}


class UpdateStateEntryBody(BaseModel):
    value: Any = Field(..., description="状态值（必填）")
    ttl_seconds: int | None = Field(None, gt=0, description="过期时间（秒），必须为正整数")


async def _check_rate_limit(user_id: str, key: str, max_req: int, window: int) -> None:
    rate_key = f"{key}:{user_id}"
    allowed = await get_channel_manager().check_rate_limit(rate_key, max_req, window)
    if not allowed:
        raise HTTPException(
            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
            detail="请求频率超限，请稍后再试",
        )


async def _handle_channel_operation_exceptions(channel_id: str, operation):
    try:
        return await operation
    except ChannelAuthenticationError as e:
        raise HTTPException(status_code=401, detail=f"凭证无效: {e}")
    except ChannelNotConnectedError as e:
        raise HTTPException(status_code=503, detail=f"渠道不可达: {e}")
    except ChannelTimeoutError as e:
        raise HTTPException(status_code=504, detail=f"连接超时: {e}")
    except ChannelRateLimitError as e:
        raise HTTPException(status_code=429, detail=f"上游限流: {e}")
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        logger.error(f"Failed to execute channel operation for {channel_id}: {e}")
        raise HTTPException(status_code=500, detail=f"Failed to execute channel operation: {e}")


_POLICY_FIELDS = [
    "group_chat_mode",
    "whitelist_ids",
    "welcome_message",
    "work_hours_start",
    "work_hours_end",
    "timezone_offset",
    "off_hours_reply",
]

_POLICY_DEFAULTS = {
    "group_chat_mode": "mention_only",
    "whitelist_ids": [],
    "welcome_message": "",
    "work_hours_start": "09:00",
    "work_hours_end": "18:00",
    "timezone_offset": 8,
    "off_hours_reply": "",
}


class ChannelPolicyUpdate(BaseModel):
    group_chat_mode: Literal["mention_only", "all", "whitelist", "blacklist"] | None = None
    whitelist_ids: list[str] | None = None
    welcome_message: str | None = Field(None, max_length=500)
    work_hours_start: str | None = Field(None, pattern=r"^\d{2}:\d{2}$")
    work_hours_end: str | None = Field(None, pattern=r"^\d{2}:\d{2}$")
    timezone_offset: int | None = Field(None, ge=-12, le=14)
    off_hours_reply: str | None = Field(None, max_length=500)


def _get_adapter(channel_id: str):
    adapter = get_channel_manager()._adapters.get(channel_id)
    if adapter is None:
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' not found or not running")
    return adapter


async def _check_channel_rate_limit(channel_id: str, user_id: str, action: str = "message") -> None:
    result = await get_channel_manager().check_per_channel_rate_limit(channel_id, user_id, action)
    if not result.allowed:
        raise HTTPException(
            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
            detail=f"请求频率超限，请在 {result.retry_after_seconds} 秒后重试",
        )


VALID_MESSAGE_STATUSES = frozenset({"processing", "success", "error", "timeout"})
VALID_CONTENT_TYPES = frozenset({"text", "image", "file", "voice", "video", "location", "event"})
MIN_SEARCH_LENGTH = 2
MAX_SEARCH_LENGTH = 100

SORTABLE_FIELDS = frozenset({"created_at", "response_time_ms", "id"})


def _escape_like(value: str) -> str:
    return value.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")


def _build_message_conditions(
    channel_id: str,
    status_value: str | None = None,
    content_type: str | None = None,
    date_from: str | None = None,
    date_to: str | None = None,
    search: str | None = None,
) -> list:
    conditions = [ChannelMsgRecord.channel_id == channel_id]

    if status_value:
        if status_value not in VALID_MESSAGE_STATUSES:
            raise HTTPException(
                status_code=400,
                detail=f"无效的 status 值: '{status_value}'，可选: {', '.join(sorted(VALID_MESSAGE_STATUSES))}",
            )
        conditions.append(ChannelMsgRecord.status == status_value)

    if content_type:
        if content_type not in VALID_CONTENT_TYPES:
            raise HTTPException(
                status_code=400,
                detail=f"无效的 content_type 值: '{content_type}'，可选: {', '.join(sorted(VALID_CONTENT_TYPES))}",
            )
        conditions.append(ChannelMsgRecord.content_type == content_type)

    dt_from = None
    dt_to = None

    if date_from:
        try:
            dt_from = datetime.strptime(date_from, "%Y-%m-%d")
            conditions.append(ChannelMsgRecord.created_at >= dt_from)
        except ValueError:
            raise HTTPException(
                status_code=400,
                detail=f"日期格式无效: '{date_from}'，正确格式: YYYY-MM-DD",
            )

    if date_to:
        try:
            dt_to = datetime.strptime(date_to, "%Y-%m-%d")
            conditions.append(ChannelMsgRecord.created_at < dt_to)
        except ValueError:
            raise HTTPException(
                status_code=400,
                detail=f"日期格式无效: '{date_to}'，正确格式: YYYY-MM-DD",
            )

    if dt_from is not None and dt_to is not None:
        if dt_from >= dt_to:
            raise HTTPException(
                status_code=400,
                detail=f"date_from ({date_from}) 必须早于 date_to ({date_to})",
            )

    if search:
        search = search.strip()
        if len(search) < MIN_SEARCH_LENGTH:
            raise HTTPException(
                status_code=400,
                detail=f"搜索关键词至少 {MIN_SEARCH_LENGTH} 个字符",
            )
        if len(search) > MAX_SEARCH_LENGTH:
            raise HTTPException(
                status_code=400,
                detail=f"搜索关键词最多 {MAX_SEARCH_LENGTH} 个字符",
            )
        escaped = _escape_like(search)
        conditions.append(ChannelMsgRecord.content_preview.ilike(f"%{escaped}%", escape="\\"))

    return conditions


_CSV_RISKY_PREFIXES = frozenset(("=", "+", "-", "@"))

_CSV_HEADER = [
    "id",
    "channel_type",
    "message_id",
    "chat_id",
    "chat_type",
    "content_type",
    "sender_user_id",
    "content_preview",
    "reply_to_message_id",
    "agent_config_id",
    "status",
    "error_message",
    "response_time_ms",
    "reply_message_id",
    "reply_content_preview",
    "created_at",
    "replied_at",
    "extra_metadata",
]


def _sanitize_csv_cell(value: str | None) -> str:
    if not value:
        return ""
    if value[0] in _CSV_RISKY_PREFIXES:
        return f"'{value}"
    return value


class _UTF8SigEncoder:
    def __init__(self, generator):
        self._gen = generator
        self._sent_bom = False

    def __iter__(self):
        return self

    def __next__(self):
        if not self._sent_bom:
            self._sent_bom = True
            return codecs.BOM_UTF8
        return next(self._gen)


def _csv_line_generator(rows):
    output = StringIO()
    writer = csv.writer(output)

    writer.writerow(_CSV_HEADER)
    yield output.getvalue()
    output.truncate(0)
    output.seek(0)

    for r in rows:
        writer.writerow(
            [
                r.id,
                r.channel_type or "",
                r.message_id or "",
                r.chat_id,
                r.chat_type,
                r.content_type,
                _sanitize_csv_cell(r.sender_user_id),
                _sanitize_csv_cell(r.content_preview),
                r.reply_to_message_id or "",
                r.agent_config_id or "",
                r.status,
                _sanitize_csv_cell(r.error_message),
                r.response_time_ms or "",
                r.reply_message_id or "",
                _sanitize_csv_cell(r.reply_content_preview),
                r.created_at.strftime("%Y-%m-%dT%H:%M:%SZ") if r.created_at else "",
                r.replied_at.strftime("%Y-%m-%dT%H:%M:%SZ") if r.replied_at else "",
                json.dumps(r.extra_metadata, ensure_ascii=False) if r.extra_metadata else "",
            ]
        )
        yield output.getvalue()
        output.truncate(0)
        output.seek(0)


def _get_nostr_adapter(channel_id: str):
    adapter = _get_adapter(channel_id)
    profile_api = getattr(adapter, "_profile_api", None)
    if profile_api is None:
        raise HTTPException(status_code=501, detail=f"渠道 '{channel_id}' 不支持 Profile 操作")
    return adapter, profile_api


def get_state_store() -> PluginStateStore:
    return PostgresPluginStateStore()


@channels.get("/nostr/profile")
async def get_nostr_profile(
    channel_id: str = Query(..., description="Nostr 渠道 ID"),
    account_id: str = Query("default"),
    current_user: User = Depends(get_admin_user),
):
    adapter, profile_api = _get_nostr_adapter(channel_id)
    profile = await profile_api.get_profile(account_id)
    return _make_response(data=profile)


@channels.post("/nostr/profile/publish")
async def publish_nostr_profile(
    channel_id: str = Query(..., description="Nostr 渠道 ID"),
    profile_data: dict = Body(..., description="Profile 数据"),
    account_id: str = Body("default"),
    current_user: User = Depends(get_admin_user),
):
    adapter, profile_api = _get_nostr_adapter(channel_id)
    result = await profile_api.publish_profile(profile_data, account_id)
    return _make_response(data=result)


@channels.get("/nostr/profile/import")
async def import_nostr_profile(
    pubkey: str = Query(..., description="目标 Nostr 公钥 (hex)"),
    channel_id: str = Query(..., description="Nostr 渠道 ID"),
    current_user: User = Depends(get_admin_user),
):
    adapter, profile_api = _get_nostr_adapter(channel_id)
    result = await profile_api.import_profile(pubkey)
    return _make_response(data=result)


@channels.post("/nostr/profile/merge")
async def merge_nostr_profile(
    channel_id: str = Query(..., description="Nostr 渠道 ID"),
    body: dict = Body(...),
    current_user: User = Depends(get_admin_user),
):
    local_data = body.get("local", {})
    imported_pubkey = body.get("imported_pubkey", "")
    adapter, profile_api = _get_nostr_adapter(channel_id)
    result = await profile_api.merge_profile(local_data, imported_pubkey)
    return _make_response(data=result)


@channels.get("/status")
async def list_channels_status(current_user: User = Depends(get_admin_user)):
    status_data = await get_channel_manager().get_channel_status()
    meta = status_data.get("_meta", {})
    code = 0
    message = "ok"
    if meta.get("failed", 0) > 0:
        code = 2001
        message = f"部分渠道状态获取失败 ({meta['failed']}/{meta['total_channels']})"
    return _make_response(code=code, data=status_data, message=message)


@channels.get("/actions")
async def list_channels_for_action(
    action: str | None = Query(None, description="要查询的 MessageAction，如 pin/edit/send"),
    current_user: User = Depends(get_admin_user),
):
    from yuxi.channels.message_actions import ActionRegistry, MessageAction

    if action:
        try:
            msg_action = MessageAction(action)
        except ValueError:
            return _make_response(
                code=-1,
                message=f"Unknown action: {action}. Valid actions: {[a.value for a in MessageAction]}",
            )
        channels = ActionRegistry.list_channels_for_action(msg_action)
        return _make_response(data={"action": action, "channels": channels})
    all_channels = ActionRegistry.list_all()
    result = {}
    for cid, caps in all_channels.items():
        result[cid] = {
            "supported_actions": caps.supported_actions(),
            "chat_types": caps.chat_types,
        }
    return _make_response(data=result)


@channels.post("/register")
async def register_channel(
    body: dict[str, Any],
    current_user: User = Depends(get_admin_user),
):
    channel_type = body.get("channel_type")
    if not channel_type:
        raise HTTPException(status_code=400, detail="channel_type is required")

    config = body.get("config", {})
    manager = get_channel_manager()

    try:
        await manager.register_channel(channel_type, config)
        return _make_response(
            data={"channel_id": channel_type, "registered": True},
            message="渠道注册成功",
        )
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@channels.get("/{channel_id}/actions")
async def get_channel_actions(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
):
    from yuxi.channels.message_actions import ActionRegistry

    declarations = ActionRegistry.list_all_declarations(channel_id)
    if declarations:
        actions_data = [
            {
                "action": decl.action.value,
                "status": decl.status.value,
                "reason": decl.reason,
                "impl": decl.impl,
            }
            for decl in declarations.values()
        ]
        return _make_response(data={"channel_id": channel_id, "actions": actions_data})

    caps = ActionRegistry.get(channel_id)
    if caps is None:
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")

    supported = caps.supported_actions()
    return _make_response(
        data={
            "channel_id": channel_id,
            "actions": [{"action": a, "status": "supported", "reason": "", "impl": ""} for a in supported],
        }
    )


@channels.get("/{channel_id}/status")
async def get_channel_status(
    channel_id: str = Path(
        ...,
        min_length=1,
        max_length=64,
        pattern=r"^[a-zA-Z0-9_-]+$",
        description="渠道标识符",
    ),
    include_stats: bool = Query(False),
    current_user: User = Depends(get_admin_user),
):
    await _check_rate_limit(str(current_user.id), "channel_status", 30, 60)
    status_data = await get_channel_manager().get_channel_status(channel_id, include_stats=include_stats)
    if status_data.get("status") == "not_found":
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")
    return _make_response(data=status_data)


@channels.post("/{channel_id}/start")
async def start_channel(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
):
    await _check_rate_limit(str(current_user.id), "channel_start", 3, 3)

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")

    config = manager._channels_config.get(channel_id, {})
    if not config.get("enabled", False):
        raise HTTPException(
            status_code=400,
            detail=f"Channel '{channel_id}' is disabled in configuration",
        )

    if manager.is_running(channel_id):
        return _make_response(code=409, message=f"Channel '{channel_id}' is already running")

    await _handle_channel_operation_exceptions(channel_id, manager.start_channel(channel_id))

    adapter = manager._adapters.get(channel_id)
    current_status = manager._adapter_status(adapter) if adapter else "connecting"

    response_data = {"channel_id": channel_id, "status": current_status}
    if adapter:
        try:
            snapshot = adapter.snapshot()
            response_data.update(
                {k: v for k, v in snapshot.items() if k in ("channel_type", "display_name", "capabilities", "health")}
            )
        except Exception:
            logger.warning(f"Failed to get snapshot for {channel_id}")

    return _make_response(data=response_data, message="Channel start initiated")


@channels.post("/{channel_id}/stop")
async def stop_channel(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
):
    await _check_rate_limit(str(current_user.id), "channel_stop", 3, 3)

    manager = get_channel_manager()
    if not manager.is_running(channel_id):
        return _make_response(code=409, message=f"Channel '{channel_id}' is not running")

    await manager.stop_channel(channel_id)
    return _make_response(
        data={"channel_id": channel_id, "status": "disconnected"},
        message="Channel stopped",
    )


@channels.post("/{channel_id}/restart")
async def restart_channel(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
):
    await _check_rate_limit(str(current_user.id), "channel_restart", 3, 3)

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")

    config = manager._channels_config.get(channel_id, {})
    if not config.get("enabled", False):
        raise HTTPException(
            status_code=400,
            detail=f"Channel '{channel_id}' is disabled in configuration",
        )

    if not manager.is_running(channel_id):
        raise HTTPException(status_code=409, detail=f"Channel '{channel_id}' is not running")

    await _handle_channel_operation_exceptions(channel_id, manager.restart_channel(channel_id))

    adapter = manager._adapters.get(channel_id)
    current_status = manager._adapter_status(adapter) if adapter else "connecting"
    return _make_response(
        data={"channel_id": channel_id, "status": current_status},
        message="Channel restart initiated",
    )


@channels.put("/{channel_id}/config")
async def update_channel_config(
    channel_id: str,
    config_updates: dict[str, Any],
    current_user: User = Depends(get_admin_user),
):
    await _check_rate_limit(str(current_user.id), "channel_config", 5, 10)

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")

    try:
        result = await manager.update_channel_config(channel_id, config_updates, user_id=str(current_user.id))

        if result["adapter_status"] == "stopped":
            message = "配置已保存。启动渠道后生效。"
        elif result.get("needs_restart"):
            message = "配置已更新。建议重启渠道以确保所有内部状态同步。"
        else:
            message = "配置已实时生效。"

        return _make_response(data=result, message=message)
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except ChannelException as e:
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        logger.error(f"Failed to update config for channel {channel_id}: {e}")
        raise HTTPException(status_code=500, detail=f"Failed to update channel config: {e}")


@channels.post("/{channel_id}/test")
async def test_channel(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
):
    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")

    result = await manager.test_channel(channel_id)
    return _make_response(data=result)


@channels.get("/{channel_id}/stats")
async def get_channel_stats(
    channel_id: str,
    days: int = Query(7, ge=1, le=90),
    period: str | None = Query(None, description="时间范围: 1d / 7d / 30d"),
    granularity: str = Query("day"),
    current_user: User = Depends(get_admin_user),
    db: AsyncSession = Depends(get_db),
):
    from datetime import timedelta

    from sqlalchemy import Integer

    from yuxi.utils.datetime_utils import utc_now_naive

    if period:
        period_map = {"1d": 1, "7d": 7, "30d": 30}
        days = period_map.get(period, 7)

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")

    now = utc_now_naive()
    since = now - timedelta(days=days)
    today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)

    stats_base = select(
        func.count().label("total"),
        func.sum(
            (ChannelMsgRecord.status == "success").cast(Integer),
        ).label("success_count"),
        func.sum(
            (ChannelMsgRecord.status == "error").cast(Integer),
        ).label("error_count"),
        func.avg(ChannelMsgRecord.response_time_ms).label("avg_response_ms"),
        func.percentile_cont(0.5).within_group(ChannelMsgRecord.response_time_ms).label("p50_ms"),
        func.percentile_cont(0.95).within_group(ChannelMsgRecord.response_time_ms).label("p95_ms"),
        func.percentile_cont(0.99).within_group(ChannelMsgRecord.response_time_ms).label("p99_ms"),
    ).where(
        ChannelMsgRecord.channel_id == channel_id,
        ChannelMsgRecord.created_at >= since,
    )

    result = await db.execute(stats_base)
    row = result.one()
    total = row.total or 0
    success = row.success_count or 0
    error = row.error_count or 0

    today_result = await db.execute(
        select(func.count()).where(
            ChannelMsgRecord.channel_id == channel_id,
            ChannelMsgRecord.created_at >= today_start,
        )
    )
    today_count = today_result.scalar() or 0

    active_users_result = await db.execute(
        select(func.count(func.distinct(ChannelMsgRecord.sender_user_id))).where(
            ChannelMsgRecord.channel_id == channel_id,
            ChannelMsgRecord.created_at >= since,
        )
    )
    active_users = active_users_result.scalar() or 0

    summary = {
        "today_count": today_count,
        "total_count": total,
        "active_users": active_users,
        "success_count": int(success),
        "error_count": int(error),
        "success_rate": round(success / total, 3) if total > 0 else 0,
        "avg_latency": round(row.avg_response_ms, 1) if row.avg_response_ms else 0,
        "p50_latency": round(row.p50_ms, 1) if row.p50_ms else 0,
        "p95_latency": round(row.p95_ms, 1) if row.p95_ms else 0,
        "p99_latency": round(row.p99_ms, 1) if row.p99_ms else 0,
    }

    daily_trend: list[dict] = []
    daily_success_rate: list[dict] = []
    if granularity == "day":
        daily_query = (
            select(
                func.date(ChannelMsgRecord.created_at).label("date"),
                func.count().label("count"),
                func.avg(ChannelMsgRecord.response_time_ms).label("avg_ms"),
            )
            .where(
                ChannelMsgRecord.channel_id == channel_id,
                ChannelMsgRecord.created_at >= since,
            )
            .group_by(func.date(ChannelMsgRecord.created_at))
            .order_by(func.date(ChannelMsgRecord.created_at))
        )

        daily_result = await db.execute(daily_query)
        daily_trend = [
            {"date": str(r.date), "count": r.count, "avg_ms": round(r.avg_ms, 1) if r.avg_ms else 0}
            for r in daily_result.all()
        ]

        success_rate_query = (
            select(
                func.date(ChannelMsgRecord.created_at).label("date"),
                func.count().label("total"),
                func.sum(
                    (ChannelMsgRecord.status == "success").cast(Integer),
                ).label("success"),
            )
            .where(
                ChannelMsgRecord.channel_id == channel_id,
                ChannelMsgRecord.created_at >= since,
            )
            .group_by(func.date(ChannelMsgRecord.created_at))
            .order_by(func.date(ChannelMsgRecord.created_at))
        )

        success_rate_result = await db.execute(success_rate_query)
        daily_success_rate = [
            {
                "date": str(r.date),
                "success_rate": round(r.success / r.total * 100, 1) if r.total > 0 else 0,
                "total": r.total,
            }
            for r in success_rate_result.all()
        ]

    type_dist_result = await db.execute(
        select(ChannelMsgRecord.chat_type, func.count().label("cnt"))
        .where(ChannelMsgRecord.channel_id == channel_id, ChannelMsgRecord.created_at >= since)
        .group_by(ChannelMsgRecord.chat_type)
    )
    chat_type_distribution = {r.chat_type: r.cnt for r in type_dist_result.all()}

    msg_type_result = await db.execute(
        select(ChannelMsgRecord.content_type, func.count().label("cnt"))
        .where(ChannelMsgRecord.channel_id == channel_id, ChannelMsgRecord.created_at >= since)
        .group_by(ChannelMsgRecord.content_type)
    )
    message_type_distribution = {r.content_type: r.cnt for r in msg_type_result.all()}

    return _make_response(
        data={
            "channel_id": channel_id,
            "period": {
                "from": since.strftime("%Y-%m-%dT%H:%M:%SZ"),
                "to": now.strftime("%Y-%m-%dT%H:%M:%SZ"),
            },
            "summary": summary,
            "daily_trend": daily_trend,
            "daily_success_rate": daily_success_rate,
            "chat_type_distribution": chat_type_distribution,
            "message_type_distribution": message_type_distribution,
        }
    )


@channels.get("/{channel_id}/users/{user_id}")
async def get_channel_user_mapping(
    channel_id: str,
    user_id: str,
    current_user: User = Depends(get_admin_user),
    db: AsyncSession = Depends(get_db),
):
    result = await db.execute(
        select(ChannelUserMapping).where(
            ChannelUserMapping.channel_id == channel_id,
            ChannelUserMapping.channel_user_id == user_id,
        )
    )
    mapping = result.scalar_one_or_none()
    if not mapping:
        raise HTTPException(status_code=404, detail="User mapping not found")

    thread_result = await db.execute(
        select(ChannelThreadMapping)
        .where(
            ChannelThreadMapping.channel_id == channel_id,
            ChannelThreadMapping.internal_user_id == mapping.internal_user_id,
        )
        .order_by(ChannelThreadMapping.last_active_at.desc())
        .limit(10)
    )
    recent_chats = [
        {
            "chat_id": t.channel_chat_id,
            "thread_id": t.thread_id,
            "last_active": t.last_active_at.strftime("%Y-%m-%dT%H:%M:%SZ") if t.last_active_at else None,
        }
        for t in thread_result.all()
    ]

    return _make_response(
        data={
            "channel_id": channel_id,
            "channel_user_id": user_id,
            "internal_user_id": mapping.internal_user_id,
            "created_at": mapping.created_at.strftime("%Y-%m-%dT%H:%M:%SZ") if mapping.created_at else None,
            "recent_chats": recent_chats,
        }
    )


@channels.get("/{channel_id}/messages")
async def get_channel_messages(
    channel_id: str,
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    status: str | None = Query(None),
    content_type: str | None = Query(None),
    date_from: str | None = Query(None),
    date_to: str | None = Query(None),
    search: str | None = Query(None),
    sort_by: str = Query("created_at"),
    sort_order: str = Query("desc", pattern="^(asc|desc)$"),
    current_user: User = Depends(get_admin_user),
    db: AsyncSession = Depends(get_db),
):
    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(
            status_code=404,
            detail=f"渠道 '{channel_id}' 未注册",
        )

    await _check_channel_rate_limit(
        channel_id=channel_id,
        user_id=str(current_user.id),
    )

    conditions = _build_message_conditions(
        channel_id=channel_id,
        status_value=status,
        content_type=content_type,
        date_from=date_from,
        date_to=date_to,
        search=search,
    )

    count_query = select(func.count()).select_from(ChannelMsgRecord).where(*conditions)
    total_result = await db.execute(count_query)
    total = total_result.scalar() or 0

    sort_column = getattr(ChannelMsgRecord, sort_by, None)
    if sort_column is None or sort_by not in SORTABLE_FIELDS:
        raise HTTPException(
            status_code=400,
            detail=f"不支持的排序字段: '{sort_by}'，可选: {', '.join(sorted(SORTABLE_FIELDS))}",
        )
    order_func = desc if sort_order == "desc" else asc

    query = (
        select(ChannelMsgRecord)
        .where(*conditions)
        .order_by(order_func(sort_column))
        .offset((page - 1) * page_size)
        .limit(page_size)
    )
    result = await db.execute(query)
    rows = result.scalars().all()
    messages = [
        {
            "id": r.id,
            "message_id": r.message_id,
            "channel_type": r.channel_type,
            "created_at": r.created_at.strftime("%Y-%m-%dT%H:%M:%SZ") if r.created_at else None,
            "sender_user_id": r.sender_user_id,
            "content_preview": r.content_preview,
            "content_type": r.content_type,
            "status": r.status,
            "response_time_ms": r.response_time_ms,
            "reply_content_preview": r.reply_content_preview,
            "reply_message_id": r.reply_message_id,
            "replied_at": r.replied_at.strftime("%Y-%m-%dT%H:%M:%SZ") if r.replied_at else None,
            "error_message": r.error_message,
            "chat_id": r.chat_id,
            "chat_type": r.chat_type,
        }
        for r in rows
    ]

    return _make_response(data={"messages": messages, "total": total})


@channels.get("/{channel_id}/messages/export")
async def export_channel_messages(
    channel_id: str,
    status: str | None = Query(None),
    content_type: str | None = Query(None),
    date_from: str | None = Query(None),
    date_to: str | None = Query(None),
    search: str | None = Query(None),
    current_user: User = Depends(get_admin_user),
    db: AsyncSession = Depends(get_db),
):
    await _check_rate_limit(str(current_user.id), "channel_messages_export", 5, 60)

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(
            status_code=404,
            detail=f"渠道 '{channel_id}' 未注册",
        )

    conditions = _build_message_conditions(
        channel_id=channel_id,
        status_value=status,
        content_type=content_type,
        date_from=date_from,
        date_to=date_to,
        search=search,
    )

    try:
        count_query = select(func.count()).select_from(ChannelMsgRecord).where(*conditions)
        total = (await db.execute(count_query)).scalar() or 0

        query = select(ChannelMsgRecord).where(*conditions).order_by(ChannelMsgRecord.created_at.desc()).limit(10000)
        result = await db.execute(query)
        rows = result.scalars().all()

        headers = {
            "Content-Disposition": f"attachment; filename=messages_{channel_id}.csv",
            "X-Total-Count": str(total),
        }
        if total > 10000:
            headers["X-Truncated"] = "true"

        return StreamingResponse(
            _UTF8SigEncoder(_csv_line_generator(rows)),
            media_type="text/csv; charset=utf-8",
            headers=headers,
        )
    except Exception:
        logger.exception(f"Failed to export messages for channel {channel_id}")
        raise HTTPException(status_code=500, detail="导出消息失败，请稍后重试")


@channels.get("/{channel_id}/policy")
async def get_channel_policy(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
    db: AsyncSession = Depends(get_db),
):
    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")

    try:
        result = await db.execute(select(ChannelPolicyConfig).where(ChannelPolicyConfig.channel_id == channel_id))
        policy = result.scalar_one_or_none()
    except Exception:
        logger.error(f"Failed to query policy for channel {channel_id}", exc_info=True)
        raise HTTPException(status_code=500, detail="查询策略配置失败")

    if not policy:
        return _make_response(data={"channel_id": channel_id, **_POLICY_DEFAULTS})
    return _make_response(data=policy.to_dict())


@channels.put("/{channel_id}/policy")
async def update_channel_policy(
    channel_id: str,
    policy_updates: ChannelPolicyUpdate,
    current_user: User = Depends(get_admin_user),
    db: AsyncSession = Depends(get_db),
):
    await _check_rate_limit(str(current_user.id), "channel_policy_update", 5, 5)

    updates_dict = policy_updates.model_dump(exclude_none=True)

    try:
        result = await db.execute(select(ChannelPolicyConfig).where(ChannelPolicyConfig.channel_id == channel_id))
        policy = result.scalar_one_or_none()

        if policy:
            for key in _POLICY_FIELDS:
                if key in updates_dict:
                    setattr(policy, key, updates_dict[key])
        else:
            policy_data = {k: v for k, v in updates_dict.items() if k in _POLICY_FIELDS}
            policy = ChannelPolicyConfig(channel_id=channel_id, **policy_data)
            db.add(policy)

        await db.commit()
        await db.refresh(policy)
    except IntegrityError:
        await db.rollback()
        raise HTTPException(status_code=409, detail="策略配置写入冲突，请重试")
    except DBAPIError as e:
        logger.error(f"数据库操作失败 (channel={channel_id}): {e}", exc_info=True)
        raise HTTPException(status_code=500, detail="数据库操作失败，请稍后重试")
    except Exception as e:
        logger.error(f"更新策略配置失败 (channel={channel_id}): {e}", exc_info=True)
        raise HTTPException(status_code=500, detail="更新策略配置失败")

    return _make_response(data=policy.to_dict(), message="策略配置已保存")


@channels.get("/{channel_id}/routing")
async def get_channel_routing(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
    db: AsyncSession = Depends(get_db),
):
    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"渠道 '{channel_id}' 不存在")

    from yuxi.storage.postgres.models_channels import ChannelRoutingRule

    try:
        result = await db.execute(select(ChannelRoutingRule).where(ChannelRoutingRule.channel_id == channel_id))
        rules = result.scalars().all()
    except DBAPIError as e:
        logger.error(f"查询路由规则失败 (channel={channel_id}): {e}", exc_info=True)
        raise HTTPException(status_code=500, detail="数据库操作失败，请稍后重试")
    except Exception as e:
        logger.error(f"查询路由规则失败 (channel={channel_id}): {e}", exc_info=True)
        raise HTTPException(status_code=500, detail="查询路由规则失败")

    return _make_response(data={"channel_id": channel_id, "routes": [r.to_dict() for r in rules]})


@channels.put("/{channel_id}/routing")
async def update_channel_routing(
    channel_id: str,
    routing_updates: list[dict[str, Any]],
    current_user: User = Depends(get_admin_user),
    db: AsyncSession = Depends(get_db),
):
    from yuxi.storage.postgres.models_channels import ChannelRoutingRule

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"渠道 '{channel_id}' 不存在")

    if not routing_updates:
        raise HTTPException(status_code=422, detail="不允许清空全部路由规则")

    from yuxi.repositories.agent_config_repository import AgentConfigRepository

    agent_repo = AgentConfigRepository(db)
    for item in routing_updates:
        aid = str(item.get("agent_config_id", "0"))
        try:
            aid_int = int(aid)
        except (ValueError, TypeError):
            raise HTTPException(status_code=422, detail=f"Agent 配置 ID '{aid}' 无效")
        config = await agent_repo.get_by_id(aid_int)
        if config is None:
            raise HTTPException(status_code=422, detail=f"Agent 配置 '{aid}' 不存在")

    existing = (
        (await db.execute(select(ChannelRoutingRule).where(ChannelRoutingRule.channel_id == channel_id)))
        .scalars()
        .all()
    )
    for rule in existing:
        await db.delete(rule)

    for item in routing_updates:
        rule = ChannelRoutingRule(
            channel_id=channel_id,
            command=item.get("command", ""),
            agent_config_id=str(item.get("agent_config_id", "0")),
        )
        db.add(rule)

    try:
        await db.commit()
    except IntegrityError:
        await db.rollback()
        raise HTTPException(status_code=409, detail="路由规则写入冲突，请重试")
    except DBAPIError as e:
        logger.error(f"数据库操作失败 (channel={channel_id}): {e}", exc_info=True)
        raise HTTPException(status_code=500, detail="数据库操作失败，请稍后重试")
    except Exception as e:
        logger.error(f"保存路由规则失败 (channel={channel_id}): {e}", exc_info=True)
        raise HTTPException(status_code=500, detail="保存路由规则失败")

    try:
        result = await db.execute(select(ChannelRoutingRule).where(ChannelRoutingRule.channel_id == channel_id))
        saved_rules = result.scalars().all()
    except DBAPIError as e:
        logger.error(f"查询路由规则失败 (channel={channel_id}): {e}", exc_info=True)
        raise HTTPException(status_code=500, detail="数据库操作失败，请稍后重试")
    except Exception as e:
        logger.error(f"查询路由规则失败 (channel={channel_id}): {e}", exc_info=True)
        raise HTTPException(status_code=500, detail="查询路由规则失败")
    return _make_response(
        data={"channel_id": channel_id, "routes": [r.to_dict() for r in saved_rules]},
        message="路由规则已保存",
    )


ALL_CONFIG_GROUPS = {
    "credentials": {"key": "credentials", "label": "认证凭据"},
    "general": {"key": "general", "label": "通用设置"},
    "routing": {"key": "routing", "label": "路由配置"},
    "advanced": {"key": "advanced", "label": "高级设置"},
}


@channels.get("/{channel_id}/config-schema")
async def get_channel_config_schema(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
):
    if not re.match(r"^[a-z0-9][a-z0-9_-]{0,30}$", channel_id):
        raise HTTPException(status_code=400, detail=f"Invalid channel_id: '{channel_id}'")

    await _check_rate_limit(str(current_user.id), "config_schema", 10, 5)

    manager = get_channel_manager()
    adapter_cls = manager._registry.get(channel_id)
    if adapter_cls is None:
        return _make_response(data={"channel_type": channel_id, "fields": [], "groups": []})

    schema = adapter_cls.get_config_schema()

    if not schema:
        logger.info(f"渠道 {channel_id} 未定义 config_schema，返回仅含 agent_config_id 的基本 Schema")

    fields = []
    used_groups: set[str] = set()

    for key, schema_def in schema.items():
        field_type = schema_def.get("type", "text")
        group = schema_def.get("group", "general")
        used_groups.add(group)

        field_entry: dict[str, Any] = {
            "key": key,
            "label": schema_def.get("label") or key.replace("_", " ").title(),
            "type": field_type,
            "required": schema_def.get("required", False),
            "group": group,
        }
        if "default" in schema_def:
            field_entry["default"] = schema_def["default"]
        if "enum" in schema_def:
            field_entry["enum"] = schema_def["enum"]
        if schema_def.get("secret"):
            field_entry["secret"] = True

        fields.append(field_entry)

    fields.append(
        {
            "key": "agent_config_id",
            "label": "默认 Agent",
            "type": "agent_select",
            "required": False,
            "group": "routing",
        }
    )
    used_groups.add("routing")

    groups = [ALL_CONFIG_GROUPS[g] for g in sorted(used_groups) if g in ALL_CONFIG_GROUPS]

    return _make_response(
        data={
            "channel_type": channel_id,
            "fields": fields,
            "groups": groups,
        }
    )


@channels.get("/{channel_id}/chats/{chat_id}")
async def get_channel_chat_mapping(
    channel_id: str,
    chat_id: str,
    current_user: User = Depends(get_admin_user),
    db: AsyncSession = Depends(get_db),
):
    result = await db.execute(
        select(ChannelThreadMapping)
        .where(
            ChannelThreadMapping.channel_id == channel_id,
            ChannelThreadMapping.channel_chat_id == chat_id,
        )
        .order_by(ChannelThreadMapping.last_active_at.desc())
        .limit(1)
    )
    mapping = result.scalar_one_or_none()
    if not mapping:
        raise HTTPException(status_code=404, detail="Chat mapping not found")

    return _make_response(
        data={
            "channel_id": channel_id,
            "channel_chat_id": chat_id,
            "thread_id": mapping.thread_id,
            "agent_id": mapping.agent_id,
            "created_at": mapping.created_at.strftime("%Y-%m-%dT%H:%M:%SZ") if mapping.created_at else None,
            "last_active_at": mapping.last_active_at.strftime("%Y-%m-%dT%H:%M:%SZ") if mapping.last_active_at else None,
        }
    )


@channels.post("/state/cleanup")
async def cleanup_expired_state(
    store: PluginStateStore = Depends(get_state_store),
    current_user: User = Depends(get_admin_user),
):
    count = await store.cleanup_expired()
    return _make_response(data={"cleaned": count}, message=f"清理了 {count} 条过期状态")


@channels.get("/{channel_id}/state")
async def list_channel_state(
    channel_id: str,
    store: PluginStateStore = Depends(get_state_store),
    current_user: User = Depends(get_admin_user),
):
    await _check_rate_limit(str(current_user.id), "state_read", 30, 10)

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' not found")

    all_state = await store.get_all(channel_id)

    safe_state = {}
    for ns, entries in all_state.items():
        if ns == "credentials":
            safe_state[ns] = {k: {"redacted": True, "has_credential": True} for k in entries}
        else:
            safe_state[ns] = entries

    return _make_response(data={"channel_id": channel_id, "state": safe_state})


@channels.get("/{channel_id}/state/{namespace}/{key}")
async def get_channel_state_entry(
    channel_id: str,
    namespace: str = Path(..., min_length=1, max_length=64),
    key: str = Path(..., min_length=1, max_length=128),
    store: PluginStateStore = Depends(get_state_store),
    current_user: User = Depends(get_admin_user),
):
    await _check_rate_limit(str(current_user.id), "state_read", 30, 10)

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' not found")

    value = await store.get(channel_id, key, namespace)
    if value is None:
        raise HTTPException(status_code=404, detail="State entry not found")

    if namespace == "credentials":
        return _make_response(
            data={
                "channel_id": channel_id,
                "namespace": namespace,
                "key": key,
                "redacted": True,
                "has_credential": True,
            }
        )

    return _make_response(data={"channel_id": channel_id, "namespace": namespace, "key": key, "value": value})


@channels.put("/{channel_id}/state/{namespace}/{key}")
async def update_channel_state_entry(
    body: UpdateStateEntryBody,
    channel_id: str = Path(..., min_length=1, max_length=32),
    namespace: str = Path(..., min_length=1, max_length=64),
    key: str = Path(..., min_length=1, max_length=128),
    store: PluginStateStore = Depends(get_state_store),
    current_user: User = Depends(get_admin_user),
):
    await _check_rate_limit(str(current_user.id), "state_write", 10, 10)

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' not found")

    logger.info(
        "渠道状态写入: user=%s, channel=%s, namespace=%s, key=%s, has_ttl=%s",
        current_user.id,
        channel_id,
        namespace,
        key,
        body.ttl_seconds is not None,
    )

    try:
        is_new = await store.set(
            channel_id,
            key,
            body.value,
            namespace,
            ttl_seconds=body.ttl_seconds,
        )
    except IntegrityError:
        raise HTTPException(status_code=409, detail="状态条目写入冲突，请重试")
    except DBAPIError as e:
        logger.error(
            "更新渠道状态失败 (channel=%s, ns=%s, key=%s): %s",
            channel_id,
            namespace,
            key,
            e,
            exc_info=True,
        )
        raise HTTPException(status_code=500, detail="数据库操作失败，请稍后重试")
    except Exception as e:
        logger.error("更新渠道状态失败 (channel=%s): %s", channel_id, e, exc_info=True)
        raise HTTPException(status_code=500, detail="更新渠道状态失败")

    status_code = 201 if is_new else 200
    message = "状态已创建" if is_new else "状态已更新"
    return JSONResponse(
        content=_make_response(
            data={"channel_id": channel_id, "namespace": namespace, "key": key},
            message=message,
        ),
        status_code=status_code,
    )


@channels.delete("/{channel_id}/state/{namespace}/{key}")
async def delete_channel_state_entry(
    channel_id: str,
    namespace: str = Path(..., min_length=1, max_length=64),
    key: str = Path(..., min_length=1, max_length=128),
    store: PluginStateStore = Depends(get_state_store),
    current_user: User = Depends(get_admin_user),
):
    await _check_rate_limit(str(current_user.id), "state_write", 10, 10)

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' not found")

    await store.delete(channel_id, key, namespace)
    return _make_response(
        data={"channel_id": channel_id, "namespace": namespace, "key": key},
        message="状态已删除",
    )


@channels.get("/{channel_id}/credential-status")
async def get_channel_credential_status(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
):
    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")

    credential = await manager.get_credential_status(channel_id)
    return _make_response(data={"channel_id": channel_id, "credential": credential})


@channels.post("/{channel_id}/refresh-credential")
async def refresh_channel_credential(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
):
    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")

    result = await manager.refresh_credential(channel_id)
    return _make_response(data={"channel_id": channel_id, "credential": result})


@channels.delete("/{channel_id}")
async def unregister_channel(
    channel_id: str,
    current_user: User = Depends(get_admin_user),
):
    await _check_rate_limit(str(current_user.id), "channel_unregister", 5, 10)

    manager = get_channel_manager()
    if not manager.is_registered(channel_id):
        raise HTTPException(status_code=404, detail=f"Channel '{channel_id}' is not registered")

    await manager.unregister_channel(channel_id)
    return _make_response(data={"channel_id": channel_id, "unregistered": True}, message="渠道已注销")