Aether/src/api/admin/system.py

"""系统设置API端点。"""

from __future__ import annotations

from dataclasses import dataclass
from typing import Optional

from fastapi import APIRouter, Depends, HTTPException, Request, status
from pydantic import ValidationError
from sqlalchemy.orm import Session

from src.api.base.admin_adapter import AdminApiAdapter
from src.api.base.pipeline import ApiRequestPipeline
from src.core.exceptions import InvalidRequestException, NotFoundException, translate_pydantic_error
from src.database import get_db
from src.models.api import SystemSettingsRequest, SystemSettingsResponse
from src.models.database import ApiKey, Provider, Usage, User
from src.services.email.email_template import EmailTemplate
from src.services.system.config import SystemConfigService

router = APIRouter(prefix="/api/admin/system", tags=["Admin - System"])


def _get_version_from_git() -> str | None:
    """从 git describe 获取版本号"""
    import subprocess

    try:
        result = subprocess.run(
            ["git", "describe", "--tags", "--always"],
            capture_output=True,
            text=True,
            timeout=5,
        )
        if result.returncode == 0:
            version = result.stdout.strip()
            if version.startswith("v"):
                version = version[1:]
            return version
    except Exception:
        pass
    return None


def _get_current_version() -> str:
    """获取当前版本号"""
    version = _get_version_from_git()
    if version:
        return version
    try:
        from src._version import __version__

        return __version__
    except ImportError:
        return "unknown"


def _parse_version(version_str: str) -> tuple:
    """解析版本号为可比较的元组，支持 3-4 段版本号

    例如:
    - '0.2.5' -> (0, 2, 5, 0)
    - '0.2.5.1' -> (0, 2, 5, 1)
    - 'v0.2.5-4-g1234567' -> (0, 2, 5, 0)
    """
    import re

    version_str = version_str.lstrip("v")
    main_version = re.split(r"[-+]", version_str)[0]
    try:
        parts = main_version.split(".")
        # 标准化为 4 段，便于比较
        int_parts = [int(p) for p in parts]
        while len(int_parts) < 4:
            int_parts.append(0)
        return tuple(int_parts[:4])
    except ValueError:
        return (0, 0, 0, 0)


@router.get("/version")
async def get_system_version():
    """
    获取系统版本信息

    获取当前系统的版本号。优先从 git describe 获取，回退到静态版本文件。

    **返回字段**:
    - `version`: 版本号字符串
    """
    return {"version": _get_current_version()}


@router.get("/check-update")
async def check_update():
    """
    检查系统更新

    从 GitHub Tags 获取最新版本并与当前版本对比。

    **返回字段**:
    - `current_version`: 当前版本号
    - `latest_version`: 最新版本号
    - `has_update`: 是否有更新可用
    - `release_url`: 最新版本的 GitHub 页面链接
    """
    import httpx

    from src.clients.http_client import HTTPClientPool

    current_version = _get_current_version()
    github_repo = "Aethersailor/Aether"
    github_tags_url = f"https://api.github.com/repos/{github_repo}/tags"

    try:
        async with HTTPClientPool.get_temp_client(
            timeout=httpx.Timeout(connect=5.0, read=10.0, write=5.0, pool=5.0)
        ) as client:
            response = await client.get(
                github_tags_url,
                headers={
                    "Accept": "application/vnd.github.v3+json",
                    "User-Agent": f"Aether/{current_version}",
                },
                params={"per_page": 10},
            )

            if response.status_code != 200:
                return {
                    "current_version": current_version,
                    "latest_version": None,
                    "has_update": False,
                    "release_url": None,
                    "error": f"GitHub API 返回错误: {response.status_code}",
                }

            tags = response.json()
            if not tags:
                return {
                    "current_version": current_version,
                    "latest_version": None,
                    "has_update": False,
                    "release_url": None,
                    "error": None,
                }

            # 找到最新的版本 tag（按版本号排序，而非时间）
            version_tags = []
            for tag in tags:
                tag_name = tag.get("name", "")
                if tag_name.startswith("v") or tag_name[0].isdigit():
                    version_tags.append((tag_name, _parse_version(tag_name)))

            if not version_tags:
                return {
                    "current_version": current_version,
                    "latest_version": None,
                    "has_update": False,
                    "release_url": None,
                    "error": None,
                }

            # 按版本号排序，取最大的
            version_tags.sort(key=lambda x: x[1], reverse=True)
            latest_tag = version_tags[0][0]
            latest_version = latest_tag.lstrip("v")

            current_tuple = _parse_version(current_version)
            latest_tuple = _parse_version(latest_version)
            has_update = latest_tuple > current_tuple

            return {
                "current_version": current_version,
                "latest_version": latest_version,
                "has_update": has_update,
                "release_url": f"https://github.com/{github_repo}/releases/tag/{latest_tag}",
                "error": None,
            }

    except httpx.TimeoutException:
        return {
            "current_version": current_version,
            "latest_version": None,
            "has_update": False,
            "release_url": None,
            "error": "检查更新超时",
        }
    except Exception as e:
        return {
            "current_version": current_version,
            "latest_version": None,
            "has_update": False,
            "release_url": None,
            "error": f"检查更新失败: {str(e)}",
        }


pipeline = ApiRequestPipeline()


@router.get("/settings")
async def get_system_settings(request: Request, db: Session = Depends(get_db)):
    """
    获取系统设置

    获取系统的全局设置信息。需要管理员权限。

    **返回字段**:
    - `default_provider`: 默认提供商名称
    - `default_model`: 默认模型名称
    - `enable_usage_tracking`: 是否启用使用情况追踪
    """

    adapter = AdminGetSystemSettingsAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.put("/settings")
async def update_system_settings(http_request: Request, db: Session = Depends(get_db)):
    """
    更新系统设置

    更新系统的全局设置。需要管理员权限。

    **请求体字段**:
    - `default_provider`: 可选，默认提供商名称（空字符串表示清除设置）
    - `default_model`: 可选，默认模型名称（空字符串表示清除设置）
    - `enable_usage_tracking`: 可选，是否启用使用情况追踪

    **返回字段**:
    - `message`: 操作结果信息
    """

    adapter = AdminUpdateSystemSettingsAdapter()
    return await pipeline.run(adapter=adapter, http_request=http_request, db=db, mode=adapter.mode)


@router.get("/configs")
async def get_all_system_configs(request: Request, db: Session = Depends(get_db)):
    """
    获取所有系统配置

    获取系统中所有的配置项。需要管理员权限。

    **返回字段**:
    - 配置项的键值对字典
    """

    adapter = AdminGetAllConfigsAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.get("/configs/{key}")
async def get_system_config(key: str, request: Request, db: Session = Depends(get_db)):
    """
    获取特定系统配置

    获取指定配置项的值。需要管理员权限。

    **路径参数**:
    - `key`: 配置项键名

    **返回字段**:
    - `key`: 配置项键名
    - `value`: 配置项的值（敏感配置项不返回实际值）
    - `is_set`: 可选，对于敏感配置项，指示是否已设置
    """

    adapter = AdminGetSystemConfigAdapter(key=key)
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.put("/configs/{key}")
async def set_system_config(
    key: str,
    request: Request,
    db: Session = Depends(get_db),
):
    """
    设置系统配置

    设置或更新指定配置项的值。需要管理员权限。

    **路径参数**:
    - `key`: 配置项键名

    **请求体字段**:
    - `value`: 配置项的值
    - `description`: 可选，配置项描述

    **返回字段**:
    - `key`: 配置项键名
    - `value`: 配置项的值（敏感配置项显示为 ********）
    - `description`: 配置项描述
    - `updated_at`: 更新时间
    """

    adapter = AdminSetSystemConfigAdapter(key=key)
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.delete("/configs/{key}")
async def delete_system_config(key: str, request: Request, db: Session = Depends(get_db)):
    """
    删除系统配置

    删除指定的配置项。需要管理员权限。

    **路径参数**:
    - `key`: 配置项键名

    **返回字段**:
    - `message`: 操作结果信息
    """

    adapter = AdminDeleteSystemConfigAdapter(key=key)
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.get("/stats")
async def get_system_stats(request: Request, db: Session = Depends(get_db)):
    """
    获取系统统计信息

    获取系统的整体统计数据。需要管理员权限。

    **返回字段**:
    - `users`: 用户统计（total: 总用户数, active: 活跃用户数）
    - `providers`: 提供商统计（total: 总提供商数, active: 活跃提供商数）
    - `api_keys`: API Key 总数
    - `requests`: 请求总数
    """
    adapter = AdminSystemStatsAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.post("/cleanup")
async def trigger_cleanup(request: Request, db: Session = Depends(get_db)):
    """
    手动触发清理任务

    手动触发使用记录清理任务，清理过期的请求/响应数据。需要管理员权限。

    **返回字段**:
    - `message`: 操作结果信息
    - `stats`: 清理统计信息
      - `total_records`: 总记录数统计（before, after, deleted）
      - `body_fields`: 请求/响应体字段清理统计（before, after, cleaned）
      - `header_fields`: 请求/响应头字段清理统计（before, after, cleaned）
    - `timestamp`: 清理完成时间
    """
    adapter = AdminTriggerCleanupAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.get("/api-formats")
async def get_api_formats(request: Request, db: Session = Depends(get_db)):
    """
    获取所有可用的 API 格式列表

    获取系统支持的所有 API 格式及其元数据。需要管理员权限。

    **返回字段**:
    - `formats`: API 格式列表，每个格式包含：
      - `value`: 格式值
      - `label`: 显示名称
      - `default_path`: 默认路径
      - `aliases`: 别名列表
    """
    adapter = AdminGetApiFormatsAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.get("/config/export")
async def export_config(request: Request, db: Session = Depends(get_db)):
    """导出提供商和模型配置（管理员）"""
    adapter = AdminExportConfigAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.post("/config/import")
async def import_config(request: Request, db: Session = Depends(get_db)):
    """导入提供商和模型配置（管理员）"""
    adapter = AdminImportConfigAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.get("/users/export")
async def export_users(request: Request, db: Session = Depends(get_db)):
    """导出用户数据（管理员）"""
    adapter = AdminExportUsersAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.post("/users/import")
async def import_users(request: Request, db: Session = Depends(get_db)):
    """导入用户数据（管理员）"""
    adapter = AdminImportUsersAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.post("/smtp/test")
async def test_smtp(request: Request, db: Session = Depends(get_db)):
    """测试 SMTP 连接（管理员）"""
    adapter = AdminTestSmtpAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


# -------- 邮件模板 API --------


@router.get("/email/templates")
async def get_email_templates(request: Request, db: Session = Depends(get_db)):
    """获取所有邮件模板（管理员）"""
    adapter = AdminGetEmailTemplatesAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.get("/email/templates/{template_type}")
async def get_email_template(
    template_type: str, request: Request, db: Session = Depends(get_db)
):
    """获取指定类型的邮件模板（管理员）"""
    adapter = AdminGetEmailTemplateAdapter(template_type=template_type)
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.put("/email/templates/{template_type}")
async def update_email_template(
    template_type: str, request: Request, db: Session = Depends(get_db)
):
    """更新邮件模板（管理员）"""
    adapter = AdminUpdateEmailTemplateAdapter(template_type=template_type)
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.post("/email/templates/{template_type}/preview")
async def preview_email_template(
    template_type: str, request: Request, db: Session = Depends(get_db)
):
    """预览邮件模板（管理员）"""
    adapter = AdminPreviewEmailTemplateAdapter(template_type=template_type)
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.post("/email/templates/{template_type}/reset")
async def reset_email_template(
    template_type: str, request: Request, db: Session = Depends(get_db)
):
    """重置邮件模板为默认值（管理员）"""
    adapter = AdminResetEmailTemplateAdapter(template_type=template_type)
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


# -------- 系统设置适配器 --------


class AdminGetSystemSettingsAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        db = context.db
        default_provider = SystemConfigService.get_default_provider(db)
        default_model = SystemConfigService.get_config(db, "default_model")
        enable_usage_tracking = (
            SystemConfigService.get_config(db, "enable_usage_tracking", "true") == "true"
        )

        return SystemSettingsResponse(
            default_provider=default_provider,
            default_model=default_model,
            enable_usage_tracking=enable_usage_tracking,
        )


class AdminUpdateSystemSettingsAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        db = context.db
        payload = context.ensure_json_body()
        try:
            settings_request = SystemSettingsRequest.model_validate(payload)
        except ValidationError as e:
            errors = e.errors()
            if errors:
                raise InvalidRequestException(translate_pydantic_error(errors[0]))
            raise InvalidRequestException("请求数据验证失败")

        if settings_request.default_provider is not None:
            provider = (
                db.query(Provider)
                .filter(
                    Provider.name == settings_request.default_provider,
                    Provider.is_active.is_(True),
                )
                .first()
            )

            if not provider and settings_request.default_provider != "":
                raise HTTPException(
                    status_code=status.HTTP_400_BAD_REQUEST,
                    detail=f"提供商 '{settings_request.default_provider}' 不存在或未启用",
                )

            if settings_request.default_provider:
                SystemConfigService.set_default_provider(db, settings_request.default_provider)
            else:
                SystemConfigService.delete_config(db, "default_provider")

        if settings_request.default_model is not None:
            if settings_request.default_model:
                SystemConfigService.set_config(db, "default_model", settings_request.default_model)
            else:
                SystemConfigService.delete_config(db, "default_model")

        if settings_request.enable_usage_tracking is not None:
            SystemConfigService.set_config(
                db,
                "enable_usage_tracking",
                str(settings_request.enable_usage_tracking).lower(),
            )

        return {"message": "系统设置更新成功"}


class AdminGetAllConfigsAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        return SystemConfigService.get_all_configs(context.db)


@dataclass
class AdminGetSystemConfigAdapter(AdminApiAdapter):
    key: str

    # 敏感配置项，不返回实际值
    SENSITIVE_KEYS = {"smtp_password"}

    async def handle(self, context):  # type: ignore[override]
        value = SystemConfigService.get_config(context.db, self.key)
        if value is None:
            raise NotFoundException(f"配置项 '{self.key}' 不存在")
        # 对敏感配置，只返回是否已设置的标志，不返回实际值
        if self.key in self.SENSITIVE_KEYS:
            return {"key": self.key, "value": None, "is_set": bool(value)}
        return {"key": self.key, "value": value}


@dataclass
class AdminSetSystemConfigAdapter(AdminApiAdapter):
    key: str

    # 需要加密存储的配置项
    ENCRYPTED_KEYS = {"smtp_password"}

    async def handle(self, context):  # type: ignore[override]
        payload = context.ensure_json_body()
        value = payload.get("value")

        # 对敏感配置进行加密
        if self.key in self.ENCRYPTED_KEYS and value:
            from src.core.crypto import crypto_service
            value = crypto_service.encrypt(value)

        config = SystemConfigService.set_config(
            context.db,
            self.key,
            value,
            payload.get("description"),
        )

        # 返回时不暴露加密后的值
        display_value = "********" if self.key in self.ENCRYPTED_KEYS else config.value

        return {
            "key": config.key,
            "value": display_value,
            "description": config.description,
            "updated_at": config.updated_at.isoformat(),
        }


@dataclass
class AdminDeleteSystemConfigAdapter(AdminApiAdapter):
    key: str

    async def handle(self, context):  # type: ignore[override]
        deleted = SystemConfigService.delete_config(context.db, self.key)
        if not deleted:
            raise NotFoundException(f"配置项 '{self.key}' 不存在")
        return {"message": f"配置项 '{self.key}' 已删除"}


class AdminSystemStatsAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        db = context.db
        total_users = db.query(User).count()
        active_users = db.query(User).filter(User.is_active.is_(True)).count()
        total_providers = db.query(Provider).count()
        active_providers = db.query(Provider).filter(Provider.is_active.is_(True)).count()
        total_api_keys = db.query(ApiKey).count()
        total_requests = db.query(Usage).count()

        return {
            "users": {"total": total_users, "active": active_users},
            "providers": {"total": total_providers, "active": active_providers},
            "api_keys": total_api_keys,
            "requests": total_requests,
        }


class AdminTriggerCleanupAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        """手动触发清理任务"""
        from datetime import datetime, timedelta, timezone

        from sqlalchemy import func

        from src.services.system.cleanup_scheduler import get_cleanup_scheduler

        db = context.db

        # 获取清理前的统计信息
        total_before = db.query(Usage).count()
        with_body_before = (
            db.query(Usage)
            .filter((Usage.request_body.isnot(None)) | (Usage.response_body.isnot(None)))
            .count()
        )
        with_headers_before = (
            db.query(Usage)
            .filter((Usage.request_headers.isnot(None)) | (Usage.response_headers.isnot(None)))
            .count()
        )

        # 触发清理
        cleanup_scheduler = get_cleanup_scheduler()
        await cleanup_scheduler._perform_cleanup()

        # 获取清理后的统计信息
        total_after = db.query(Usage).count()
        with_body_after = (
            db.query(Usage)
            .filter((Usage.request_body.isnot(None)) | (Usage.response_body.isnot(None)))
            .count()
        )
        with_headers_after = (
            db.query(Usage)
            .filter((Usage.request_headers.isnot(None)) | (Usage.response_headers.isnot(None)))
            .count()
        )

        return {
            "message": "清理任务执行完成",
            "stats": {
                "total_records": {
                    "before": total_before,
                    "after": total_after,
                    "deleted": total_before - total_after,
                },
                "body_fields": {
                    "before": with_body_before,
                    "after": with_body_after,
                    "cleaned": with_body_before - with_body_after,
                },
                "header_fields": {
                    "before": with_headers_before,
                    "after": with_headers_after,
                    "cleaned": with_headers_before - with_headers_after,
                },
            },
            "timestamp": datetime.now(timezone.utc).isoformat(),
        }


class AdminGetApiFormatsAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        """获取所有可用的API格式"""
        from src.core.api_format_metadata import API_FORMAT_DEFINITIONS
        from src.core.enums import APIFormat

        _ = context  # 参数保留以符合接口规范

        formats = []
        for api_format in APIFormat:
            definition = API_FORMAT_DEFINITIONS.get(api_format)
            formats.append(
                {
                    "value": api_format.value,
                    "label": api_format.value,
                    "default_path": definition.default_path if definition else "/",
                    "aliases": list(definition.aliases) if definition else [],
                }
            )

        return {"formats": formats}


class AdminExportConfigAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        """导出提供商和模型配置（解密数据）"""
        from datetime import datetime, timezone

        from src.core.crypto import crypto_service
        from src.models.database import GlobalModel, Model, ProviderAPIKey, ProviderEndpoint

        db = context.db

        # 导出 GlobalModels
        global_models = db.query(GlobalModel).all()
        global_models_data = []
        for gm in global_models:
            global_models_data.append(
                {
                    "name": gm.name,
                    "display_name": gm.display_name,
                    "default_price_per_request": gm.default_price_per_request,
                    "default_tiered_pricing": gm.default_tiered_pricing,
                    "supported_capabilities": gm.supported_capabilities,
                    "config": gm.config,
                    "is_active": gm.is_active,
                }
            )

        # 导出 Providers 及其关联数据
        providers = db.query(Provider).all()
        providers_data = []
        for provider in providers:
            # 导出 Endpoints
            endpoints = (
                db.query(ProviderEndpoint)
                .filter(ProviderEndpoint.provider_id == provider.id)
                .all()
            )
            endpoints_data = []
            for ep in endpoints:
                # 导出 Endpoint Keys
                keys = (
                    db.query(ProviderAPIKey).filter(ProviderAPIKey.endpoint_id == ep.id).all()
                )
                keys_data = []
                for key in keys:
                    # 解密 API Key
                    try:
                        decrypted_key = crypto_service.decrypt(key.api_key)
                    except Exception:
                        decrypted_key = ""

                    keys_data.append(
                        {
                            "api_key": decrypted_key,
                            "name": key.name,
                            "note": key.note,
                            "rate_multiplier": key.rate_multiplier,
                            "internal_priority": key.internal_priority,
                            "global_priority": key.global_priority,
                            "max_concurrent": key.max_concurrent,
                            "rate_limit": key.rate_limit,
                            "daily_limit": key.daily_limit,
                            "monthly_limit": key.monthly_limit,
                            "allowed_models": key.allowed_models,
                            "capabilities": key.capabilities,
                            "is_active": key.is_active,
                        }
                    )

                endpoints_data.append(
                    {
                        "api_format": ep.api_format,
                        "base_url": ep.base_url,
                        "headers": ep.headers,
                        "timeout": ep.timeout,
                        "max_retries": ep.max_retries,
                        "max_concurrent": ep.max_concurrent,
                        "rate_limit": ep.rate_limit,
                        "is_active": ep.is_active,
                        "custom_path": ep.custom_path,
                        "config": ep.config,
                        "keys": keys_data,
                    }
                )

            # 导出 Provider Models
            models = db.query(Model).filter(Model.provider_id == provider.id).all()
            models_data = []
            for model in models:
                # 获取关联的 GlobalModel 名称
                global_model = (
                    db.query(GlobalModel).filter(GlobalModel.id == model.global_model_id).first()
                )
                models_data.append(
                    {
                        "global_model_name": global_model.name if global_model else None,
                        "provider_model_name": model.provider_model_name,
                        "provider_model_mappings": model.provider_model_mappings,
                        "price_per_request": model.price_per_request,
                        "tiered_pricing": model.tiered_pricing,
                        "supports_vision": model.supports_vision,
                        "supports_function_calling": model.supports_function_calling,
                        "supports_streaming": model.supports_streaming,
                        "supports_extended_thinking": model.supports_extended_thinking,
                        "supports_image_generation": model.supports_image_generation,
                        "is_active": model.is_active,
                        "config": model.config,
                    }
                )

            providers_data.append(
                {
                    "name": provider.name,
                    "display_name": provider.display_name,
                    "description": provider.description,
                    "website": provider.website,
                    "billing_type": provider.billing_type.value if provider.billing_type else None,
                    "monthly_quota_usd": provider.monthly_quota_usd,
                    "quota_reset_day": provider.quota_reset_day,
                    "rpm_limit": provider.rpm_limit,
                    "provider_priority": provider.provider_priority,
                    "is_active": provider.is_active,
                    "concurrent_limit": provider.concurrent_limit,
                    "config": provider.config,
                    "endpoints": endpoints_data,
                    "models": models_data,
                }
            )

        return {
            "version": "1.0",
            "exported_at": datetime.now(timezone.utc).isoformat(),
            "global_models": global_models_data,
            "providers": providers_data,
        }


MAX_IMPORT_SIZE = 10 * 1024 * 1024  # 10MB


class AdminImportConfigAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        """导入提供商和模型配置"""
        import uuid
        from datetime import datetime, timezone

        from src.core.crypto import crypto_service
        from src.core.enums import ProviderBillingType
        from src.models.database import GlobalModel, Model, ProviderAPIKey, ProviderEndpoint

        # 检查请求体大小
        if context.raw_body and len(context.raw_body) > MAX_IMPORT_SIZE:
            raise InvalidRequestException("请求体大小不能超过 10MB")

        db = context.db
        payload = context.ensure_json_body()

        # 验证配置版本
        version = payload.get("version")
        if version != "1.0":
            raise InvalidRequestException(f"不支持的配置版本: {version}")

        # 获取导入选项
        merge_mode = payload.get("merge_mode", "skip")  # skip, overwrite, error
        global_models_data = payload.get("global_models", [])
        providers_data = payload.get("providers", [])

        stats = {
            "global_models": {"created": 0, "updated": 0, "skipped": 0},
            "providers": {"created": 0, "updated": 0, "skipped": 0},
            "endpoints": {"created": 0, "updated": 0, "skipped": 0},
            "keys": {"created": 0, "updated": 0, "skipped": 0},
            "models": {"created": 0, "updated": 0, "skipped": 0},
            "errors": [],
        }

        try:
            # 导入 GlobalModels
            global_model_map = {}  # name -> id 映射
            for gm_data in global_models_data:
                existing = (
                    db.query(GlobalModel).filter(GlobalModel.name == gm_data["name"]).first()
                )

                if existing:
                    global_model_map[gm_data["name"]] = existing.id
                    if merge_mode == "skip":
                        stats["global_models"]["skipped"] += 1
                        continue
                    elif merge_mode == "error":
                        raise InvalidRequestException(
                            f"GlobalModel '{gm_data['name']}' 已存在"
                        )
                    elif merge_mode == "overwrite":
                        # 更新现有记录
                        existing.display_name = gm_data.get(
                            "display_name", existing.display_name
                        )
                        existing.default_price_per_request = gm_data.get(
                            "default_price_per_request"
                        )
                        existing.default_tiered_pricing = gm_data.get(
                            "default_tiered_pricing", existing.default_tiered_pricing
                        )
                        existing.supported_capabilities = gm_data.get(
                            "supported_capabilities"
                        )
                        existing.config = gm_data.get("config")
                        existing.is_active = gm_data.get("is_active", True)
                        existing.updated_at = datetime.now(timezone.utc)
                        stats["global_models"]["updated"] += 1
                else:
                    # 创建新记录
                    new_gm = GlobalModel(
                        id=str(uuid.uuid4()),
                        name=gm_data["name"],
                        display_name=gm_data.get("display_name", gm_data["name"]),
                        default_price_per_request=gm_data.get("default_price_per_request"),
                        default_tiered_pricing=gm_data.get(
                            "default_tiered_pricing",
                            {"tiers": [{"up_to": None, "input_price_per_1m": 0, "output_price_per_1m": 0}]},
                        ),
                        supported_capabilities=gm_data.get("supported_capabilities"),
                        config=gm_data.get("config"),
                        is_active=gm_data.get("is_active", True),
                    )
                    db.add(new_gm)
                    db.flush()
                    global_model_map[gm_data["name"]] = new_gm.id
                    stats["global_models"]["created"] += 1

            # 导入 Providers
            for prov_data in providers_data:
                existing_provider = (
                    db.query(Provider).filter(Provider.name == prov_data["name"]).first()
                )

                if existing_provider:
                    provider_id = existing_provider.id
                    if merge_mode == "skip":
                        stats["providers"]["skipped"] += 1
                        # 仍然需要处理 endpoints 和 models（如果存在）
                    elif merge_mode == "error":
                        raise InvalidRequestException(
                            f"Provider '{prov_data['name']}' 已存在"
                        )
                    elif merge_mode == "overwrite":
                        # 更新现有记录
                        existing_provider.display_name = prov_data.get(
                            "display_name", existing_provider.display_name
                        )
                        existing_provider.description = prov_data.get("description")
                        existing_provider.website = prov_data.get("website")
                        if prov_data.get("billing_type"):
                            existing_provider.billing_type = ProviderBillingType(
                                prov_data["billing_type"]
                            )
                        existing_provider.monthly_quota_usd = prov_data.get(
                            "monthly_quota_usd"
                        )
                        existing_provider.quota_reset_day = prov_data.get(
                            "quota_reset_day", 30
                        )
                        existing_provider.rpm_limit = prov_data.get("rpm_limit")
                        existing_provider.provider_priority = prov_data.get(
                            "provider_priority", 100
                        )
                        existing_provider.is_active = prov_data.get("is_active", True)
                        existing_provider.concurrent_limit = prov_data.get(
                            "concurrent_limit"
                        )
                        existing_provider.config = prov_data.get("config")
                        existing_provider.updated_at = datetime.now(timezone.utc)
                        stats["providers"]["updated"] += 1
                else:
                    # 创建新 Provider
                    billing_type = ProviderBillingType.PAY_AS_YOU_GO
                    if prov_data.get("billing_type"):
                        billing_type = ProviderBillingType(prov_data["billing_type"])

                    new_provider = Provider(
                        id=str(uuid.uuid4()),
                        name=prov_data["name"],
                        display_name=prov_data.get("display_name", prov_data["name"]),
                        description=prov_data.get("description"),
                        website=prov_data.get("website"),
                        billing_type=billing_type,
                        monthly_quota_usd=prov_data.get("monthly_quota_usd"),
                        quota_reset_day=prov_data.get("quota_reset_day", 30),
                        rpm_limit=prov_data.get("rpm_limit"),
                        provider_priority=prov_data.get("provider_priority", 100),
                        is_active=prov_data.get("is_active", True),
                        concurrent_limit=prov_data.get("concurrent_limit"),
                        config=prov_data.get("config"),
                    )
                    db.add(new_provider)
                    db.flush()
                    provider_id = new_provider.id
                    stats["providers"]["created"] += 1

                # 导入 Endpoints
                for ep_data in prov_data.get("endpoints", []):
                    existing_ep = (
                        db.query(ProviderEndpoint)
                        .filter(
                            ProviderEndpoint.provider_id == provider_id,
                            ProviderEndpoint.api_format == ep_data["api_format"],
                        )
                        .first()
                    )

                    if existing_ep:
                        endpoint_id = existing_ep.id
                        if merge_mode == "skip":
                            stats["endpoints"]["skipped"] += 1
                        elif merge_mode == "error":
                            raise InvalidRequestException(
                                f"Endpoint '{ep_data['api_format']}' 已存在于 Provider '{prov_data['name']}'"
                            )
                        elif merge_mode == "overwrite":
                            existing_ep.base_url = ep_data.get(
                                "base_url", existing_ep.base_url
                            )
                            existing_ep.headers = ep_data.get("headers")
                            existing_ep.timeout = ep_data.get("timeout", 300)
                            existing_ep.max_retries = ep_data.get("max_retries", 2)
                            existing_ep.max_concurrent = ep_data.get("max_concurrent")
                            existing_ep.rate_limit = ep_data.get("rate_limit")
                            existing_ep.is_active = ep_data.get("is_active", True)
                            existing_ep.custom_path = ep_data.get("custom_path")
                            existing_ep.config = ep_data.get("config")
                            existing_ep.updated_at = datetime.now(timezone.utc)
                            stats["endpoints"]["updated"] += 1
                    else:
                        new_ep = ProviderEndpoint(
                            id=str(uuid.uuid4()),
                            provider_id=provider_id,
                            api_format=ep_data["api_format"],
                            base_url=ep_data["base_url"],
                            headers=ep_data.get("headers"),
                            timeout=ep_data.get("timeout", 300),
                            max_retries=ep_data.get("max_retries", 2),
                            max_concurrent=ep_data.get("max_concurrent"),
                            rate_limit=ep_data.get("rate_limit"),
                            is_active=ep_data.get("is_active", True),
                            custom_path=ep_data.get("custom_path"),
                            config=ep_data.get("config"),
                        )
                        db.add(new_ep)
                        db.flush()
                        endpoint_id = new_ep.id
                        stats["endpoints"]["created"] += 1

                    # 导入 Keys
                    # 获取当前 endpoint 下所有已有的 keys，用于去重
                    existing_keys = (
                        db.query(ProviderAPIKey)
                        .filter(ProviderAPIKey.endpoint_id == endpoint_id)
                        .all()
                    )
                    # 解密已有 keys 用于比对
                    existing_key_values = set()
                    for ek in existing_keys:
                        try:
                            decrypted = crypto_service.decrypt(ek.api_key)
                            existing_key_values.add(decrypted)
                        except Exception:
                            pass

                    for key_data in ep_data.get("keys", []):
                        if not key_data.get("api_key"):
                            stats["errors"].append(
                                f"跳过空 API Key (Endpoint: {ep_data['api_format']})"
                            )
                            continue

                        # 检查是否已存在相同的 Key（通过明文比对）
                        if key_data["api_key"] in existing_key_values:
                            stats["keys"]["skipped"] += 1
                            continue

                        encrypted_key = crypto_service.encrypt(key_data["api_key"])

                        new_key = ProviderAPIKey(
                            id=str(uuid.uuid4()),
                            endpoint_id=endpoint_id,
                            api_key=encrypted_key,
                            name=key_data.get("name"),
                            note=key_data.get("note"),
                            rate_multiplier=key_data.get("rate_multiplier", 1.0),
                            internal_priority=key_data.get("internal_priority", 100),
                            global_priority=key_data.get("global_priority"),
                            max_concurrent=key_data.get("max_concurrent"),
                            rate_limit=key_data.get("rate_limit"),
                            daily_limit=key_data.get("daily_limit"),
                            monthly_limit=key_data.get("monthly_limit"),
                            allowed_models=key_data.get("allowed_models"),
                            capabilities=key_data.get("capabilities"),
                            is_active=key_data.get("is_active", True),
                        )
                        db.add(new_key)
                        # 添加到已有集合，防止同一批导入中重复
                        existing_key_values.add(key_data["api_key"])
                        stats["keys"]["created"] += 1

                # 导入 Models
                for model_data in prov_data.get("models", []):
                    global_model_name = model_data.get("global_model_name")
                    if not global_model_name:
                        stats["errors"].append(
                            f"跳过无 global_model_name 的模型 (Provider: {prov_data['name']})"
                        )
                        continue

                    global_model_id = global_model_map.get(global_model_name)
                    if not global_model_id:
                        # 尝试从数据库查找
                        existing_gm = (
                            db.query(GlobalModel)
                            .filter(GlobalModel.name == global_model_name)
                            .first()
                        )
                        if existing_gm:
                            global_model_id = existing_gm.id
                        else:
                            stats["errors"].append(
                                f"GlobalModel '{global_model_name}' 不存在，跳过模型"
                            )
                            continue

                    existing_model = (
                        db.query(Model)
                        .filter(
                            Model.provider_id == provider_id,
                            Model.provider_model_name == model_data["provider_model_name"],
                        )
                        .first()
                    )

                    if existing_model:
                        if merge_mode == "skip":
                            stats["models"]["skipped"] += 1
                        elif merge_mode == "error":
                            raise InvalidRequestException(
                                f"Model '{model_data['provider_model_name']}' 已存在于 Provider '{prov_data['name']}'"
                            )
                        elif merge_mode == "overwrite":
                            existing_model.global_model_id = global_model_id
                            existing_model.provider_model_mappings = model_data.get(
                                "provider_model_mappings"
                            )
                            existing_model.price_per_request = model_data.get(
                                "price_per_request"
                            )
                            existing_model.tiered_pricing = model_data.get(
                                "tiered_pricing"
                            )
                            existing_model.supports_vision = model_data.get(
                                "supports_vision"
                            )
                            existing_model.supports_function_calling = model_data.get(
                                "supports_function_calling"
                            )
                            existing_model.supports_streaming = model_data.get(
                                "supports_streaming"
                            )
                            existing_model.supports_extended_thinking = model_data.get(
                                "supports_extended_thinking"
                            )
                            existing_model.supports_image_generation = model_data.get(
                                "supports_image_generation"
                            )
                            existing_model.is_active = model_data.get("is_active", True)
                            existing_model.config = model_data.get("config")
                            existing_model.updated_at = datetime.now(timezone.utc)
                            stats["models"]["updated"] += 1
                    else:
                        new_model = Model(
                            id=str(uuid.uuid4()),
                            provider_id=provider_id,
                            global_model_id=global_model_id,
                            provider_model_name=model_data["provider_model_name"],
                            provider_model_mappings=model_data.get(
                                "provider_model_mappings"
                            ),
                            price_per_request=model_data.get("price_per_request"),
                            tiered_pricing=model_data.get("tiered_pricing"),
                            supports_vision=model_data.get("supports_vision"),
                            supports_function_calling=model_data.get(
                                "supports_function_calling"
                            ),
                            supports_streaming=model_data.get("supports_streaming"),
                            supports_extended_thinking=model_data.get(
                                "supports_extended_thinking"
                            ),
                            supports_image_generation=model_data.get(
                                "supports_image_generation"
                            ),
                            is_active=model_data.get("is_active", True),
                            config=model_data.get("config"),
                        )
                        db.add(new_model)
                        stats["models"]["created"] += 1

            db.commit()

            # 失效缓存
            from src.services.cache.invalidation import get_cache_invalidation_service

            cache_service = get_cache_invalidation_service()
            cache_service.clear_all_caches()

            return {
                "message": "配置导入成功",
                "stats": stats,
            }

        except InvalidRequestException:
            db.rollback()
            raise
        except Exception as e:
            db.rollback()
            raise InvalidRequestException(f"导入失败: {str(e)}")


class AdminExportUsersAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        """导出用户数据（保留加密数据，排除管理员）"""
        from datetime import datetime, timezone

        from src.core.enums import UserRole
        from src.models.database import ApiKey, User

        db = context.db

        def _serialize_api_key(key: ApiKey, include_is_standalone: bool = False) -> dict:
            """序列化 API Key 为导出格式"""
            data = {
                "key_hash": key.key_hash,
                "key_encrypted": key.key_encrypted,
                "name": key.name,
                "balance_used_usd": key.balance_used_usd,
                "current_balance_usd": key.current_balance_usd,
                "allowed_providers": key.allowed_providers,
                "allowed_api_formats": key.allowed_api_formats,
                "allowed_models": key.allowed_models,
                "rate_limit": key.rate_limit,
                "concurrent_limit": key.concurrent_limit,
                "force_capabilities": key.force_capabilities,
                "is_active": key.is_active,
                "expires_at": key.expires_at.isoformat() if key.expires_at else None,
                "auto_delete_on_expiry": key.auto_delete_on_expiry,
                "total_requests": key.total_requests,
                "total_cost_usd": key.total_cost_usd,
            }
            if include_is_standalone:
                data["is_standalone"] = key.is_standalone
            return data

        # 导出 Users（排除管理员）
        users = db.query(User).filter(
            User.is_deleted.is_(False),
            User.role != UserRole.ADMIN
        ).all()
        users_data = []
        for user in users:
            # 导出用户的 API Keys（排除独立余额Key，独立Key单独导出）
            api_keys = db.query(ApiKey).filter(
                ApiKey.user_id == user.id,
                ApiKey.is_standalone.is_(False)
            ).all()
            api_keys_data = [_serialize_api_key(key, include_is_standalone=True) for key in api_keys]

            users_data.append(
                {
                    "email": user.email,
                    "username": user.username,
                    "password_hash": user.password_hash,
                    "role": user.role.value if user.role else "user",
                    "allowed_providers": user.allowed_providers,
                    "allowed_api_formats": user.allowed_api_formats,
                    "allowed_models": user.allowed_models,
                    "model_capability_settings": user.model_capability_settings,
                    "quota_usd": user.quota_usd,
                    "used_usd": user.used_usd,
                    "total_usd": user.total_usd,
                    "is_active": user.is_active,
                    "api_keys": api_keys_data,
                }
            )

        # 导出独立余额 Keys（管理员创建的，不属于普通用户）
        standalone_keys = db.query(ApiKey).filter(ApiKey.is_standalone.is_(True)).all()
        standalone_keys_data = [_serialize_api_key(key) for key in standalone_keys]

        return {
            "version": "1.1",
            "exported_at": datetime.now(timezone.utc).isoformat(),
            "users": users_data,
            "standalone_keys": standalone_keys_data,
        }


class AdminImportUsersAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        """导入用户数据"""
        import uuid
        from datetime import datetime, timezone

        from src.core.enums import UserRole
        from src.models.database import ApiKey, User

        # 检查请求体大小
        if context.raw_body and len(context.raw_body) > MAX_IMPORT_SIZE:
            raise InvalidRequestException("请求体大小不能超过 10MB")

        db = context.db
        payload = context.ensure_json_body()

        # 获取导入选项
        merge_mode = payload.get("merge_mode", "skip")  # skip, overwrite, error
        users_data = payload.get("users", [])
        standalone_keys_data = payload.get("standalone_keys", [])

        stats = {
            "users": {"created": 0, "updated": 0, "skipped": 0},
            "api_keys": {"created": 0, "skipped": 0},
            "standalone_keys": {"created": 0, "skipped": 0},
            "errors": [],
        }

        def _create_api_key_from_data(
            key_data: dict,
            owner_id: str,
            is_standalone: bool = False,
        ) -> tuple[ApiKey | None, str]:
            """从导入数据创建 ApiKey 对象

            Returns:
                (ApiKey, "created"): 成功创建
                (None, "skipped"): key 已存在，跳过
                (None, "invalid"): 数据无效，跳过
            """
            key_hash = key_data.get("key_hash", "").strip()
            if not key_hash:
                return None, "invalid"

            # 检查是否已存在
            existing = db.query(ApiKey).filter(ApiKey.key_hash == key_hash).first()
            if existing:
                return None, "skipped"

            # 解析 expires_at
            expires_at = None
            if key_data.get("expires_at"):
                try:
                    expires_at = datetime.fromisoformat(key_data["expires_at"])
                except ValueError:
                    stats["errors"].append(
                        f"API Key '{key_data.get('name', key_hash[:8])}' 的 expires_at 格式无效"
                    )

            return ApiKey(
                id=str(uuid.uuid4()),
                user_id=owner_id,
                key_hash=key_hash,
                key_encrypted=key_data.get("key_encrypted"),
                name=key_data.get("name"),
                is_standalone=is_standalone or key_data.get("is_standalone", False),
                balance_used_usd=key_data.get("balance_used_usd", 0.0),
                current_balance_usd=key_data.get("current_balance_usd"),
                allowed_providers=key_data.get("allowed_providers"),
                allowed_api_formats=key_data.get("allowed_api_formats"),
                allowed_models=key_data.get("allowed_models"),
                rate_limit=key_data.get("rate_limit"),
                concurrent_limit=key_data.get("concurrent_limit", 5),
                force_capabilities=key_data.get("force_capabilities"),
                is_active=key_data.get("is_active", True),
                expires_at=expires_at,
                auto_delete_on_expiry=key_data.get("auto_delete_on_expiry", False),
                total_requests=key_data.get("total_requests", 0),
                total_cost_usd=key_data.get("total_cost_usd", 0.0),
            ), "created"

        try:
            for user_data in users_data:
                # 跳过管理员角色的导入（不区分大小写）
                role_str = str(user_data.get("role", "")).lower()
                if role_str == "admin":
                    stats["errors"].append(f"跳过管理员用户: {user_data.get('email')}")
                    stats["users"]["skipped"] += 1
                    continue

                existing_user = (
                    db.query(User).filter(User.email == user_data["email"]).first()
                )

                if existing_user:
                    user_id = existing_user.id
                    if merge_mode == "skip":
                        stats["users"]["skipped"] += 1
                    elif merge_mode == "error":
                        raise InvalidRequestException(
                            f"用户 '{user_data['email']}' 已存在"
                        )
                    elif merge_mode == "overwrite":
                        # 更新现有用户
                        existing_user.username = user_data.get(
                            "username", existing_user.username
                        )
                        if user_data.get("password_hash"):
                            existing_user.password_hash = user_data["password_hash"]
                        if user_data.get("role"):
                            existing_user.role = UserRole(user_data["role"])
                        existing_user.allowed_providers = user_data.get("allowed_providers")
                        existing_user.allowed_api_formats = user_data.get("allowed_api_formats")
                        existing_user.allowed_models = user_data.get("allowed_models")
                        existing_user.model_capability_settings = user_data.get(
                            "model_capability_settings"
                        )
                        existing_user.quota_usd = user_data.get("quota_usd")
                        existing_user.used_usd = user_data.get("used_usd", 0.0)
                        existing_user.total_usd = user_data.get("total_usd", 0.0)
                        existing_user.is_active = user_data.get("is_active", True)
                        existing_user.updated_at = datetime.now(timezone.utc)
                        stats["users"]["updated"] += 1
                else:
                    # 创建新用户
                    role = UserRole.USER
                    if user_data.get("role"):
                        role = UserRole(user_data["role"])

                    new_user = User(
                        id=str(uuid.uuid4()),
                        email=user_data["email"],
                        username=user_data.get("username", user_data["email"].split("@")[0]),
                        password_hash=user_data.get("password_hash", ""),
                        role=role,
                        allowed_providers=user_data.get("allowed_providers"),
                        allowed_api_formats=user_data.get("allowed_api_formats"),
                        allowed_models=user_data.get("allowed_models"),
                        model_capability_settings=user_data.get("model_capability_settings"),
                        quota_usd=user_data.get("quota_usd"),
                        used_usd=user_data.get("used_usd", 0.0),
                        total_usd=user_data.get("total_usd", 0.0),
                        is_active=user_data.get("is_active", True),
                    )
                    db.add(new_user)
                    db.flush()
                    user_id = new_user.id
                    stats["users"]["created"] += 1

                # 导入 API Keys
                for key_data in user_data.get("api_keys", []):
                    new_key, status = _create_api_key_from_data(key_data, user_id)
                    if new_key:
                        db.add(new_key)
                        stats["api_keys"]["created"] += 1
                    elif status == "skipped":
                        stats["api_keys"]["skipped"] += 1
                    # invalid 数据不计入统计

            # 导入独立余额 Keys（需要找一个管理员用户作为 owner）
            if standalone_keys_data:
                # 查找一个管理员用户作为独立Key的owner
                admin_user = db.query(User).filter(User.role == UserRole.ADMIN).first()
                if not admin_user:
                    stats["errors"].append("无法导入独立余额Key: 系统中没有管理员用户")
                else:
                    for key_data in standalone_keys_data:
                        new_key, status = _create_api_key_from_data(
                            key_data, admin_user.id, is_standalone=True
                        )
                        if new_key:
                            db.add(new_key)
                            stats["standalone_keys"]["created"] += 1
                        elif status == "skipped":
                            stats["standalone_keys"]["skipped"] += 1
                        # invalid 数据不计入统计

            db.commit()

            return {
                "message": "用户数据导入成功",
                "stats": stats,
            }

        except InvalidRequestException:
            db.rollback()
            raise
        except Exception as e:
            db.rollback()
            raise InvalidRequestException(f"导入失败: {str(e)}")


class AdminTestSmtpAdapter(AdminApiAdapter):
    async def handle(self, context):  # type: ignore[override]
        """测试 SMTP 连接"""
        from src.core.crypto import crypto_service
        from src.services.system.config import SystemConfigService
        from src.services.email.email_sender import EmailSenderService

        db = context.db
        payload = context.ensure_json_body() or {}

        # 获取密码：优先使用前端传入的明文密码，否则从数据库获取并解密
        smtp_password = payload.get("smtp_password")
        if not smtp_password:
            encrypted_password = SystemConfigService.get_config(db, "smtp_password")
            if encrypted_password:
                try:
                    smtp_password = crypto_service.decrypt(encrypted_password, silent=True)
                except Exception:
                    # 解密失败，可能是旧的未加密密码
                    smtp_password = encrypted_password

        # 前端可传入未保存的配置，优先使用前端值，否则回退数据库
        config = {
            "smtp_host": payload.get("smtp_host") or SystemConfigService.get_config(db, "smtp_host"),
            "smtp_port": payload.get("smtp_port") or SystemConfigService.get_config(db, "smtp_port", default=587),
            "smtp_user": payload.get("smtp_user") or SystemConfigService.get_config(db, "smtp_user"),
            "smtp_password": smtp_password,
            "smtp_use_tls": payload.get("smtp_use_tls")
            if payload.get("smtp_use_tls") is not None
            else SystemConfigService.get_config(db, "smtp_use_tls", default=True),
            "smtp_use_ssl": payload.get("smtp_use_ssl")
            if payload.get("smtp_use_ssl") is not None
            else SystemConfigService.get_config(db, "smtp_use_ssl", default=False),
            "smtp_from_email": payload.get("smtp_from_email")
            or SystemConfigService.get_config(db, "smtp_from_email"),
            "smtp_from_name": payload.get("smtp_from_name")
            or SystemConfigService.get_config(db, "smtp_from_name", default="Aether"),
        }

        # 验证必要配置
        missing_fields = [
            field for field in ["smtp_host", "smtp_user", "smtp_password", "smtp_from_email"] if not config.get(field)
        ]
        if missing_fields:
            return {
                "success": False,
                "message": f"SMTP 配置不完整，请检查 {', '.join(missing_fields)}"
            }

        # 测试连接
        try:
            success, error_msg = await EmailSenderService.test_smtp_connection(
                db=db, override_config=config
            )

            if success:
                return {
                    "success": True,
                    "message": "SMTP 连接测试成功"
                }
            else:
                return {
                    "success": False,
                    "message": error_msg
                }
        except Exception as e:
            return {
                "success": False,
                "message": str(e)
            }


# -------- 邮件模板适配器 --------


class AdminGetEmailTemplatesAdapter(AdminApiAdapter):
    """获取所有邮件模板"""

    async def handle(self, context):  # type: ignore[override]
        db = context.db
        templates = []

        for template_type, type_info in EmailTemplate.TEMPLATE_TYPES.items():
            # 获取自定义模板或默认模板
            template = EmailTemplate.get_template(db, template_type)
            default_template = EmailTemplate.get_default_template(template_type)

            # 检查是否使用了自定义模板
            is_custom = (
                template["subject"] != default_template["subject"]
                or template["html"] != default_template["html"]
            )

            templates.append(
                {
                    "type": template_type,
                    "name": type_info["name"],
                    "variables": type_info["variables"],
                    "subject": template["subject"],
                    "html": template["html"],
                    "is_custom": is_custom,
                }
            )

        return {"templates": templates}


@dataclass
class AdminGetEmailTemplateAdapter(AdminApiAdapter):
    """获取指定类型的邮件模板"""

    template_type: str

    async def handle(self, context):  # type: ignore[override]
        # 验证模板类型
        if self.template_type not in EmailTemplate.TEMPLATE_TYPES:
            raise NotFoundException(f"模板类型 '{self.template_type}' 不存在")

        db = context.db
        type_info = EmailTemplate.TEMPLATE_TYPES[self.template_type]
        template = EmailTemplate.get_template(db, self.template_type)
        default_template = EmailTemplate.get_default_template(self.template_type)

        is_custom = (
            template["subject"] != default_template["subject"]
            or template["html"] != default_template["html"]
        )

        return {
            "type": self.template_type,
            "name": type_info["name"],
            "variables": type_info["variables"],
            "subject": template["subject"],
            "html": template["html"],
            "is_custom": is_custom,
            "default_subject": default_template["subject"],
            "default_html": default_template["html"],
        }


@dataclass
class AdminUpdateEmailTemplateAdapter(AdminApiAdapter):
    """更新邮件模板"""

    template_type: str

    async def handle(self, context):  # type: ignore[override]
        # 验证模板类型
        if self.template_type not in EmailTemplate.TEMPLATE_TYPES:
            raise NotFoundException(f"模板类型 '{self.template_type}' 不存在")

        db = context.db
        payload = context.ensure_json_body()

        subject = payload.get("subject")
        html = payload.get("html")

        # 至少需要提供一个字段
        if subject is None and html is None:
            raise InvalidRequestException("请提供 subject 或 html")

        # 保存模板
        subject_key = f"email_template_{self.template_type}_subject"
        html_key = f"email_template_{self.template_type}_html"

        if subject is not None:
            if subject:
                SystemConfigService.set_config(db, subject_key, subject)
            else:
                # 空字符串表示删除自定义值，恢复默认
                SystemConfigService.delete_config(db, subject_key)

        if html is not None:
            if html:
                SystemConfigService.set_config(db, html_key, html)
            else:
                SystemConfigService.delete_config(db, html_key)

        return {"message": "模板保存成功"}


@dataclass
class AdminPreviewEmailTemplateAdapter(AdminApiAdapter):
    """预览邮件模板"""

    template_type: str

    async def handle(self, context):  # type: ignore[override]
        # 验证模板类型
        if self.template_type not in EmailTemplate.TEMPLATE_TYPES:
            raise NotFoundException(f"模板类型 '{self.template_type}' 不存在")

        db = context.db
        payload = context.ensure_json_body() or {}

        # 获取模板 HTML（优先使用请求体中的，否则使用数据库中的）
        html = payload.get("html")
        if not html:
            template = EmailTemplate.get_template(db, self.template_type)
            html = template["html"]

        # 获取预览变量
        type_info = EmailTemplate.TEMPLATE_TYPES[self.template_type]

        # 构建预览变量，使用请求中的值或默认示例值
        preview_variables = {}
        default_values = {
            "app_name": SystemConfigService.get_config(db, "email_app_name")
            or SystemConfigService.get_config(db, "smtp_from_name", default="Aether"),
            "code": "123456",
            "expire_minutes": "30",
            "email": "example@example.com",
            "reset_link": "https://example.com/reset?token=abc123",
        }

        for var in type_info["variables"]:
            preview_variables[var] = payload.get(var, default_values.get(var, f"{{{{{var}}}}}"))

        # 渲染模板
        rendered_html = EmailTemplate.render_template(html, preview_variables)

        return {
            "html": rendered_html,
            "variables": preview_variables,
        }


@dataclass
class AdminResetEmailTemplateAdapter(AdminApiAdapter):
    """重置邮件模板为默认值"""

    template_type: str

    async def handle(self, context):  # type: ignore[override]
        # 验证模板类型
        if self.template_type not in EmailTemplate.TEMPLATE_TYPES:
            raise NotFoundException(f"模板类型 '{self.template_type}' 不存在")

        db = context.db

        # 删除自定义模板
        subject_key = f"email_template_{self.template_type}_subject"
        html_key = f"email_template_{self.template_type}_html"

        SystemConfigService.delete_config(db, subject_key)
        SystemConfigService.delete_config(db, html_key)

        # 返回默认模板
        default_template = EmailTemplate.get_default_template(self.template_type)
        type_info = EmailTemplate.TEMPLATE_TYPES[self.template_type]

        return {
            "message": "模板已重置为默认值",
            "template": {
                "type": self.template_type,
                "name": type_info["name"],
                "subject": default_template["subject"],
                "html": default_template["html"],
            },
        }