class ErrorRuleDetector {
  private regexPatterns: RegexPattern[] = [];      // 正则匹配（最灵活）
  private containsPatterns: ContainsPattern[] = []; // 包含匹配
  private exactPatterns: Map<string, ExactPattern> = new Map(); // 精确匹配
}

const DEFAULT_ERROR_RULES = [
  {
    pattern: "prompt is too long.*(tokens.*maximum|maximum.*tokens)",
    category: "prompt_limit",
    matchType: "regex",
    priority: 100,
    overrideResponse: {
      type: "error",
      error: {
        type: "prompt_limit",
        message: "输入内容过长，请减少 Prompt 中的 token 数量后重试",
      },
    },
  },
];

export async function getOverviewMetrics(): Promise<OverviewMetrics> {
  const timezone = await resolveSystemTimezone();

  const [result] = await db
    .select({
      requestCount: count(),
      totalCost: sum(messageRequest.costUsd),
      avgDuration: avg(messageRequest.durationMs),
      errorCount: sql<number>`count(*) FILTER (WHERE ${messageRequest.statusCode} >= 400)`,
    })
    .from(messageRequest)
    .where(
      and(
        isNull(messageRequest.deletedAt),
        EXCLUDE_WARMUP_CONDITION,
        sql`(${messageRequest.createdAt} AT TIME ZONE ${timezone})::date = 
            (CURRENT_TIMESTAMP AT TIME ZONE ${timezone})::date`
      )
    );

  const requestCount = Number(result.requestCount || 0);
  const errorCount = Number(result.errorCount || 0);
  const todayErrorRate =
    requestCount > 0 ? parseFloat(((errorCount / requestCount) * 100).toFixed(2)) : 0;

  return {
    todayRequests: requestCount,
    todayCost,
    avgResponseTime,
    todayErrorRate,
  };
}

错误率 = (状态码 >= 400 的请求数 / 总请求数) × 100%

export async function getRateLimitEventStats(
  filters: RateLimitEventFilters = {}
): Promise<RateLimitEventStats> {
  const conditions: string[] = [
    `${messageRequest.errorMessage.name} LIKE '%rate_limit_metadata%'`,
    `${messageRequest.deletedAt.name} IS NULL`,
  ];

  // 按类型、用户、供应商、小时聚合
  const eventsByType: Record<string, number> = {};
  const eventsByUser: Record<number, number> = {};
  const eventsByProvider: Record<number, number> = {};
  const eventsByHour: Record<string, number> = {};

  // 解析 rate_limit_metadata JSON 进行统计
  for (const row of rows) {
    const metadataMatch = row.error_message.match(/rate_limit_metadata:\s*(\{[^}]+\})/);
    if (!metadataMatch) continue;
    const metadata = JSON.parse(metadataMatch[1]);
    // 按维度统计...
  }
}

CREATE TABLE message_request (
  id SERIAL PRIMARY KEY,
  user_id INTEGER NOT NULL,
  provider_id INTEGER NOT NULL,
  key VARCHAR NOT NULL,
  model VARCHAR(128),
  duration_ms INTEGER,
  cost_usd NUMERIC(21, 15) DEFAULT '0',
  status_code INTEGER,              -- HTTP 状态码，>=400 表示错误
  error_message TEXT,               -- 错误消息
  error_stack TEXT,                 -- 错误堆栈
  error_cause TEXT,                 -- 错误原因
  blocked_by VARCHAR(50),           -- 拦截原因（如 warmup）
  blocked_reason TEXT,              -- 拦截详细原因
  provider_chain JSONB,             -- 供应商选择决策链
  created_at TIMESTAMPTZ DEFAULT NOW(),
  deleted_at TIMESTAMPTZ            -- 软删除标记
);

CREATE TABLE error_rules (
  id SERIAL PRIMARY KEY,
  pattern TEXT NOT NULL UNIQUE,     -- 匹配模式
  match_type VARCHAR(20) NOT NULL DEFAULT 'regex',  -- 匹配类型
  category VARCHAR(50) NOT NULL,    -- 错误类别
  description TEXT,                 -- 描述
  override_response JSONB,          -- 覆写响应
  override_status_code INTEGER,     -- 覆写状态码
  is_enabled BOOLEAN DEFAULT true,  -- 是否启用
  is_default BOOLEAN DEFAULT false, -- 是否默认规则
  priority INTEGER DEFAULT 0,       -- 优先级
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);

export const EXCLUDE_WARMUP_CONDITION = sql`(
  ${messageRequest.blockedBy} IS NULL OR 
  ${messageRequest.blockedBy} <> 'warmup'
)`;

export function isClientAbortError(error: Error): boolean {
  // 检查错误名称
  if (error.name === "AbortError" || error.name === "ResponseAborted") {
    return true;
  }

  // 检查 HTTP 状态码（Nginx 使用的 "Client Closed Request"）
  if (error instanceof ProxyError && error.statusCode === 499) {
    return true;
  }

  // 检查错误消息
  const abortMessages = [
    "This operation was aborted",
    "The user aborted a request",
    "aborted",
  ];

  return abortMessages.some((msg) => error.message.includes(msg));
}

const errorDetectionCache = new WeakMap<Error, ErrorDetectionResult>();

async function detectErrorRuleOnceAsync(error: Error): Promise<ErrorDetectionResult> {
  const cached = errorDetectionCache.get(error);
  if (cached) {
    return cached;
  }

  const content = extractErrorContentForDetection(error);
  const result = await errorRuleDetector.detectAsync(content);
  errorDetectionCache.set(error, result);
  return result;
}

import safeRegex from "safe-regex";

if (!safeRegex(rule.pattern)) {
  logger.warn(
    `[ErrorRuleDetector] ReDoS risk detected in pattern: ${rule.pattern}, skipping`
  );
  skippedRedosCount++;
  break;
}

// src/repository/overview.ts
export async function getOverviewMetrics(): Promise<OverviewMetrics>
export async function getOverviewMetricsWithComparison(userId?: number): Promise<OverviewMetricsWithComparison>

// src/actions/rate-limit-stats.ts
export async function getRateLimitStats(
  filters: RateLimitEventFilters = {}
): Promise<ActionResult<RateLimitEventStats>>

// src/repository/usage-logs.ts
export async function findUsageLogsStats(
  filters: Omit<UsageLogFilters, "page" | "pageSize">
): Promise<UsageLogSummary>