"""
会员订阅体系管理 API（管理员）— 增强版：权益细化与权限挂钩
"""
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from sqlalchemy import text
from ...database import get_db, SessionLocal
from ...models import MembershipPlan, MembershipSubscription, User, RiskRule
from ...auth import get_current_admin
from ...middleware.log_service import LogService
import uuid
import json
from datetime import datetime, date

router = APIRouter()


def _format_plan(p):
    """格式化会员计划数据"""
    return {
        "id": p.id,
        "name": p.name,
        "level": p.level,
        "duration_type": p.duration_type,
        "price": float(p.price) if p.price else 0,
        "daily_free_tokens": p.daily_free_tokens or 0,
        "features": p.features or [],
        "free_app_ids": p.free_app_ids or [],
        "free_model_ids": p.free_model_ids or [],
        "is_active": p.is_active,
        # 配额字段
        "max_agents": getattr(p, 'max_agents', 5) or 5,
        "max_workflows": getattr(p, 'max_workflows', 3) or 3,
        "max_knowledge_bases": getattr(p, 'max_knowledge_bases', 2) or 2,
        "max_storage_mb": getattr(p, 'max_storage_mb', 1024) or 1024,
        "api_calls_per_day": getattr(p, 'api_calls_per_day', 100) or 100,
        "api_calls_per_min": getattr(p, 'api_calls_per_min', 10) or 10,
        # 权限字段
        "can_publish_apps": bool(getattr(p, 'can_publish_apps', 0)),
        "can_create_api_keys": bool(getattr(p, 'can_create_api_keys', 0)),
        "can_use_workflow": bool(getattr(p, 'can_use_workflow', 0)),
        "can_use_mcp": bool(getattr(p, 'can_use_mcp', 0)),
        "can_use_code_exec": bool(getattr(p, 'can_use_code_exec', 0)),
        "can_use_privacy_mode": bool(getattr(p, 'can_use_privacy_mode', 0)),
        "can_use_dag": bool(getattr(p, 'can_use_dag', 0)),
        "allowed_model_tiers": getattr(p, 'allowed_model_tiers', None) or ["free"],
        "permissions": getattr(p, 'permissions', None) or {},
        "created_at": p.created_at.isoformat() if p.created_at else None,
        "updated_at": p.updated_at.isoformat() if p.updated_at else None,
    }


# ============================================================
# 会员计划 CRUD
# ============================================================

@router.get("/plans")
async def get_plans(
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """获取会员计划列表（含权益配置）"""
    plans = db.query(MembershipPlan).order_by(MembershipPlan.level).all()
    return [_format_plan(p) for p in plans]


@router.post("/plans")
async def create_plan(
    name: str,
    level: int,
    duration_type: str,
    price: float,
    daily_free_tokens: int = 0,
    features: list = None,
    free_app_ids: list = None,
    free_model_ids: list = None,
    # 配额参数
    max_agents: int = 5,
    max_workflows: int = 3,
    max_knowledge_bases: int = 2,
    max_storage_mb: int = 1024,
    api_calls_per_day: int = 100,
    api_calls_per_min: int = 10,
    # 权限参数
    can_publish_apps: bool = False,
    can_create_api_keys: bool = False,
    can_use_workflow: bool = False,
    can_use_mcp: bool = False,
    can_use_code_exec: bool = False,
    can_use_privacy_mode: bool = False,
    can_use_dag: bool = False,
    allowed_model_tiers: list = None,
    permissions: dict = None,
    is_active: bool = True,
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """创建会员计划（含权益配置）"""
    plan = MembershipPlan(
        id=str(uuid.uuid4()),
        name=name,
        level=level,
        duration_type=duration_type,
        price=price,
        daily_free_tokens=daily_free_tokens,
        features=features,
        free_app_ids=free_app_ids,
        free_model_ids=free_model_ids,
        is_active=is_active,
    )
    # 设置配额字段
    plan.max_agents = max_agents
    plan.max_workflows = max_workflows
    plan.max_knowledge_bases = max_knowledge_bases
    plan.max_storage_mb = max_storage_mb
    plan.api_calls_per_day = api_calls_per_day
    plan.api_calls_per_min = api_calls_per_min
    # 设置权限字段
    plan.can_publish_apps = can_publish_apps
    plan.can_create_api_keys = can_create_api_keys
    plan.can_use_workflow = can_use_workflow
    plan.can_use_mcp = can_use_mcp
    plan.can_use_code_exec = can_use_code_exec
    plan.can_use_privacy_mode = can_use_privacy_mode
    plan.can_use_dag = can_use_dag
    plan.allowed_model_tiers = allowed_model_tiers or ["free"]
    plan.permissions = permissions or {}

    db.add(plan)
    db.commit()

    LogService.log_audit(
        admin_id=admin_user.id,
        admin_name=admin_user.username,
        action="create_membership_plan",
        target_type="membership_plan",
        target_id=plan.id,
        detail=f"创建会员计划 {name} (level={level})",
    )

    return {"message": "会员计划已创建", "id": plan.id}


@router.put("/plans/{id}")
async def update_plan(
    id: str,
    name: str = None,
    level: int = None,
    duration_type: str = None,
    price: float = None,
    daily_free_tokens: int = None,
    features: list = None,
    free_app_ids: list = None,
    free_model_ids: list = None,
    # 配额参数
    max_agents: int = None,
    max_workflows: int = None,
    max_knowledge_bases: int = None,
    max_storage_mb: int = None,
    api_calls_per_day: int = None,
    api_calls_per_min: int = None,
    # 权限参数
    can_publish_apps: bool = None,
    can_create_api_keys: bool = None,
    can_use_workflow: bool = None,
    can_use_mcp: bool = None,
    can_use_code_exec: bool = None,
    can_use_privacy_mode: bool = None,
    can_use_dag: bool = None,
    allowed_model_tiers: list = None,
    permissions: dict = None,
    is_active: bool = None,
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """更新会员计划（含权益配置）"""
    plan = db.query(MembershipPlan).filter(MembershipPlan.id == id).first()
    if not plan:
        raise HTTPException(status_code=404, detail="会员计划不存在")

    # 基础字段
    if name is not None:
        plan.name = name
    if level is not None:
        plan.level = level
    if duration_type is not None:
        plan.duration_type = duration_type
    if price is not None:
        plan.price = price
    if daily_free_tokens is not None:
        plan.daily_free_tokens = daily_free_tokens
    if features is not None:
        plan.features = features
    if free_app_ids is not None:
        plan.free_app_ids = free_app_ids
    if free_model_ids is not None:
        plan.free_model_ids = free_model_ids
    if is_active is not None:
        plan.is_active = is_active

    # 配额字段
    if max_agents is not None:
        plan.max_agents = max_agents
    if max_workflows is not None:
        plan.max_workflows = max_workflows
    if max_knowledge_bases is not None:
        plan.max_knowledge_bases = max_knowledge_bases
    if max_storage_mb is not None:
        plan.max_storage_mb = max_storage_mb
    if api_calls_per_day is not None:
        plan.api_calls_per_day = api_calls_per_day
    if api_calls_per_min is not None:
        plan.api_calls_per_min = api_calls_per_min

    # 权限字段
    if can_publish_apps is not None:
        plan.can_publish_apps = can_publish_apps
    if can_create_api_keys is not None:
        plan.can_create_api_keys = can_create_api_keys
    if can_use_workflow is not None:
        plan.can_use_workflow = can_use_workflow
    if can_use_mcp is not None:
        plan.can_use_mcp = can_use_mcp
    if can_use_code_exec is not None:
        plan.can_use_code_exec = can_use_code_exec
    if can_use_privacy_mode is not None:
        plan.can_use_privacy_mode = can_use_privacy_mode
    if can_use_dag is not None:
        plan.can_use_dag = can_use_dag
    if allowed_model_tiers is not None:
        plan.allowed_model_tiers = allowed_model_tiers
    if permissions is not None:
        plan.permissions = permissions

    plan.updated_at = datetime.now()
    db.commit()

    LogService.log_audit(
        admin_id=admin_user.id,
        admin_name=admin_user.username,
        action="update_membership_plan",
        target_type="membership_plan",
        target_id=id,
        detail=f"更新会员计划 {plan.name} (含权益配置)",
    )

    return {"message": "会员计划已更新"}


@router.delete("/plans/{id}")
async def delete_plan(
    id: str,
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """删除会员计划"""
    plan = db.query(MembershipPlan).filter(MembershipPlan.id == id).first()
    if not plan:
        raise HTTPException(status_code=404, detail="会员计划不存在")

    # 检查是否有用户正在使用此计划
    user_count = db.query(User).filter(User.membership_plan_id == id).count()
    if user_count > 0:
        raise HTTPException(status_code=400, detail=f"有 {user_count} 个用户正在使用此计划，无法删除")

    db.delete(plan)
    db.commit()

    LogService.log_audit(
        admin_id=admin_user.id,
        admin_name=admin_user.username,
        action="delete_membership_plan",
        target_type="membership_plan",
        target_id=id,
        detail=f"删除会员计划 {plan.name}",
    )

    return {"message": "会员计划已删除"}


# ============================================================
# 会员权益对比（前端对比表用）
# ============================================================

@router.get("/benefits-comparison")
async def get_benefits_comparison(
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """获取会员权益对比表数据"""
    plans = db.query(MembershipPlan).filter(
        MembershipPlan.is_active == True
    ).order_by(MembershipPlan.level).all()

    # 定义对比维度
    dimensions = [
        {"key": "daily_free_tokens", "label": "每日免费Token", "type": "number"},
        {"key": "max_agents", "label": "最大Agent数量", "type": "number"},
        {"key": "max_workflows", "label": "最大工作流数量", "type": "number"},
        {"key": "max_knowledge_bases", "label": "最大知识库数量", "type": "number"},
        {"key": "max_storage_mb", "label": "存储配额(MB)", "type": "number"},
        {"key": "api_calls_per_day", "label": "每日API调用限额", "type": "number"},
        {"key": "api_calls_per_min", "label": "每分钟API调用限额", "type": "number"},
        {"key": "can_publish_apps", "label": "发布应用到市场", "type": "boolean"},
        {"key": "can_create_api_keys", "label": "创建开发者API密钥", "type": "boolean"},
        {"key": "can_use_workflow", "label": "使用工作流编排", "type": "boolean"},
        {"key": "can_use_mcp", "label": "使用MCP工具", "type": "boolean"},
        {"key": "can_use_code_exec", "label": "使用代码执行", "type": "boolean"},
        {"key": "can_use_privacy_mode", "label": "使用隐私模式", "type": "boolean"},
        {"key": "can_use_dag", "label": "使用DAG多Agent", "type": "boolean"},
        {"key": "allowed_model_tiers", "label": "可用模型层级", "type": "list"},
    ]

    return {
        "dimensions": dimensions,
        "plans": [_format_plan(p) for p in plans],
    }


# ============================================================
# 全局会员配置管理
# ============================================================

@router.get("/global-configs")
async def get_global_configs(
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """获取全局会员配置"""
    result = db.execute(text("SELECT id, config_key, config_value, config_type, description FROM membership_global_configs ORDER BY config_key"))
    configs = []
    for row in result:
        val = row[2]
        if row[3] == 'boolean':
            val = val == 'true'
        elif row[3] == 'number':
            try:
                val = int(val)
            except:
                val = 0
        elif row[3] == 'json':
            try:
                val = json.loads(val)
            except:
                pass
        configs.append({
            "id": row[0],
            "key": row[1],
            "value": val,
            "type": row[3],
            "description": row[4] or "",
        })
    return configs


@router.put("/global-configs/{key}")
async def update_global_config(
    key: str,
    value: str = None,
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """更新全局会员配置"""
    result = db.execute(text("SELECT id, config_type FROM membership_global_configs WHERE config_key = :key"), {"key": key})
    row = result.fetchone()
    if not row:
        raise HTTPException(status_code=404, detail="配置项不存在")

    config_id, config_type = row[0], row[1]
    store_value = value
    if config_type == 'boolean':
        store_value = 'true' if value in ('true', '1', 'True') else 'false'

    db.execute(text("UPDATE membership_global_configs SET config_value = :val WHERE id = :id"), {"val": store_value, "id": config_id})
    db.commit()

    LogService.log_audit(
        admin_id=admin_user.id,
        admin_name=admin_user.username,
        action="update_membership_config",
        target_type="membership_config",
        target_id=config_id,
        detail=f"更新会员配置 {key}={store_value}",
    )

    return {"message": "配置已更新"}


# ============================================================
# 用户会员管理
# ============================================================

@router.get("/user-memberships")
async def get_user_memberships(
    user_id: str = Query(None),
    plan_id: str = Query(None),
    status: str = Query(None, description="会员状态: active/expired"),
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """获取用户会员信息列表"""
    query = db.query(User).filter(User.role == 'user')

    if user_id:
        query = query.filter(User.id == user_id)

    users_q = query
    if plan_id:
        users_q = users_q.filter(User.membership_plan_id == plan_id)

    total = users_q.count()
    users = users_q.order_by(User.created_at.desc()).offset((page - 1) * page_size).limit(page_size).all()

    items = []
    for u in users:
        plan = db.query(MembershipPlan).filter(MembershipPlan.id == u.membership_plan_id).first() if u.membership_plan_id else None
        # 判断状态
        now = datetime.now()
        if u.membership_expire_at and u.membership_expire_at < now:
            member_status = "expired"
        elif u.membership_level > 0:
            member_status = "active"
        else:
            member_status = "free"

        if status and member_status != status:
            continue

        items.append({
            "user_id": u.id,
            "username": u.username,
            "email": u.email,
            "membership_plan_id": u.membership_plan_id,
            "membership_plan_name": plan.name if plan else "免费版",
            "membership_level": u.membership_level or 0,
            "membership_expire_at": u.membership_expire_at.isoformat() if u.membership_expire_at else None,
            "auto_renew": bool(u.auto_renew),
            "member_status": member_status,
            "created_at": u.created_at.isoformat() if u.created_at else None,
        })

    return {"total": total, "page": page, "page_size": page_size, "items": items}


@router.put("/users/{user_id}/assign-plan")
async def assign_plan_to_user(
    user_id: str,
    plan_id: str,
    duration_days: int = Query(30, description="订阅时长(天)"),
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """为用户分配会员计划（管理员手动分配）"""
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")

    plan = db.query(MembershipPlan).filter(MembershipPlan.id == plan_id).first()
    if not plan:
        raise HTTPException(status_code=404, detail="会员计划不存在")

    from datetime import timedelta
    now = datetime.now()
    # 如果用户当前会员未到期，从到期时间续期
    start_at = now
    if user.membership_expire_at and user.membership_expire_at > now:
        start_at = user.membership_expire_at
    end_at = start_at + timedelta(days=duration_days)

    user.membership_plan_id = plan_id
    user.membership_level = plan.level
    user.membership_expire_at = end_at

    # 创建订阅记录
    sub = MembershipSubscription(
        id=str(uuid.uuid4()),
        user_id=user_id,
        plan_id=plan_id,
        start_at=start_at,
        end_at=end_at,
        status="active",
    )
    db.add(sub)
    db.commit()

    LogService.log_audit(
        admin_id=admin_user.id,
        admin_name=admin_user.username,
        action="assign_membership_plan",
        target_type="user",
        target_id=user_id,
        detail=f"为用户 {user.username} 分配计划 {plan.name} ({duration_days}天)",
    )

    return {"message": f"已为用户 {user.username} 分配 {plan.name} 计划", "expire_at": end_at.isoformat()}


@router.put("/users/{user_id}/revoke")
async def revoke_membership(
    user_id: str,
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """撤销用户会员（降级为免费版）"""
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")

    old_plan = user.membership_plan_id
    user.membership_plan_id = None
    user.membership_level = 0
    user.membership_expire_at = None
    user.auto_renew = False
    db.commit()

    LogService.log_audit(
        admin_id=admin_user.id,
        admin_name=admin_user.username,
        action="revoke_membership",
        target_type="user",
        target_id=user_id,
        detail=f"撤销用户 {user.username} 的会员 (原计划ID: {old_plan})",
    )

    return {"message": f"已撤销用户 {user.username} 的会员"}


# ============================================================
# 用户配额使用情况
# ============================================================

@router.get("/users/{user_id}/usage")
async def get_user_usage(
    user_id: str,
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """获取用户资源使用情况"""
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")

    # 获取用户计划
    plan = None
    if user.membership_plan_id:
        plan = db.query(MembershipPlan).filter(MembershipPlan.id == user.membership_plan_id).first()

    # 统计用户实际资源使用
    from ...models import Agent, KnowledgeBase
    agents_count = db.query(Agent).filter(Agent.owner_id == user_id).count() if hasattr(Agent, 'owner_id') else 0

    # 使用原生SQL统计
    try:
        kb_result = db.execute(text("SELECT COUNT(*) FROM knowledge_bases WHERE owner_id = :uid"), {"uid": user_id})
        kb_count = kb_result.fetchone()[0]
    except:
        kb_count = 0

    try:
        agent_result = db.execute(text("SELECT COUNT(*) FROM agents WHERE owner_id = :uid"), {"uid": user_id})
        agent_count = agent_result.fetchone()[0]
    except:
        agent_count = 0

    try:
        wf_result = db.execute(text("SELECT COUNT(*) FROM workflows WHERE owner_id = :uid"), {"uid": user_id})
        wf_count = wf_result.fetchone()[0]
    except:
        wf_count = 0

    # 获取今日API使用量
    today = date.today()
    try:
        usage_result = db.execute(text("SELECT api_calls_total, tokens_used FROM user_api_usage WHERE user_id = :uid AND usage_date = :d"), {"uid": user_id, "d": today})
        usage_row = usage_result.fetchone()
        api_calls_today = usage_row[0] if usage_row else 0
        tokens_today = usage_row[1] if usage_row else 0
    except:
        api_calls_today = 0
        tokens_today = 0

    # 获取存储使用量
    try:
        storage_result = db.execute(text("SELECT storage_used_mb FROM user_resource_usage WHERE user_id = :uid"), {"uid": user_id})
        storage_row = storage_result.fetchone()
        storage_used = float(storage_row[0]) if storage_row else 0.0
    except:
        storage_used = 0.0

    plan_limits = {}
    if plan:
        plan_limits = {
            "max_agents": getattr(plan, 'max_agents', 5) or 5,
            "max_workflows": getattr(plan, 'max_workflows', 3) or 3,
            "max_knowledge_bases": getattr(plan, 'max_knowledge_bases', 2) or 2,
            "max_storage_mb": getattr(plan, 'max_storage_mb', 1024) or 1024,
            "api_calls_per_day": getattr(plan, 'api_calls_per_day', 100) or 100,
            "daily_free_tokens": plan.daily_free_tokens or 0,
        }

    return {
        "user_id": user_id,
        "username": user.username,
        "plan_name": plan.name if plan else "免费版",
        "plan_level": user.membership_level or 0,
        "usage": {
            "agents_count": agent_count,
            "workflows_count": wf_count,
            "knowledge_bases_count": kb_count,
            "storage_used_mb": storage_used,
            "api_calls_today": api_calls_today,
            "tokens_today": tokens_today,
        },
        "limits": plan_limits,
        "over_limit": {
            "agents": agent_count > plan_limits.get("max_agents", 999) if plan_limits else False,
            "workflows": wf_count > plan_limits.get("max_workflows", 999) if plan_limits else False,
            "knowledge_bases": kb_count > plan_limits.get("max_knowledge_bases", 999) if plan_limits else False,
            "storage": storage_used > plan_limits.get("max_storage_mb", 999999) if plan_limits else False,
            "api_calls": api_calls_today > plan_limits.get("api_calls_per_day", 999999) if plan_limits else False,
        },
    }


# ============================================================
# 用户订阅管理
# ============================================================

@router.get("/subscriptions")
async def get_subscriptions(
    user_id: str = Query(None),
    status: str = Query(None, description="订阅状态: active/expired/downgraded"),
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """获取所有用户订阅列表"""
    query = db.query(MembershipSubscription)

    if user_id:
        query = query.filter(MembershipSubscription.user_id == user_id)
    if status:
        query = query.filter(MembershipSubscription.status == status)

    total = query.count()
    subscriptions = query.order_by(
        MembershipSubscription.created_at.desc()
    ).offset((page - 1) * page_size).limit(page_size).all()

    # 关联用户名和计划名
    items = []
    for s in subscriptions:
        u = db.query(User).filter(User.id == s.user_id).first()
        p = db.query(MembershipPlan).filter(MembershipPlan.id == s.plan_id).first()
        items.append({
            "id": s.id,
            "user_id": s.user_id,
            "username": u.username if u else "",
            "plan_id": s.plan_id,
            "plan_name": p.name if p else "",
            "order_id": s.order_id,
            "start_at": s.start_at.isoformat() if s.start_at else None,
            "end_at": s.end_at.isoformat() if s.end_at else None,
            "auto_renew": s.auto_renew,
            "status": s.status,
            "created_at": s.created_at.isoformat() if s.created_at else None,
        })

    return {
        "total": total,
        "page": page,
        "page_size": page_size,
        "items": items,
    }


# ============================================================
# 会员统计概览
# ============================================================

@router.get("/stats")
async def get_membership_stats(
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """获取会员统计概览"""
    total_users = db.query(User).filter(User.role == 'user').count()

    # 各等级用户数
    level_stats = {}
    for level in range(4):
        count = db.query(User).filter(User.membership_level == level).count()
        level_stats[f"level_{level}"] = count

    # 活跃会员（未到期）
    now = datetime.now()
    active_members = db.query(User).filter(
        User.membership_level > 0,
        User.membership_expire_at > now
    ).count()

    # 已过期会员
    expired_members = db.query(User).filter(
        User.membership_level > 0,
        User.membership_expire_at <= now
    ).count()

    # 自动续费用户数
    auto_renew_count = db.query(User).filter(
        User.auto_renew == True,
        User.membership_level > 0
    ).count()

    # 各计划订阅数
    plan_stats = []
    plans = db.query(MembershipPlan).order_by(MembershipPlan.level).all()
    for plan in plans:
        count = db.query(User).filter(User.membership_plan_id == plan.id).count()
        plan_stats.append({
            "plan_id": plan.id,
            "plan_name": plan.name,
            "level": plan.level,
            "user_count": count,
            "is_active": plan.is_active,
        })

    # 今日新增订阅
    today_start = datetime(now.year, now.month, now.day)
    today_new_subs = db.query(MembershipSubscription).filter(
        MembershipSubscription.created_at >= today_start
    ).count()

    return {
        "total_users": total_users,
        "active_members": active_members,
        "expired_members": expired_members,
        "free_users": level_stats.get("level_0", 0),
        "auto_renew_count": auto_renew_count,
        "level_stats": level_stats,
        "plan_stats": plan_stats,
        "today_new_subs": today_new_subs,
    }


# ============================================================
# 自动化规则（风控）
# ============================================================

@router.get("/automation-rules")
async def get_automation_rules(
    admin_user=Depends(get_current_admin),
    db: Session = Depends(get_db),
):
    """获取自动化规则配置"""
    rules = db.query(RiskRule).order_by(RiskRule.created_at.desc()).all()

    if not rules:
        return {
            "rules": [],
            "defaults": {
                "max_login_attempts": 5,
                "token_usage_threshold_per_hour": 1000000,
                "token_usage_threshold_per_day": 10000000,
                "concurrent_sessions_limit": 5,
            },
        }

    return {
        "rules": [
            {
                "id": r.id,
                "name": r.name,
                "type": r.type,
                "threshold": r.threshold,
                "duration": r.duration,
                "is_enabled": r.is_enabled,
                "created_at": r.created_at.isoformat() if r.created_at else None,
                "updated_at": r.updated_at.isoformat() if r.updated_at else None,
            }
            for r in rules
        ],
        "defaults": {
            "max_login_attempts": 5,
            "token_usage_threshold_per_hour": 1000000,
            "token_usage_threshold_per_day": 10000000,
            "concurrent_sessions_limit": 5,
        },
    }