import store from '@/store'
import request, { tenantRequest } from '@/utils/request'
import {
  add,
  update,
  del,
  confirm,
  messageSend,
  send,
  confirmAndSend,
  addTenant,
  addTenantOrOrg,
  addUser
} from './base'
import {
  AssetType,
  SupportedAlarmStrategies
} from '@/constant'

export function getRatiosWithUser () {
  return tenantRequest({
    url: '/device/resolutionRatio',
    method: 'GET',
    params: addTenantOrOrg({})
  }).then(({ data }) => {
    return {
      data: Object.keys(data).map(key => {
        return {
          value: key,
          label: `${key} ${data[key].slice(0, 3).map(device => device.name).join(', ')}`
        }
      })
    }
  })
}

export function getRatios () {
  return tenantRequest({
    url: '/device/resolutionRatio',
    method: 'GET',
    params: addTenant({})
  }).then(({ data }) => {
    return {
      data: Object.keys(data).map(key => {
        return {
          value: key,
          label: key
        }
      })
    }
  })
}

export function getTimeline (deviceId, options) {
  return request({
    url: `/content/deviceCalender/${deviceId}`,
    method: 'GET',
    ...options
  }).then(({ data }) => JSON.parse(data.eventDetail) || [])
}

export function getTimelineByRange (deviceId, startTime, endTime, options) {
  return request({
    url: `/content/deviceCalender/${deviceId}`,
    method: 'GET',
    params: {
      startTime,
      endTime
    },
    ...options
  }).then(({ data }) => JSON.parse(data.eventDetail) || [])
}

export function addDevice (data) {
  return add({
    url: '/device',
    method: 'POST',
    data
  })
}

export function updateDevice (data) {
  return update({
    url: '/device',
    method: 'PUT',
    data
  })
}

function deleteDeviceById (id) {
  return messageSend({
    url: `/device/${id}`,
    method: 'DELETE'
  }, '删除')
}

export function deleteDevice ({ id, name, masterId }) {
  if (__SUB_DEVICE__) {
    if (masterId) {
      return confirm(`删除备份设备【${name}】？`).then(() => deleteDeviceById(id))
    }
    return send({
      url: `/device/${id}/standbyDevice`,
      method: 'GET',
      params: { pageNum: 1, pageSize: 1 }
    }).then(({ data }) => confirm(
      data.length
        ? `删除主设备【${name}】后备份设备也将删除`
        : `删除设备【${name}】？`
    )).then(() => deleteDeviceById(id))
  }
  return confirm(`删除设备【${name}】？`).then(() => deleteDeviceById(id))
}

// isAttentionFlag 是否带关注标识位，开启值为1
// attentionValue 过滤值，2为不过滤
export function getDevices (query, options) {
  return getDevicesByQuery(addTenantOrOrg(query), options)
}

export function getDevicesByQuery (query, options) {
  const { tenant, org, ...params } = query
  if (tenant || org && org === store.getters.tenant) {
    return getDevicesByTenant(tenant || org, params, options)
  }
  return getDevicesByOrg(org, params, options)
}

export function getDevicesByTenant (tenant, query, options) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return tenantRequest({
    url: '/device/tenant/page',
    method: 'GET',
    params: {
      tenant,
      pageIndex,
      pageSize,
      ...params
    },
    ...options
  })
}

export function getDevicesByOrg (org, query, options) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return tenantRequest({
    url: '/device/relation/page',
    method: 'GET',
    params: {
      org,
      pageIndex,
      pageSize,
      ...params
    },
    ...options
  })
}

export function activateDevice ({ id, name }) {
  return confirmAndSend('激活', name, {
    url: '/device/batch/activate',
    method: 'PUT',
    data: [id]
  })
}

export function deactivateDevice ({ id, name }) {
  return confirmAndSend('停用', name, {
    url: '/device/batch/deactivate',
    method: 'PUT',
    data: [id]
  })
}

export function getDevice (id) {
  return request({
    url: `/device/${id}`,
    method: 'GET'
  })
}

export function getSubDevices (query) {
  const { id, pageNum: pageIndex, pageSize, ...params } = query
  return request({
    url: `/device/${id}/standbyDevice`,
    method: 'GET',
    params: {
      pageIndex, pageSize,
      ...params
    }
  })
}

export function addSubDevice ({ id }, data) {
  return add({
    url: `/device/${id}/addStandby`,
    method: 'POST',
    data
  })
}

export function addProductType (data) {
  return add({
    url: '/productType',
    method: 'POST',
    data
  })
}

export function updateProductType (data) {
  return update({
    url: '/productType',
    method: 'put',
    data
  })
}

export function deleteProductType ({ id, name }) {
  return del({
    url: `/productType/${id}`,
    method: 'DELETE'
  }, name)
}

export function getProductTypes (query) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return tenantRequest({
    url: '/productType/list',
    method: 'GET',
    params: addTenant({
      pageIndex, pageSize,
      ...params
    })
  })
}

export function addProduct (data) {
  return add({
    url: '/product',
    method: 'POST',
    data
  })
}

export function updateProduct (data) {
  return update({
    url: '/product',
    method: 'put',
    data
  })
}

export function deleteProduct ({ id, name }) {
  return del({
    url: `/product/${id}`,
    method: 'DELETE'
  }, name)
}

const productMap = {}
export function getProduct (id) {
  if (productMap[id]) {
    return Promise.resolve({ data: productMap[id] })
  }
  return request({
    url: `/product/${id}`,
    method: 'GET'
  }).then(({ data }) => {
    if (data) {
      productMap[id] = data
    }
    return { data }
  })
}

export function getProducts (query) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return tenantRequest({
    url: '/product/list',
    method: 'GET',
    params: addTenant({
      pageIndex, pageSize,
      ...params
    })
  })
}

export function addDeviceGroup (data) {
  return add({
    url: '/deviceGroup',
    method: 'POST',
    data
  })
}

export function updateDeviceGroup (data) {
  return update({
    url: '/deviceGroup',
    method: 'PUT',
    data
  })
}

export function deleteDeviceGroup ({ id, name }) {
  return del({
    url: `/deviceGroup/${id}`,
    method: 'DELETE'
  }, name)
}

export function getDeviceGroups (query) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return tenantRequest({
    url: '/deviceGroup/list',
    method: 'GET',
    params: addUser({
      pageIndex, pageSize,
      ...params
    })
  })
}

export function getDevicesByGroup (id) {
  return tenantRequest({
    url: `/deviceGroup/${id}/device`,
    method: 'GET',
    params: addTenantOrOrg({})
  })
}

export function getDeviceTree () {
  return tenantRequest({
    url: '/deviceGroup/deviceTree',
    method: 'GET',
    params: addUser(addTenantOrOrg({}))
  })
}

export function addDevicesToGroup (id, deviceIds) {
  return add({
    url: `/deviceGroup/${id}/device`,
    method: 'POST',
    data: deviceIds
  })
}

export function deleteDeviceFromGroup (id, { id: deviceId, name }) {
  return confirmAndSend('移除', name, {
    url: `/deviceGroup/${id}/device`,
    method: 'DELETE',
    params: { deviceId }
  })
}

export function getDeviceStatistics () {
  return getDeviceStatisticsByPath(store.getters.org)
}

export function getDeviceStatisticsByPath (path, options) {
  return tenantRequest({
    url: '/device/listDeviceTotal',
    method: 'GET',
    params: path === store.getters.tenant
      ? { tenant: path }
      : { org: path },
    ...options
  })
}

const handeEnum = ['应用重启', '设备重启', '恢复出厂', '未干预']
const typeEnum = ['primary', 'success', 'danger']
const labelEnum = ['处理中', '成功', '失败']

export function getDeviceAlarms (query) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return request({
    url: '/deviceException/list',
    method: 'GET',
    params: {
      pageIndex, pageSize,
      ...params
    }
  }).then(({ data, totalCount }) => {
    return {
      data: data.map(({ id, messageId, deviceName, level, pic, picUrl, type, handle, status, happenTime, bugMessage, ...item }) => {
        const alarm = {
          id, messageId, deviceName, level, happenTime,
          file: pic && picUrl
            ? {
              type: AssetType.IMAGE,
              url: picUrl,
              origin: true
            }
            : null,
          type: bugMessage || `预警码【${type}】`,
          handle: handeEnum[handle] || '-',
          status: handle <= 2 && status <= 2
            ? {
              type: typeEnum[status],
              label: labelEnum[status]
            }
            : { label: '-' }
        }
        SupportedAlarmStrategies.forEach(({ key }) => {
          alarm[key] = getTag(item[key])
        })
        return alarm
      }),
      totalCount
    }
  })
}

function getTag (status) {
  switch (status) {
    case 0:
      return {
        type: 'primary',
        label: '待发送'
      }
    case 1:
      return {
        type: 'success',
        label: '已发送'
      }
    case 2:
      return {
        type: 'warning',
        label: '发送中'
      }
    case 3:
      return {
        type: 'danger',
        label: '失败'
      }
    case 4:
      return {
        type: 'danger',
        label: '无目标'
      }
    case 5:
      return {
        type: 'warning',
        label: '未开启'
      }
    default:
      return null
  }
}

export function getUsersByInform ({ messageId }) {
  return send({
    url: '/deviceException/user/list',
    method: 'GET',
    params: { messageId }
  })
}

export function getTasks (query) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return request({
    url: '/device/functionTask',
    method: 'GET',
    params: {
      pageIndex, pageSize,
      ...params
    }
  })
}

export function addTask (task) {
  return add({
    url: '/device/functionTask',
    method: 'POST',
    data: task
  })
}

export function updateTask (task) {
  return update({
    url: '/device/functionTask',
    method: 'PUT',
    data: task
  })
}

export function deleteTask ({ taskId }) {
  return del({
    url: `/device/functionTask/${taskId}`,
    method: 'DELETE'
  })
}

export function activateTask ({ taskId }) {
  return confirmAndSend('启用', null, {
    url: '/device/functionTask/resume',
    method: 'PUT',
    data: [taskId]
  })
}

export function deactivateTask ({ taskId }) {
  return confirmAndSend('停用', null, {
    url: '/device/functionTask/pause',
    method: 'PUT',
    data: [taskId]
  })
}

export function getShadow (deviceId) {
  return request({
    url: `/device/shadow/${deviceId}`,
    method: 'GET'
  })
}

export function getRecordConfig (deviceId, config) {
  return request({
    url: '/deviceStream/config',
    method: 'GET',
    params: { deviceId },
    ...config
  })
}

export function addRecordConfig (data, config) {
  return request({
    url: '/deviceStream/config',
    method: 'POST',
    data,
    ...config
  })
}

export function updateRecordConfig (data, config) {
  return request({
    url: '/deviceStream/config',
    method: 'PUT',
    data,
    ...config
  })
}

export function authCode (stream, options) {
  return request({
    url: `/deviceStream/${stream}/authCode`,
    method: 'GET',
    ...options
  })
}

export function addDeviceAttention (deviceId) {
  return update({
    url: `/device/attention/add/${deviceId}`,
    method: 'POST',
    data: { deviceId }
  }, '关注')
}

export function cancelDeviceAttention (deviceId) {
  return update({
    url: `/device/attention/cancel/${deviceId}`,
    method: 'DELETE'
  }, '取关')
}

export function getDeviceAttentionList (options) {
  return request({
    url: '/device/user/attention/list',
    method: 'GET',
    ...options
  })
}

export function getStatusReport (id, options) {
  return request({
    url: '/device/screenPower/latestStatusReport',
    method: 'POST',
    data: { deviceIds: id },
    ...options
  })
}

export function getDevicesWithPower (params) {
  return request({
    url: '/device/bond/multiFunction/list',
    method: 'GET',
    params
  })
}

export function getDepartmentDeviceTree (options) {
  return getDepartmentDeviceTreeByGroup(store.getters.org, options)
}

export function getDepartmentDeviceTreeByGroup (path, options) {
  const data = addTenant()
  if (path && path !== data.tenant) {
    data.org = path
  }
  return tenantRequest({
    url: '/admin/department/device/list',
    method: 'GET',
    params: data,
    ...options
  })
}