const axios = require('axios')
import { Message } from 'element-ui'
import { getToken } from '@/utils/auth'
function isF() { return typeof arguments[0] === 'function' }

/* json转formdata（序列化），仅支持一级字面量和字面量数组 */
function jsonToFormData(json) {
  var arr = []
  var e = encodeURIComponent
  for (var key in json) {
    var item = json[key]
    var res
    if (item instanceof Array) {
      res = []
      item.map(function(o) {
        res.push(e(key) + '=' + e(o))
      })
      res = res.join('&')
    } else {
      res = e(key) + '=' + e(item)
    }
    arr.push(res)
  }
  return arr.join('&')
}

function Http(http_o) {
  // 返回值 Object
  // 参数说明
  // o.baseUrl 这个参数根据传入的基础路径会初始化http中的所有请求方法
  // ... 待扩展
  var requestArr = [] // 请求次数
  return {
    // 这个对象是包含全部所有的请求
    postFN(post_o, successCallBack, failCallBack) {
      // post 方法
      // 参数说明
      // post_o.url 指的是请求的路径
      // post_o.baseChgUrl 可动态切换的接口
      // params 接受 对象序列化 传参 即 将传入的 params（对象） 参数  序列化为 url 传参的方式如 xxx.com/api?id=1212&name=456
      // udData Object：即userDefined Data 用户自定义数据，这是一个扩展字段
      // mockData Object 测试数据
      Request({
        method: 'post',
        header: post_o.header,
        params: post_o.params || false,
        url: post_o.url,
        baseChgUrl: post_o.baseChgUrl, // 动态切换接口
        udData: post_o.udData, // 预留扩展字段
        mockData: post_o.mockData // 测试数据
      }).then(data => {
        console.log('请求:', post_o.url, data, post_o.params)
        // 登录失效
        if (Number(data.code) === 603) {
          Message({
            type: 'error',
            showClose: true,
            duration: 10000,
            message: data.msg
          })
          setTimeout(() => {
            sessionStorage.clear()
            // 未登录，刷新页面出发页面 checkLoginFN跳转登录页面
            location.reload()
          }, 800)
          return
        }

        // todo 无code时的报错
        if (Number(data.code) === 100) {
          // 请求成功
          isF(successCallBack) && successCallBack(data.data)
        } else {
          // 请求失败
          if (isF(failCallBack)) {
            failCallBack(data)
          } else {
            Message({
              type: 'error',
              showClose: true,
              duration: 10000,
              message: data.msg
            })
          }
        }
      })
    },
    getFN(get_o, successCallBack, failCallBack) {
      // get 方法
      // 参数说明
      // get_o.url 指的是请求的路径
      // get_o.baseChgUrl 可动态切换的接口
      // params 接受 对象序列化 传参 即 将传入的 params（对象） 参数  序列化为 url 传参的方式如 xxx.com/api?id=1212&name=456
      // udData Object：即userDefined Data 用户自定义数据，这是一个扩展字段
      // mockData Object 测试数据
      Request({
        method: 'get',
        header: get_o.header,
        params: get_o.params || false,
        url: get_o.url,
        baseChgUrl: get_o.baseChgUrl, // 动态切换接口
        udData: get_o.udData, // 预留扩展字段
        mockData: get_o.mockData // 测试数据
      }).then(data => {
        console.log('请求:', get_o.url, data, get_o.params)
        // 登录失效
        if (Number(data.code) === 603) {
          Message({
            type: 'error',
            showClose: true,
            duration: 10000,
            message: data.msg
          })
          setTimeout(() => {
            sessionStorage.clear()
            // 未登录，刷新页面出发页面 checkLoginFN跳转登录页面
            location.reload()
          }, 800)
          return
        }

        if (Number(data.code) === 100) {
          // 请求成功
          isF(successCallBack) && successCallBack(data.inf)
        } else {
          // 请求失败
          if (isF(failCallBack)) {
            failCallBack(data)
          } else {
            Message({
              type: 'error',
              showClose: true,
              duration: 10000,
              message: data.msg
            })
          }
        }
      })
    }
  }

  function Request(request_o) {
    // 总请求方法,这是一个被独立处理出来的方法，因为这个方法是一个比较特殊的方法，首先这个方法不应被暴露出来，
    // 然后因为根据项目的独特性，最底层的拦截、加密、权限的实现和代码都有所不同，这里应该独立处理，方便以后移植和复用
    // 这个方法是所有请求方法的底层方法，具有错误码拦截，权限管理（鉴权）等 拦截的功能
    // 返回值 Object
    // 参数说明
    // o.method 请求类型
    // o.url 请求路径
    // o.params 请求参数
    // o.baseUrl 基本路径
    // udData Object：即userDefined Data 用户自定义数据，这是一个扩展字段
    //              fullData 这个字段为真的话，将返回 服务端返回的所有数据，默认返回data
    requestArr.push(request_o) // 将请求加入数组
    if (http_o.startRequest) {
      http_o.startRequest(http_o, request_o) // 事件委托,请求之前
    }
    return new Promise((resolve, reject) => {
      // 添加切换调用接口域名功能 -- start
      var ajaxUrl
      if (request_o.baseChgUrl) {
        ajaxUrl = request_o.baseChgUrl + request_o.url
      } else {
        ajaxUrl = http_o.baseUrl + request_o.url
      }
      // 添加切换调用接口域名功能 -- end

      // 处理传参 -- start
      // 将token放到params里
      var noToken = request_o.udData && request_o.udData.noToken // noToken则不传token
      var adminToken = getToken()
      // 放到连接后得请求参数

      var urlEncodes = {}
      if (adminToken && !noToken) {
        urlEncodes = { adminToken: adminToken }
        // ...urlEncodes,
      }
      // // 将请求参数放到链接后面
      var paramsUrl = urlEncode(urlEncodes)
      if(!/\?/.test(ajaxUrl)) {
          paramsUrl = paramsUrl.replace('&', '?')
      }
      ajaxUrl = ajaxUrl + paramsUrl

      // console.log(ajaxUrl)
      // console.log(request_o.params)
      // 处理传参 -- end

      // request_o.params.adminToken = adminToken

      var requestConfig = {
        // 請求對象
        method: request_o.method,
        url: ajaxUrl,
        data: request_o.params,
        header: request_o.header || {
          'Content-type': 'application/x-www-form-urlencoded' // 默认值
        }
      }

      // 转formData
      if (requestConfig.header['Content-type'] === 'application/x-www-form-urlencoded') {
        requestConfig.data = requestConfig.data ? jsonToFormData(requestConfig.data) : {}
      }

      // 使用测试数据
      if (http_o.isMock) {
        console.log('开始模拟等待800ms')
        // 模拟请求
        if (http_o.httpEventCode && http_o.httpEventCode['code200']) {
          http_o.httpEventCode['code200'](request_o.mockData) // 事件委托,处理错误
        }
        if (http_o.endRequest) {
          http_o.endRequest({ ...http_o, ...request_o.mockData }) // 事件委托,请求之前
        }
        setTimeout(() => {
          console.log('结束模拟等待800ms')
          resolve(request_o.mockData)

          // 无论成功或者失败都会执行
          requestArr.splice(0, 1)
          if (requestArr.length === 0) {
            // 批量请求全部完成
            if (http_o.concurrentRequests) {
              http_o.concurrentRequests()
            }
          }
        }, 800)
        return
      }

      axios(requestConfig).then((res) => {
        if (http_o.httpEventCode && http_o.httpEventCode['code' + res.status]) {
          http_o.httpEventCode['code' + res.status](res) // 事件委托,处理错误
        }
        if (http_o.endRequest) {
          http_o.endRequest({ ...http_o, ...res }) // 事件委托,请求之前
        }
        if (http_o.defindFlow) {
          // 自定义流程
          resolve(http_o.defindFlow({ requestConfig: requestConfig, res: res, Request: Request }))
        }
        if (request_o.udData && request_o.udData.fullData === true) {
          // 如果这里的fullData 为真的话,将返回服务器返回的所有数据
          resolve(res)
        }
        resolve(res.data)
      }).catch((err) => {
        // console.log('异步报错：',err);
        var code
        err.response && (code = err.response.status) // 请求错误码
        if (http_o.httpEventCode && http_o.httpEventCode['code' + code]) {
          http_o.httpEventCode['code' + code](err) // 事件委托,处理错误
        }
        reject(err)
      }).finally(() => {
        // 无论成功或者失败都会执行
        requestArr.splice(0, 1)
        if (requestArr.length === 0) {
          // 批量请求全部完成
          if (http_o.concurrentRequests) {
            http_o.concurrentRequests()
          }
        }
      })
    })
  }

  // 对象转url参数
  function urlEncode(param, key, encode) {
    if (param == null) return ''
    var paramStr = ''
    var t = typeof (param)
    if (t === 'string' || t === 'number' || t === 'boolean') {
      paramStr += '&' + key + '=' + ((encode == null || encode) ? encodeURIComponent(param) : param)
    } else {
      for (var i in param) {
        var k = key == null ? i : key + (param instanceof Array ? '[' + i + ']' : '.' + i)
        paramStr += urlEncode(param[i], k, encode)
      }
    }screenLeft
    return paramStr
  }
}
export { Http }