import axios from 'axios'
import store from '@/store'
import { Message } from 'element-ui'
// import { Loading } from 'element-ui'
// import { disposeErrFun } from './errMesenge'
// import { promises } from 'fs'
// import { listenerCount } from 'cluster'
// create an axios instance
const service = axios.create({
  baseURL:  VUE_APP_BASE_API || process.env.VUE_APP_BASE_API, // eslint-disable-line
  withCredentials: false, // send cookies when cross-domain requests
  timeout: 20000 // request timeout
})
// let loadingInstance
// request interceptor
service.interceptors.request.use(
  config => {
    // loadingInstance = Loading.service({
    //   fullscreen: true,
    //   background: 'rgba(0, 0, 0, 0.0)'
    // })
    if (store.getters.token) {
      config.headers['AUTHPASSWORD'] = store.getters.token.password
      config.headers['AUTHUSER'] = store.getters.token.username
      config.headers['DATABASE'] = 'DIMS'
      config.headers['Cache-Control'] = 'no-cache'
      config.headers['TIMEZONE_NAME'] = 'China Standard Time'
    }
    return config
  },
  error => {
    return Promise.reject(error)
  }
)

// response interceptor
service.interceptors.response.use(
  response => {
    const res = response.data
    // loadingInstance.close()
    return res
  },
  error => {
    var r = error.response
    // loadingInstance.close()
    if (r) {
      if (r.data && r.data.error && r.data.error.message) {
        const msg = r.data.error.message
        if (msg.indexOf('No items of type') > -1) {
          return Promise.resolve({ value: [] })
        }
        //  else {
        //   // Message({
        //   //   message: msg.indexOf('already exists') > -1 ? '不能添加重复项' : msg,
        //   //   type: 'error',
        //   //   duration: 5 * 1000
        //   // })
        //   // disposeErrFun(msg, error.response)
        // }
      } else {
        Message({
          message: error.message,
          type: 'error',
          duration: 5 * 1000
        })
      }
    }

    return Promise.reject(error)
  }
)

const getItems = function(itemType, params) {
  const { currentPage, pageSize } = params
  delete params.currentPage
  delete params.pageSize
  const pageParams = {}
  if (pageSize !== undefined && currentPage !== undefined) {
    pageParams.$skip = pageSize * (currentPage - 1)
    pageParams.$top = pageSize
    const dataQuery = service.get(`/${itemType}`, { params: Object.assign(pageParams, params) })
    delete params.$select
    var countQuery = service.get(`/${itemType}/$count`, { params: params })
    return new Promise((resolve, reject) => {
      Promise.all([dataQuery, countQuery]).then(r => {
        resolve({
          value: r[0].value,
          total: isNaN(r[1]) ? 0 : r[1]
        })
      }).catch(() => {
        resolve({
          value: [],
          total: 0
        })
      })
    })
  } else {
    const dataQuery = service.get(`/${itemType}`, { params })
    return new Promise((resolve, reject) => {
      Promise.all([dataQuery]).then(r => {
        resolve({
          value: r[0].value
        })
      }).catch(() => {
        resolve({
          value: []
        })
      })
    })
  }
}

const get = function(itemType, params) {
  return service.get(`/${itemType}`, {
    params
  })
}
const getItemById = function(itemType, id, params) {
  return service.get(`/${itemType}('${id}')`, {
    params
  })
}
const patch = function(itemType, id, data) {
  return service.patch(`/${itemType}('${id}')`, data)
}

const deleteItem = function(itemType, id) {
  return service.delete(`/${itemType}('${id}')`)
}
const deleteId = function(itemType) {
  return service.delete(`/${itemType}`)
}
const deleteMultiItem = function(itemType, ids) {
  return new Promise((resolve, reject) => {
    const idList = ids
    function recursivedel() {
      deleteItem(itemType, idList[idList.length - 1]).then((res) => {
        idList.pop()
        if (idList.length) {
          return recursivedel()
        } else {
          resolve()
        }
      }).catch(() => {
        return reject()
      })
    }
    recursivedel()
  })
  // return service.delete(`/${itemType}('${id}')`)
}

const deleteItemFunPro = function(itemType, delList, delItemCallback, id, item) {
  return new Promise((resolve, reject) => {
    deleteItem(itemType, id).then(() => {
      delItemCallback ? delItemCallback(item) : ''
      if (delList.length === 0) {
        reject({})
      } else {
        resolve({ itemType, delList, delItemCallback })
      }
    })
  })
}
const deleteItems = function(itemType, items, delItemCallback) {
  return new Promise((resolve, reject) => {
    !(function deleteItemFun(itemType, items, delItemCallback) {
      const delList = JSON.parse(JSON.stringify(items))
      const item = delList.pop()
      const id = item.id
      deleteItemFunPro(itemType, delList, delItemCallback, id, item).then(({ itemType, delList, delItemCallback }) => {
        deleteItemFun(itemType, delList, delItemCallback)
      }).catch(() => {
        resolve({})
      })
    }(itemType, items, delItemCallback))
  })
}
const post = function(itemType, data, header) {
  return service.post(itemType, data, header)
}
const postMultiItem = function(itemTypes, body) {
  return new Promise((resolve, reject) => {
    const idList = itemTypes
    function recursivedel() {
      post(idList[idList.length - 1], body).then((res) => {
        idList.pop()
        if (idList.length) {
          return recursivedel()
        } else {
          resolve()
        }
      }).catch(() => {
        return reject()
      })
    }
    recursivedel()
  })
}
const applyAction = function(itemType, id, method, data) {
  return service.post(`/${itemType}('${id}')/method.${method}`, data)
}

const applyMethod = function(method, data) {
  var requestData = Object.assign({
    '@aras.type': 'Method'
  }, data)
  return service.post(`/method.${method}`, requestData)
}

export default {
  get,
  getItemById,
  post,
  postMultiItem,
  patch,
  getItems,
  deleteId,
  deleteItem,
  deleteItems,
  applyAction,
  applyMethod,
  deleteMultiItem
}