import axios from 'axios';
import error from './error';
import Message from '../../tool/message';


const config = {
  api: 'http://172.16.33.193:8040'
}
/**
 * http类
 * @author tanxj
 */
class HttpService {
  private defaultRequestOptions: any = {};

  constructor() {
    // axios 基本配置，请求超时参数，地址前缀
    axios.defaults.timeout = 30000;
    axios.defaults.baseURL = config.api;
    axios.defaults.headers = {
      'Content-Type': 'application/json;charset=UTF-8'
    };
    // POST传参序列化
    axios.interceptors.request.use((config) => {
      return config;
    }, (error) => {
      return Promise.reject(error);
    });
    // axios响应功能配置
    axios.interceptors.response.use((response: any) => {
      return response;
    }, (error: any) => {
      return Promise.resolve(error.response);
    });
  }

  /**
   * 检测请求状态值
   * @param response
   * @return {any}
   */
  checkStatus(response: any, isApi?: boolean) {
    const statusCode = response.status.toString();
    switch (statusCode) {
      case '403':
        throw { code: 1005 }; // 无权限
      case '404':
        throw { code: 1002 }; // 无接口
      case '406':
        throw { code: 1004 }; // token失效
      case '417':
        return { code: 417 }; // token过期
      case '500':
        throw { code: 1006 }; // 服务端错误
      default: {
        if ((statusCode.indexOf('2') === 0)) return !isApi
          ? { code: 0, ...response.data } : { code: 0, data: response.data };
        // 开发级异常（主键冲突、不满足条件等等）
        if ((statusCode.indexOf('4') === 0)) throw { code: 1001, ...response.data };
        //  服务端错误
        if ((statusCode.indexOf('5') === 0)) throw { code: 1006, ...response.data };
        throw { code: 1001 };
      }
    }
  }

  /**
   * 请求成功，数据处理
   * @param res 返回数据
   * @return {any}
   */

  successHandler(res: any, type?: string) {
    Message(`请求成功`, 'success');
    return res;
  }

  /**
   * 请求失败，数据处理
   * @param error 返回错误信息
   * @return {any}
   */
  errHandler(errorInfo: any) {
    throw errorInfo;
  }

  /**
   * 过滤请求参数参数
   * @param params 请求数据
   * @return {any} 返回请求数据
   */
  filterParam(params: { [key: string]: any }) {
    if (params === null || params === undefined) return null;
    return Object.keys(params).filter((item: any) => {
      return params[item] || [0, '', false].includes(params[item]);
    }).reduce((prev: any, curr: any) => Object.assign(prev, {
      [curr]: params[curr]
    }), {});
  }

  /**
   * http请求获取方式， GET
   * @param {string} url 请求的url
   * @param {string} method 请求方式 POST/PUT/GET/DELETE
   * @param data 参数或者path路径参数
   * @param params  query参数处理
   * @return {Promise<void>}
   */
  request(url: string, method: string, data: any = {}, params: any = {}, other: any = {}) {
    axios.defaults.baseURL = config.api;
    axios.defaults.headers = {
      'Content-Type': 'application/json;charset=UTF-8'
    };
    // 处理超时特殊时间
    if (data && data.axiosTimeout) {
      axios.defaults.timeout = data.axiosTimeout;
      delete data.axiosTimeout;
    }
    if (!(data instanceof Array)) {
      data = data && this.filterParam(data);
    }
    let options = {};
    // 判断method是get/delete还是post/put，请求的options不同
    if (method === 'get' || method === 'delete') {
      data && Object.values(data).forEach((item: any) => url += '/' + item);
      // query参数处理
      if (method === 'delete') {
        options = { method, url, data: params, params: other };
      } else {
        Object.keys(params).forEach((key: string) => {
          if (params[key] === undefined) delete params[key];
        });
        options = { method, url, data: {}, params: params };
      }
    } else {
      options = { method, url, data, params: params };
    }
    return axios(options).then((response: any) => {
      const tempData = this.checkStatus(response, true);
      if (tempData !== undefined) return tempData;
    }).then((res: any) => {
      return this.successHandler(res);
    }).catch((error: any) => {
      return this.errHandler(error);
    });
  }

  /**
   * http请求参数获取方式
   * @return {Promise<void>}
   */
  requestParams(serviceName: string, funcName: string, params?: any) {
    try {
      axios.defaults.baseURL = config.api;
      const options = this.handelParams(serviceName, funcName, params);
      return axios(options).then((response: any) => {
        const tempData = this.checkStatus(response);
        if (tempData !== undefined) return tempData;
      }).then((res: any) => {
        return this.successHandler(res, options.method);
      }).catch((error: any) => {
        return this.errHandler(error);
      });
    } catch (error) {
      Message(error ? `${error}` : '参数错误', 'error');
      return Promise.reject(error);
    }
  }

  /**
   * 处理请求参数
   */
  handelParams(serviceName: string, funcName: string, params?: any) {
    let currentApi: any = {};
    const apiList = JSON.parse(sessionStorage.getItem('api'));
    if (!apiList || apiList.length === 0) throw `服务器异常`;
    const apiItem = apiList.find((item: any) => item[serviceName]);
    if (!apiItem) throw `无服务名称API`;
    const baseUrl = apiItem[serviceName]['route.id'] + apiItem[serviceName].contextPath;
    if (apiItem[serviceName]) {
      currentApi = apiItem[serviceName].apis[funcName];
      if (!currentApi) throw `无方法名称API`;
    }
    const { path, method, parameters } = currentApi;
    const options = { url: baseUrl + path, method, data: {}, params: {} };
    // 处理参数，参数必填以及类型
    Object.keys(parameters).forEach((key: string) => {
      switch (parameters[key].in) {
        case "header": {
          switch (key) {
            case 'Authorization': {
              axios.defaults.headers.Authorization = '';
              break;
            }
            default:
              axios.defaults.headers[key] = config[key];
              break;
          }
          break;
        }
        case "query": {
          if (parameters[key].required && !params[key]) throw key;
          else options.params[key] = params[key];
          break;
        }
        case 'path': {
          if (parameters[key].required && !params[key]) throw `参数${key}为必填项`;
          else options.url = options.url.replace(`{${key}}`, params[key]);
          break;
        }
        case 'body': {
          options.data = params;
          break;
        }
        default:
          break;
      }
    });
    return options;
  }

}

export const BaseHttp = new HttpService();