/**
 * Error Handler
 *
 * 统一的错误处理机制
 */

export enum ErrorCode {
  // 认证错误
  UNAUTHORIZED = 401,
  FORBIDDEN = 403,
  TOKEN_EXPIRED = 4011,
  TOKEN_INVALID = 4012,

  // 业务错误
  BAD_REQUEST = 400,
  NOT_FOUND = 404,
  CONFLICT = 409,
  VALIDATION_ERROR = 422,

  // 服务器错误
  INTERNAL_SERVER_ERROR = 500,
  SERVICE_UNAVAILABLE = 503,

  // 网络错误
  NETWORK_ERROR = -1,
  TIMEOUT_ERROR = -2,
  ABORT_ERROR = -3,
}

export interface AppError {
  code: ErrorCode;
  message: string;
  detail?: string;
  data?: any;
}

export class ErrorHandler {
  private static errorMessages: Record<ErrorCode, string> = {
    [ErrorCode.UNAUTHORIZED]: '未授权，请先登录',
    [ErrorCode.FORBIDDEN]: '没有权限访问该资源',
    [ErrorCode.TOKEN_EXPIRED]: '登录已过期，请重新登录',
    [ErrorCode.TOKEN_INVALID]: '登录信息无效，请重新登录',
    [ErrorCode.BAD_REQUEST]: '请求参数错误',
    [ErrorCode.NOT_FOUND]: '请求的资源不存在',
    [ErrorCode.CONFLICT]: '资源冲突',
    [ErrorCode.VALIDATION_ERROR]: '数据验证失败',
    [ErrorCode.INTERNAL_SERVER_ERROR]: '服务器内部错误',
    [ErrorCode.SERVICE_UNAVAILABLE]: '服务暂时不可用',
    [ErrorCode.NETWORK_ERROR]: '网络连接失败',
    [ErrorCode.TIMEOUT_ERROR]: '请求超时',
    [ErrorCode.ABORT_ERROR]: '请求已取消',
  };

  /**
   * 解析错误
   */
  static parseError(error: any): AppError {
    // 处理 null 或 undefined
    if (!error) {
      return {
        code: ErrorCode.INTERNAL_SERVER_ERROR,
        message: this.errorMessages[ErrorCode.INTERNAL_SERVER_ERROR],
      };
    }

    // 网络错误
    if (!error.response && error.request) {
      return {
        code: ErrorCode.NETWORK_ERROR,
        message: this.errorMessages[ErrorCode.NETWORK_ERROR],
        detail: error.message,
      };
    }

    // 超时错误
    if (error.code === 'ECONNABORTED' || error.message?.includes('timeout')) {
      return {
        code: ErrorCode.TIMEOUT_ERROR,
        message: this.errorMessages[ErrorCode.TIMEOUT_ERROR],
      };
    }

    // 取消请求
    if (error.name === 'AbortError' || error.message?.includes('abort')) {
      return {
        code: ErrorCode.ABORT_ERROR,
        message: this.errorMessages[ErrorCode.ABORT_ERROR],
      };
    }

    // HTTP 错误
    const status = error.response?.status || error.status || error.statusCode;
    const data = error.response?.data || error.data;

    const code = (status as ErrorCode) || ErrorCode.INTERNAL_SERVER_ERROR;

    // 确保 detail 和 message 是字符串类型
    let detail = data?.detail;
    if (detail) {
      if (typeof detail === 'string') {
        // 已经是字符串，直接使用
      } else if (Array.isArray(detail)) {
        // 如果是数组（Pydantic 验证错误），提取错误信息
        detail = detail
          .map((err: any) => {
            if (typeof err === 'string') return err;
            if (err.msg) return err.msg;
            if (err.message) return err.message;
            return JSON.stringify(err);
          })
          .join('; ');
      } else if (typeof detail === 'object') {
        // 如果是对象，尝试提取有用信息
        if (detail.msg) {
          detail = detail.msg;
        } else if (detail.message) {
          detail = detail.message;
        } else {
          detail = JSON.stringify(detail);
        }
      } else {
        detail = String(detail);
      }
    }

    let message = data?.message;
    if (message) {
      if (typeof message === 'string') {
        // 已经是字符串，直接使用
      } else if (Array.isArray(message)) {
        // 如果是数组，提取错误信息
        message = message
          .map((err: any) => {
            if (typeof err === 'string') return err;
            if (err.msg) return err.msg;
            if (err.message) return err.message;
            return JSON.stringify(err);
          })
          .join('; ');
      } else if (typeof message === 'object') {
        // 如果是对象，尝试提取有用信息
        if (message.msg) {
          message = message.msg;
        } else if (message.message) {
          message = message.message;
        } else {
          message = JSON.stringify(message);
        }
      } else {
        message = String(message);
      }
    }

    const finalMessage = detail || message || this.errorMessages[code] || '未知错误';

    return {
      code,
      message: finalMessage,
      detail: detail,
      data: data,
    };
  }

  /**
   * 获取用户友好的错误消息
   */
  static getUserMessage(error: any): string {
    const appError = this.parseError(error);
    return appError.message;
  }

  /**
   * 判断是否需要重新登录
   */
  static needsReauth(error: any): boolean {
    const appError = this.parseError(error);
    return [ErrorCode.UNAUTHORIZED, ErrorCode.TOKEN_EXPIRED, ErrorCode.TOKEN_INVALID].includes(
      appError.code
    );
  }

  /**
   * 判断是否是网络错误
   */
  static isNetworkError(error: any): boolean {
    const appError = this.parseError(error);
    return [ErrorCode.NETWORK_ERROR, ErrorCode.TIMEOUT_ERROR].includes(appError.code);
  }
}