import { extend, ResponseError, type RequestOptionsInit } from 'umi-request';
import { message } from 'antd';
import { navigate } from '@/utils';

export type IErrorLevel = 'toast' | 'prompt' | 'critical' | false;
export interface IOptions {
  method?: 'get' | 'post' | 'put' | 'delete';
  mock?: boolean;
  errorLevel?: 'toast' | 'prompt' | 'critical' | false;
  delayTime?: number | true;
  outside?: boolean;
  isFullPath?: boolean;
  dynamicUrl?: boolean;
}

// TODO:
const codeMessage: { [errorCode: number]: string } = {
  200: '服务器成功返回请求的数据。',
  201: '新建或修改数据成功。',
  202: '一个请求已经进入后台排队（异步任务）。',
  204: '删除数据成功。',
  400: '发出的请求有错误，服务器没有进行新建或修改数据的操作。',
  401: '用户没有权限（令牌、用户名、密码错误）。',
  403: '用户得到授权，但是访问是被禁止的。',
  404: '发出的请求针对的是不存在的记录，服务器没有进行操作。',
  406: '请求的格式不可得。',
  410: '请求的资源被永久删除，且不会再得到的。',
  422: '当创建一个对象时，发生一个验证错误。',
  500: '服务器发生错误，请检查服务器。',
  502: '网关错误。',
  503: '服务不可用，服务器暂时过载或维护。',
  504: '网关超时。',
};

enum ErrorCode {
  /** 需要登录 */
  NEED_LOGGED_IN = 'common.needLoggedIn',
}

const noNeedToastErrorCode = [ErrorCode.NEED_LOGGED_IN];

// yapi mock地址
const mockUrl = 'https://yapi.com/mock/1000160';

// 桌面端的服务器地址
const desktopServiceUrl = `http://127.0.0.1:${__APP_PORT__ || '10824'}`;

// 非桌面端的服务器地址
const prodServiceUrl = location.origin;

// 是否自定义了 _BaseURL || 是否为桌面端地址
const baseURL =
  localStorage.getItem('_BaseURL') ||
  (location.href.indexOf('dist/index.html') > -1 ? desktopServiceUrl : prodServiceUrl);

window._BaseURL = baseURL;
// window._BaseURL = 'http://127.0.0.1:8000';

const appGatewayParams = localStorage.getItem('app-gateway-params');

// appGateway 的基本信息
if (appGatewayParams) {
  window._appGatewayParams = JSON.parse(appGatewayParams);
} else {
  window._appGatewayParams = {};
}

const outsideUrlPrefix = window._appGatewayParams.baseUrl || 'http://test.sqlgpt.cn/gateway';

const errorHandler = (error: ResponseError, errorLevel: IErrorLevel) => {
  const { response } = error;
  if (!response) return;
  const errorText = codeMessage[response.status] || response.statusText;
  const { status } = response;
  if (errorLevel === 'toast') {
    // notification.open({
    //   type: 'error',
    //   message: status,
    //   description: errorText,
    //   placement: 'topRight',
    // });
    message.error(`${status}: ${errorText}`);
  }
};

const request = extend({
  // prefix: '/api',
  credentials: 'include', // 默认请求是否带上cookie
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
  },
});

request.interceptors.request.use((url, options) => {
  const myOptions: any = {
    ...options,
    headers: {
      ...options.headers,
    },
  };
  if (localStorage.getItem('Chat2db')) {
    myOptions.headers.Chat2db = localStorage.getItem('Chat2db');
  }
  return {
    options: myOptions,
  };
});

request.interceptors.response.use(async (response) => {
  const res = await response.clone().json();
  if (__ENV__ === 'desktop') {
    const Chat2db = response.headers.get('Chat2db') || '';
    if (Chat2db) {
      localStorage.setItem('Chat2db', Chat2db);
    }
  }
  const { errorCode } = res;
  if (errorCode === ErrorCode.NEED_LOGGED_IN) {
    navigate('/login');
    // const callback = window.location.hash.substr(1).split('?')[0];
    // window.location.href = '#/login' + (callback === '/login' ? '' : `?callback=${callback}`);
  }

  return response;
});

export default function createRequest<P = void, R = void>(url: string, options?: IOptions) {
  // 路由跳转
  const {
    method = 'get',
    mock = false,
    errorLevel = 'toast',
    delayTime,
    outside,
    isFullPath,
    dynamicUrl,
  } = options || {};

  return function (params: P, restParams?: RequestOptionsInit) {
    // 是否需要mock
    const _baseURL = (mock ? mockUrl : baseURL) || '';
    // if (url === '/api/rdb/ddl/list') {
    //   debugger;
    // }
    // 在url上按照定义规则拼接params
    const paramsInUrl: string[] = [];

    const _url = url.replace(/:(.+?)\b/, (_, name: string) => {
      const value = params[name];
      paramsInUrl.push(name);
      return `${value}`;
    });

    if (paramsInUrl.length) {
      paramsInUrl.forEach((name) => {
        delete params[name];
      });
    }

    return new Promise<R>((resolve, reject) => {
      let dataName = '';
      switch (method) {
        case 'get':
          dataName = 'params';
          break;
        case 'delete':
          dataName = 'params';
          break;
        case 'post':
          dataName = 'data';
          break;
        case 'put':
          dataName = 'data';
          break;
        default:
          dataName = 'params';
          break;
      }

      let eventualUrl = outside ? `${outsideUrlPrefix}${_url}` : `${_baseURL}${_url}`;
      eventualUrl = isFullPath ? url : eventualUrl;

      // 动态的url
      if (dynamicUrl) {
        eventualUrl = params as string;
      }

      request[method](eventualUrl, { [dataName]: params, ...restParams })
        .then((res) => {
          if (!res) return;
          const { success, errorCode, errorMessage, errorDetail, solutionLink, data } = res;
          if (!success && errorLevel === 'toast' && !noNeedToastErrorCode.includes(errorCode)) {
            delayTimeFn(() => {
              window._notificationApi({
                requestUrl: eventualUrl,
                requestParams: JSON.stringify(params),
                errorCode,
                errorMessage,
                errorDetail,
                solutionLink,
              });
              // message.error(`${errorCode}: ${errorMessage}`);
              reject(`${errorCode}: ${errorMessage}`);
            }, delayTime);
            return;
          }
          // 有些loading效果添加强制延时效果可能会更好看, 可行性待商榷
          delayTimeFn(() => {
            resolve(data);
          }, delayTime);
        })
        .catch((error) => {
          delayTimeFn(() => {
            errorHandler(error, errorLevel);
            reject(error);
          }, delayTime);
        });
    });
  };
}

// 简单的延时函数
function delayTimeFn(callback: () => void, time: number | true | undefined) {
  if (time) {
    const timer = setTimeout(() => {
      callback();
      clearInterval(timer);
    }, time && 500);
  } else {
    callback();
  }
}