// This file is auto-generated by @hey-api/openapi-ts

import { type ClientOptions, type Config, createClient, createConfig } from './api/client';
import type { ClientOptions as ClientOptions2 } from './api/types.gen';

/**
 * The `createClientConfig()` function will be called on client initialization
 * and the returned object will become the client's initial configuration.
 *
 * You may want to initialize your client this way instead of calling
 * `setConfig()`. This is useful for example if you're using Next.js
 * to ensure your client always has the correct values.
 */
export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;

/**
 * 格式化请求体以便打印
 */
const formatRequestBody = (body: any): string => {
  if (!body) return '(空)';

  try {
    if (typeof body === 'string') {
      // 如果是字符串，尝试解析为JSON
      const parsed = JSON.parse(body);
      return JSON.stringify(parsed, null, 2);
    } else if (typeof body === 'object') {
      // 如果是对象，直接格式化
      return JSON.stringify(body, null, 2);
    } else {
      // 其他类型
      return String(body);
    }
  } catch (error) {
    // 如果格式化失败，返回原始值
    return String(body);
  }
};


/**
 * 格式化响应体以便打印
 */
const formatResponseBody = async (response: Response): Promise<string> => {
  try {
    const contentType = response.headers.get('content-type');

    if (contentType?.includes('application/json')) {
      const data = await response.clone().json();
      return JSON.stringify(data, null, 2);
    } else if (contentType?.includes('text/')) {
      const text = await response.clone().text();
      return text.substring(0, 1000) + (text.length > 1000 ? '...' : '');
    } else {
      return `(非文本响应: ${contentType || 'unknown'})`;
    }
  } catch (error) {
    return `(解析失败: ${error.message})`;
  }
};

// 注意：由于 tsconfig.json 的 exclude 规则导致路径别名问题，暂时使用相对路径
// 正常情况下应该是：import { getAuthToken } from '@/utils/token';
// 实际文件路径：src/utils/token.ts
// 当前文件路径：src/lib/client.ts
// 相对路径：../../utils/token

/**
 * 获取认证token（使用公用工具函数）
 * 由于TypeScript路径别名问题，暂时直接复制实现
 * TODO: 路径别名修复后改为 import { getAuthToken } from '@/utils/token';
 */
const getAuthToken = (): string | null => {
    try {
      const storedUser = localStorage.getItem('user');
      const user = storedUser ? JSON.parse(storedUser) : null;
      return user?.token || null;
    } catch (error) {
      console.error('获取token失败:', error);
      return null;
    }
  };

/**
 * 请求拦截器 - 在发送请求前添加默认请求头并打印请求信息
 */
const requestInterceptor = async (request: Request) => {
  const timestamp = new Date().toISOString();
  const method = request.method;
  const url = request.url;

  // 获取原有请求头
  const headers: Record<string, string> = {};
  request.headers.forEach((value, key) => {
    headers[key] = value;
  });

  // 添加默认请求头
  const token = getAuthToken();
  if (token && !headers['authorization']) {
    headers['authorization'] = `Bearer ${token}`;
    console.log('🔐 已添加认证token到请求头');
  }

  // 添加其他默认请求头
  headers['X-Requested-With'] = 'XMLHttpRequest';
  headers['X-Client-Version'] = '1.0.0';
  headers['X-Client-Platform'] = 'web';

  // 创建新的请求对象（包含更新的请求头）
  const modifiedRequest = new Request(request, {
    headers: headers
  });

  console.group(`🚀 [${timestamp}] HTTP 请求发送`);
  console.log('📝 方法:', method);
  console.log('🔗 URL:', url);
  console.log('📋 最终请求头:', headers);
  console.log('🔐 认证状态:', token ? '已认证' : '未认证');

  // 获取请求体
  try {
    const bodyText = await modifiedRequest.clone().text();
    if (bodyText) {
      console.log('📦 请求体:', formatRequestBody(bodyText));
    } else {
      console.log('📦 请求体: (空)');
    }
  } catch (error) {
    console.log('📦 请求体: (无法读取)');
  }

  console.log('⏱️ 请求时间戳:', timestamp);
  console.groupEnd();

  return modifiedRequest;
};

/**
 * 响应拦截器 - 在收到响应后打印响应信息
 * 注意：这个拦截器系统的参数顺序是 (response, request, options)
 */
const responseInterceptor = async (response: Response, request: Request, options: any) => {
  const timestamp = new Date().toISOString();
  const status = response.status;
  const statusText = response.statusText;
  const url = response.url;

  // 获取响应头
  const responseHeaders: Record<string, string> = {};
  response.headers.forEach((value, key) => {
    responseHeaders[key] = value;
  });

  console.group(`📥 [${timestamp}] HTTP 响应接收`);
  console.log('📊 状态码:', status);
  console.log('📝 状态文本:', statusText);
  console.log('🔗 响应URL:', url);
  console.log('📋 响应头:', responseHeaders);

  // 获取响应体
  try {
    const responseBody = await formatResponseBody(response);
    console.log('📦 响应体:', responseBody);
  } catch (error) {
    console.log('📦 响应体: (无法读取)');
  }

  // 计算请求耗时（如果有时间戳头）
  const requestTime = request.headers.get('X-Request-Timestamp');
  if (requestTime) {
    const duration = Date.now() - parseInt(requestTime);
    console.log(`⏱️ 请求耗时: ${duration}ms`);
  }

  console.log('⏱️ 响应时间戳:', timestamp);
  console.groupEnd();

  return response;
};

/**
 * 根据HTTP状态码获取用户友好的错误消息
 */
const getErrorMessage = (status: number, statusText?: string, errorData?: any): string => {
  // 业务错误消息（优先使用服务器返回的错误消息）
  if (errorData?.message) {
    return errorData.message;
  }

  // 根据状态码返回通用错误消息
  switch (status) {
    case 400:
      return '请求参数错误，请检查输入信息';
    case 401:
      return '身份认证失败，请重新登录';
    case 403:
      return '权限不足，无法访问该资源';
    case 404:
      return '请求的资源不存在';
    case 405:
      return '请求方法不被允许';
    case 408:
      return '请求超时，请重试';
    case 409:
      return '资源冲突，请检查后重试';
    case 422:
      return '请求参数验证失败';
    case 429:
      return '请求过于频繁，请稍后重试';
    case 500:
      return '服务器内部错误';
    case 502:
      return '网关错误';
    case 503:
      return '服务暂不可用，请稍后重试';
    case 504:
      return '网关超时';
    default:
      return statusText || '请求失败，请重试';
  }
};

/**
 * 显示用户友好的错误提示
 */
const showErrorToast = (message: string, status?: number) => {
  // 检查是否有toast函数（避免在非浏览器环境中调用）
  if (typeof window !== 'undefined' && window.document) {
    // 动态导入toast以避免循环依赖
    import('sonner').then(({ toast }) => {
      if (status && status >= 500) {
        toast.error(message);
      } else if (status === 401) {
        toast.error(message);
      } else if (status === 403) {
        toast.error(message);
      } else {
        toast.error(message);
      }
    }).catch(() => {
      // 如果导入失败，回退到alert
      console.error(message);
      alert(message);
    });
  }
};

/**
 * 错误拦截器 - 统一处理HTTP请求错误
 */
const errorInterceptor = async (error: any, response: Response, request: Request, options: any) => {
  const timestamp = new Date().toISOString();
  const status = response?.status;
  const statusText = response?.statusText;
  const url = response?.url || request?.url || 'Unknown';

  // 尝试解析错误数据
  let errorData = null;
  try {
    const errorText = await response?.clone()?.text();
    if (errorText) {
      errorData = JSON.parse(errorText);
    }
  } catch (e) {
    // 如果解析失败，保持errorData为null
  }

  console.group(`❌ [${timestamp}] HTTP 请求错误`);
  console.error('🚨 HTTP状态:', status, statusText);
  console.error('📝 请求URL:', url);
  console.error('📋 原始错误:', error);

  if (errorData) {
    console.error('📄 错误详情:', errorData);
  }

  // 根据状态码进行特殊处理
  if (status === 401) {
    console.warn('🔐 用户未授权，清除认证信息');
    // 清除本地认证信息
    if (typeof window !== 'undefined') {
      localStorage.removeItem('user');
      document.cookie = 'auth_token=; path=/; expires=Thu, 01 Jan 1970 00:00:01 GMT';

      // 重定向到登录页面
      const currentPath = window.location.pathname;
      const loginUrl = `/login${currentPath !== '/' ? `?redirect=${encodeURIComponent(currentPath)}` : ''}`;
      console.log('🔄 重定向到登录页面:', loginUrl);

      // 延迟跳转，给用户时间看到错误信息
      setTimeout(() => {
        window.location.href = loginUrl;
      }, 1000);
    }
  } else if (status === 403) {
    console.warn('🚫 用户权限不足');
  } else if (status && status >= 500) {
    console.error('💥 服务器错误:', status);
  }

  console.groupEnd();

  // 显示用户友好的错误消息
  const userMessage = getErrorMessage(status!, statusText, errorData);
  showErrorToast(userMessage, status);

  // 创建增强的错误对象，包含更多调试信息
  const enhancedError = new Error(userMessage) as any;
  enhancedError.status = status;
  enhancedError.statusText = statusText;
  enhancedError.url = url;
  enhancedError.data = errorData;
  enhancedError.originalError = error;

  return enhancedError;
};

/**
 * 获取API基础URL
 */
const getBaseUrl = (): string => {
  // 在浏览器环境中使用相对路径（通过Next.js代理）
  if (typeof window !== 'undefined') {
    return '';
  }

  // 在服务器端使用环境变量或默认URL
  return process.env.API_BASE_URL || 'https://gitea-admin-hm-smart-agri-app.dev.maimaiag.com';
};

/**
 * 创建带有拦截器的客户端
 */
const createClientWithInterceptors = () => {
  const baseConfig = createConfig<ClientOptions2>({
    // 根据环境变量配置baseUrl
    baseUrl: getBaseUrl()
  });

  const client = createClient(baseConfig);

  // 添加请求拦截器
  client.interceptors.request.use(requestInterceptor);

  // 添加响应拦截器
  client.interceptors.response.use(responseInterceptor);

  // 添加错误拦截器
  client.interceptors.error.use(errorInterceptor);

  return client;
};

/**
 * 导出带有拦截器的客户端实例
 */
export const client = createClientWithInterceptors();

/**
 * 导出客户端配置函数（保持向后兼容）
 */
export { createClient, createConfig };
