/**
 * 日志系统 API 服务
 * 模块: logging
 * 
 * 基于文档: docs/modules/logging-system/07-api.md
 * 
 * 说明: 日志系统分为 Data Plane 和 Control Plane
 * - Data Plane: HTTP Header 规范（X-Trace-Id 等），由框架自动处理
 * - Control Plane: /api/v1/logs/* API，面向内部管理后台
 */
import apiClient, { PaginatedData, ApiClientError } from '@/lib/api-client';

// ==================== 枚举类型 ====================

/**
 * 日志级别
 */
export enum LogLevel {
  ERROR = 'ERROR',
  WARN = 'WARN',
  INFO = 'INFO',
  DEBUG = 'DEBUG',
}

/**
 * 服务类型（推荐枚举，可扩展）
 */
export type LogService = 
  // 核心服务
  | 'IAM'           // 身份认证服务
  | 'Form'          // 表单引擎
  | 'Approval'      // 审批引擎
  | 'Inventory'     // 库存管理
  // 业务服务
  | 'HR'            // 人事管理
  | 'Finance'       // 财务管理
  | 'Report'        // 报表服务
  | 'Notification'  // 通知服务
  // 基础设施
  | 'Gateway'       // API 网关
  | 'Scheduler'     // 定时任务
  | 'FileStorage'   // 文件存储
  | 'Temporal'      // 工作流引擎
  | string;         // 允许自定义服务名

/**
 * 告警类型
 */
export enum AlertType {
  SLOW_REQUEST = 'SLOW_REQUEST',
  HIGH_ERROR_RATE = 'HIGH_ERROR_RATE',
  DISK_SPACE = 'DISK_SPACE',
  IP_ANOMALY = 'IP_ANOMALY',
}

/**
 * 告警状态
 */
export enum AlertStatus {
  SENT = 'SENT',
  FAILED = 'FAILED',
  ACKNOWLEDGED = 'ACKNOWLEDGED',
}

/**
 * 告警严重级别
 */
export enum AlertSeverity {
  CRITICAL = 'CRITICAL',
  WARNING = 'WARNING',
  INFO = 'INFO',
}

// ==================== 接口类型 ====================

/**
 * 追踪信息
 */
export interface TraceInfo {
  id: string;             // traceId
  span_id: string;        // spanId
  parent_span_id?: string;
}

/**
 * HTTP 信息
 */
export interface HttpInfo {
  request_id: string;
  method: string;
  url: string;
  status_code: number;
  duration_ms: number;
}

/**
 * 用户信息
 */
export interface UserInfo {
  id: string;
  name: string;
}

/**
 * 客户端信息
 */
export interface ClientInfo {
  ip: string;
  user_agent: string;
  geo?: {
    country: string;
    city: string;
  };
}

/**
 * 服务信息
 */
export interface ServiceInfo {
  name: string;
  region: string;
  instance: string;
  version?: string;
}

/**
 * 错误信息
 */
export interface ErrorInfo {
  type: string;
  message: string;
  code?: string;
  stack?: string;  // 仅开发环境
  details?: Record<string, unknown>;
}

/**
 * 日志项
 */
export interface LogItem {
  '@timestamp': string;     // ISO 8601
  level: LogLevel;
  message: string;
  trace: TraceInfo;
  http: HttpInfo;
  user?: UserInfo;
  client: ClientInfo;
  service: ServiceInfo;
  error?: ErrorInfo;
}

/**
 * Span 信息（链路追踪）
 */
export interface SpanInfo {
  spanId: string;
  parentSpanId: string | null;
  service: string;
  region: string;
  operation: string;
  startTime: string;
  duration: number;
  status: 'SUCCESS' | 'ERROR';
}

/**
 * 时间线事件
 */
export interface TimelineEvent {
  time: number;  // 相对于 trace 开始时间的偏移（ms）
  event: string;
}

/**
 * 追踪响应
 */
export interface TraceResponse {
  traceId: string;
  startTime: string;
  endTime: string;
  totalDuration: number;
  spans: SpanInfo[];
  timeline: TimelineEvent[];
}

/**
 * 错误日志项
 */
export interface ErrorLogItem extends LogItem {
  error: ErrorInfo;
}

/**
 * 错误日志响应
 */
export interface ErrorLogListResponse extends PaginatedData<ErrorLogItem> {
  summary: {
    total: number;
    byType: Record<string, number>;
    byHour: { hour: string; count: number }[];
  };
}

/**
 * 慢请求项
 */
export interface SlowRequestItem {
  timestamp: string;
  traceId: string;
  requestId: string;
  method: string;
  url: string;
  duration: number;
  user?: UserInfo;
  service: string;
  region: string;
}

/**
 * 慢请求响应
 */
export interface SlowRequestListResponse extends PaginatedData<SlowRequestItem> {
  summary: {
    total: number;
    avgDuration: number;
    maxDuration: number;
    p95Duration: number;
    p99Duration: number;
    topPaths: { path: string; count: number; avgDuration: number }[];
    byService: Record<string, number>;
  };
}

/**
 * 日志配置
 */
export interface LogConfig {
  level: LogLevel;
  sampling: {
    enabled: boolean;
    rules: {
      alwaysLog: { levels: LogLevel[]; paths: string[] };
      neverLog: { paths: string[] };
      dynamic: {
        qpsThreshold: number;
        minSampleRate: number;
        maxSampleRate: number;
      };
    };
  };
  retention: {
    http: number;          // 天
    application: number;   // 天
    error: number;         // 天
  };
  alerts: AlertConfig;
  updatedAt: string;
  updatedBy: string;
}

/**
 * 告警配置
 */
export interface AlertConfig {
  slowRequest: {
    enabled: boolean;
    thresholdMs: number;
    excludePaths: string[];
  };
  errorRate: {
    enabled: boolean;
    thresholdPercent: number;
    windowMinutes: number;
    minRequests?: number;
  };
  ipAnomaly?: {
    enabled: boolean;
    maxRequestsPerMinute: number;
    blockDurationMinutes: number;
  };
  diskSpace: {
    enabled: boolean;
    warningPercent: number;
    criticalPercent: number;
  };
}

/**
 * 告警项
 */
export interface AlertItem {
  id: string;
  type: AlertType;
  severity: AlertSeverity;
  message: string;
  context: {
    traceId?: string;
    url?: string;
    duration?: number;
    threshold?: number;
    errorRate?: number;
    diskUsage?: number;
    ip?: string;
    requestCount?: number;
  };
  sentAt: string;
  channels: string[];
  status: AlertStatus;
}

/**
 * 告警历史响应
 */
export interface AlertHistoryResponse extends PaginatedData<AlertItem> {
  summary: {
    total: number;
    byType: Record<AlertType, number>;
    byStatus: Record<AlertStatus, number>;
  };
}

/**
 * 告警配置响应
 */
export interface AlertConfigResponse extends AlertConfig {
  notifications: {
    slack: { enabled: boolean; webhookConfigured: boolean };
    feishu: { enabled: boolean; webhookConfigured: boolean };
    email: { enabled: boolean; recipientCount: number };
  };
  updatedAt: string;
  updatedBy: string;
}

/**
 * 日志统计
 */
export interface LogStats {
  period: { start: string; end: string };
  summary: {
    totalLogs: number;
    totalRequests: number;
    errorCount: number;
    warnCount: number;
    avgDuration: number;
    p95Duration: number;
    p99Duration: number;
    slowRequestCount: number;
  };
  byLevel: Record<LogLevel, number>;
  byService: Record<string, number>;
  byRegion: Record<string, number>;
  byHour: { hour: string; count: number; errorRate: number; avgDuration: number }[];
  diskUsage: {
    total: string;
    used: string;
    usedPercent: number;
    byType: Record<string, string>;
  };
}

/**
 * 清理结果
 */
export interface CleanupResult {
  dryRun: boolean;
  deletedFiles: number;
  freedSpace: string;
  details: {
    http?: { files: number; size: string };
    application?: { files: number; size: string };
    error?: { files: number; size: string };
  };
  completedAt: string;
}

/**
 * 测试告警结果
 */
export interface TestAlertResult {
  channel: string;
  status: 'SUCCESS' | 'FAILED';
  sentAt: string;
  errorMessage?: string;
}

// ==================== 请求参数类型 ====================

/**
 * 通用查询参数
 */
export interface CommonQueryParams {
  startTime?: string;        // ISO 8601 格式
  endTime?: string;          // ISO 8601 格式
  service?: LogService;
  region?: string;           // CN | US | UAE
  sortBy?: '@timestamp' | 'level' | 'duration' | 'service';
  sortOrder?: 'asc' | 'desc';
  page?: number;
  limit?: number;
}

/**
 * 查询日志参数
 */
export interface QueryLogParams extends CommonQueryParams {
  level?: LogLevel;
  traceId?: string;
  requestId?: string;
  userId?: string;
  userName?: string;
  url?: string;
  keyword?: string;
  minDuration?: number;
  maxDuration?: number;
  statusCode?: number;
  hasError?: boolean;
}

/**
 * 查询错误日志参数
 */
export interface QueryErrorLogParams extends CommonQueryParams {
  errorType?: string;
  errorCode?: string;
  userId?: string;
  userName?: string;
  url?: string;
  keyword?: string;
}

/**
 * 查询慢请求参数
 */
export interface QuerySlowRequestParams extends CommonQueryParams {
  thresholdMs?: number;      // 默认 2000
  url?: string;
  userId?: string;
  userName?: string;
}

/**
 * 查询告警历史参数
 */
export interface QueryAlertHistoryParams extends CommonQueryParams {
  type?: AlertType;
  status?: AlertStatus;
}

/**
 * 日志统计参数
 */
export interface LogStatsParams {
  startTime?: string;
  endTime?: string;
  groupBy?: 'hour' | 'day' | 'service' | 'level' | 'region';
}

/**
 * 更新日志配置参数
 */
export interface UpdateLogConfigParams {
  level?: LogLevel;
  sampling?: {
    enabled?: boolean;
    rules?: {
      dynamic?: {
        qpsThreshold?: number;
        minSampleRate?: number;
        maxSampleRate?: number;
      };
    };
  };
  alerts?: Partial<AlertConfig>;
}

/**
 * 清理日志参数
 */
export interface CleanupLogParams {
  type?: 'http' | 'application' | 'error' | 'all';
  olderThanDays?: number;
  dryRun?: boolean;
}

/**
 * 更新告警配置参数
 */
export interface UpdateAlertConfigParams {
  slowRequest?: Partial<AlertConfig['slowRequest']>;
  errorRate?: Partial<AlertConfig['errorRate']>;
  ipAnomaly?: Partial<AlertConfig['ipAnomaly']>;
  diskSpace?: Partial<AlertConfig['diskSpace']>;
  notifications?: {
    slack?: { webhookUrl?: string; enabled?: boolean };
    feishu?: { webhookUrl?: string; enabled?: boolean };
    email?: { recipients?: string[]; enabled?: boolean };
  };
}

/**
 * 测试告警参数
 */
export interface TestAlertParams {
  channel: 'slack' | 'feishu' | 'email';
  message?: string;
}

// ==================== API 函数 ====================

const BASE_URL = '/logs';

// -------------------- 日志查询 --------------------

/**
 * 查询日志列表
 */
export async function queryLogs(params?: QueryLogParams): Promise<PaginatedData<LogItem>> {
  return apiClient.get(`${BASE_URL}/query`, { params });
}

/**
 * 按追踪 ID 查询完整链路
 */
export async function getTraceById(traceId: string): Promise<TraceResponse> {
  return apiClient.get(`${BASE_URL}/trace/${traceId}`);
}

/**
 * 查询错误日志
 */
export async function queryErrorLogs(params?: QueryErrorLogParams): Promise<ErrorLogListResponse> {
  return apiClient.get(`${BASE_URL}/errors`, { params });
}

/**
 * 查询慢请求
 */
export async function querySlowRequests(params?: QuerySlowRequestParams): Promise<SlowRequestListResponse> {
  return apiClient.get(`${BASE_URL}/slow-requests`, { params });
}

// -------------------- 日志管理 --------------------

/**
 * 获取日志配置
 */
export async function getLogConfig(): Promise<LogConfig> {
  return apiClient.get(`${BASE_URL}/config`);
}

/**
 * 更新日志配置
 */
export async function updateLogConfig(params: UpdateLogConfigParams): Promise<LogConfig> {
  return apiClient.put(`${BASE_URL}/config`, params);
}

/**
 * 手动清理日志
 */
export async function cleanupLogs(params: CleanupLogParams): Promise<CleanupResult> {
  return apiClient.post(`${BASE_URL}/cleanup`, params);
}

/**
 * 获取日志统计
 */
export async function getLogStats(params?: LogStatsParams): Promise<LogStats> {
  return apiClient.get(`${BASE_URL}/stats`, { params });
}

// -------------------- 告警管理 --------------------

/**
 * 获取告警历史
 */
export async function getAlertHistory(params?: QueryAlertHistoryParams): Promise<AlertHistoryResponse> {
  return apiClient.get(`${BASE_URL}/alerts`, { params });
}

/**
 * 获取告警配置
 */
export async function getAlertConfig(): Promise<AlertConfigResponse> {
  return apiClient.get(`${BASE_URL}/alerts/config`);
}

/**
 * 更新告警配置
 */
export async function updateAlertConfig(params: UpdateAlertConfigParams): Promise<AlertConfigResponse> {
  return apiClient.put(`${BASE_URL}/alerts/config`, params);
}

/**
 * 测试告警通道
 */
export async function testAlert(params: TestAlertParams): Promise<TestAlertResult> {
  return apiClient.post(`${BASE_URL}/alerts/test`, params);
}

// ==================== 辅助函数 ====================

// eslint-disable-next-line @typescript-eslint/no-explicit-any
type TranslationObject = Record<string, any>;

/**
 * 获取日志级别标签
 */
export function getLogLevelLabel(level: LogLevel, t?: TranslationObject): string {
  const labels: Record<LogLevel, string> = {
    [LogLevel.ERROR]: t?.logs?.level?.error || '错误',
    [LogLevel.WARN]: t?.logs?.level?.warn || '警告',
    [LogLevel.INFO]: t?.logs?.level?.info || '信息',
    [LogLevel.DEBUG]: t?.logs?.level?.debug || '调试',
  };
  return labels[level] || level;
}

/**
 * 获取日志级别颜色
 */
export function getLogLevelColor(level: LogLevel): { bg: string; text: string; border: string } {
  const colors: Record<LogLevel, { bg: string; text: string; border: string }> = {
    [LogLevel.ERROR]: { bg: 'bg-red-50', text: 'text-red-600', border: 'border-red-200' },
    [LogLevel.WARN]: { bg: 'bg-yellow-50', text: 'text-yellow-600', border: 'border-yellow-200' },
    [LogLevel.INFO]: { bg: 'bg-blue-50', text: 'text-blue-600', border: 'border-blue-200' },
    [LogLevel.DEBUG]: { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' },
  };
  return colors[level] || { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' };
}

/**
 * 获取告警类型标签
 */
export function getAlertTypeLabel(type: AlertType, t?: TranslationObject): string {
  const labels: Record<AlertType, string> = {
    [AlertType.SLOW_REQUEST]: t?.logs?.alertType?.slowRequest || '慢请求',
    [AlertType.HIGH_ERROR_RATE]: t?.logs?.alertType?.highErrorRate || '高错误率',
    [AlertType.DISK_SPACE]: t?.logs?.alertType?.diskSpace || '磁盘空间',
    [AlertType.IP_ANOMALY]: t?.logs?.alertType?.ipAnomaly || 'IP 异常',
  };
  return labels[type] || type;
}

/**
 * 获取告警类型颜色
 */
export function getAlertTypeColor(type: AlertType): { bg: string; text: string; border: string } {
  const colors: Record<AlertType, { bg: string; text: string; border: string }> = {
    [AlertType.SLOW_REQUEST]: { bg: 'bg-yellow-50', text: 'text-yellow-600', border: 'border-yellow-200' },
    [AlertType.HIGH_ERROR_RATE]: { bg: 'bg-red-50', text: 'text-red-600', border: 'border-red-200' },
    [AlertType.DISK_SPACE]: { bg: 'bg-orange-50', text: 'text-orange-600', border: 'border-orange-200' },
    [AlertType.IP_ANOMALY]: { bg: 'bg-purple-50', text: 'text-purple-600', border: 'border-purple-200' },
  };
  return colors[type] || { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' };
}

/**
 * 获取告警严重级别标签
 */
export function getAlertSeverityLabel(severity: AlertSeverity, t?: TranslationObject): string {
  const labels: Record<AlertSeverity, string> = {
    [AlertSeverity.CRITICAL]: t?.logs?.severity?.critical || '严重',
    [AlertSeverity.WARNING]: t?.logs?.severity?.warning || '警告',
    [AlertSeverity.INFO]: t?.logs?.severity?.info || '信息',
  };
  return labels[severity] || severity;
}

/**
 * 获取告警严重级别颜色
 */
export function getAlertSeverityColor(severity: AlertSeverity): { bg: string; text: string; border: string } {
  const colors: Record<AlertSeverity, { bg: string; text: string; border: string }> = {
    [AlertSeverity.CRITICAL]: { bg: 'bg-red-50', text: 'text-red-600', border: 'border-red-200' },
    [AlertSeverity.WARNING]: { bg: 'bg-yellow-50', text: 'text-yellow-600', border: 'border-yellow-200' },
    [AlertSeverity.INFO]: { bg: 'bg-blue-50', text: 'text-blue-600', border: 'border-blue-200' },
  };
  return colors[severity] || { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' };
}

/**
 * 获取告警状态标签
 */
export function getAlertStatusLabel(status: AlertStatus, t?: TranslationObject): string {
  const labels: Record<AlertStatus, string> = {
    [AlertStatus.SENT]: t?.logs?.alertStatus?.sent || '已发送',
    [AlertStatus.FAILED]: t?.logs?.alertStatus?.failed || '发送失败',
    [AlertStatus.ACKNOWLEDGED]: t?.logs?.alertStatus?.acknowledged || '已确认',
  };
  return labels[status] || status;
}

/**
 * 获取告警状态颜色
 */
export function getAlertStatusColor(status: AlertStatus): { bg: string; text: string; border: string } {
  const colors: Record<AlertStatus, { bg: string; text: string; border: string }> = {
    [AlertStatus.SENT]: { bg: 'bg-green-50', text: 'text-green-600', border: 'border-green-200' },
    [AlertStatus.FAILED]: { bg: 'bg-red-50', text: 'text-red-600', border: 'border-red-200' },
    [AlertStatus.ACKNOWLEDGED]: { bg: 'bg-blue-50', text: 'text-blue-600', border: 'border-blue-200' },
  };
  return colors[status] || { bg: 'bg-gray-50', text: 'text-gray-600', border: 'border-gray-200' };
}

/**
 * 格式化服务名称
 */
export function formatServiceName(service: string): string {
  const serviceNames: Record<string, string> = {
    IAM: '身份认证',
    Form: '表单引擎',
    Approval: '审批引擎',
    Inventory: '库存管理',
    HR: '人事管理',
    Finance: '财务管理',
    Report: '报表服务',
    Notification: '通知服务',
    Gateway: 'API 网关',
    Scheduler: '定时任务',
    FileStorage: '文件存储',
    Temporal: '工作流引擎',
  };
  return serviceNames[service] || service;
}

/**
 * 格式化响应时间
 */
export function formatDuration(ms: number): string {
  if (ms < 1000) {
    return `${ms}ms`;
  }
  if (ms < 60000) {
    return `${(ms / 1000).toFixed(2)}s`;
  }
  return `${(ms / 60000).toFixed(2)}min`;
}

/**
 * 格式化文件大小
 */
export function formatFileSize(bytes: number): string {
  if (bytes < 1024) {
    return `${bytes}B`;
  }
  if (bytes < 1024 * 1024) {
    return `${(bytes / 1024).toFixed(2)}KB`;
  }
  if (bytes < 1024 * 1024 * 1024) {
    return `${(bytes / (1024 * 1024)).toFixed(2)}MB`;
  }
  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
}

/**
 * 获取 HTTP 方法颜色
 */
export function getHttpMethodColor(method: string): { bg: string; text: string } {
  const colors: Record<string, { bg: string; text: string }> = {
    GET: { bg: 'bg-green-100', text: 'text-green-700' },
    POST: { bg: 'bg-blue-100', text: 'text-blue-700' },
    PUT: { bg: 'bg-yellow-100', text: 'text-yellow-700' },
    PATCH: { bg: 'bg-orange-100', text: 'text-orange-700' },
    DELETE: { bg: 'bg-red-100', text: 'text-red-700' },
  };
  return colors[method.toUpperCase()] || { bg: 'bg-gray-100', text: 'text-gray-700' };
}

/**
 * 获取 HTTP 状态码颜色
 */
export function getStatusCodeColor(code: number): { bg: string; text: string } {
  if (code >= 200 && code < 300) {
    return { bg: 'bg-green-100', text: 'text-green-700' };
  }
  if (code >= 300 && code < 400) {
    return { bg: 'bg-blue-100', text: 'text-blue-700' };
  }
  if (code >= 400 && code < 500) {
    return { bg: 'bg-yellow-100', text: 'text-yellow-700' };
  }
  if (code >= 500) {
    return { bg: 'bg-red-100', text: 'text-red-700' };
  }
  return { bg: 'bg-gray-100', text: 'text-gray-700' };
}

// 导出错误类
export { ApiClientError };