import XEUtils from 'xe-utils'
import { getUserDataPath } from './applet'

export function getFileSuffix (filename: string) {
  const pos = filename.lastIndexOf('.')
  let suffix = ''
  if (pos !== -1) {
    suffix = filename.substring(pos + 1)
  }
  return suffix
}

export function getFileName (url: string) {
  const urlRest = XEUtils.parseUrl(url)
  return urlRest.pathname.split('/').slice(-1)[0] || ''
}

export function getAllPreviewTypes () {
  return [...getFilePreviewTypes(), ...getImagePreviewTypes(), ...getVideoPreviewTypes()]
}

export function hasAllPreviewType (fileType: string) {
  return getAllPreviewTypes().includes(XEUtils.toValueString(fileType).toLowerCase())
}

export function getFilePreviewTypes () {
  return ['doc', 'xls', 'ppt', 'pdf', 'docx', 'xlsx', 'pptx']
}

export function hasFilePreviewType (fileType: string) {
  return getFilePreviewTypes().includes(XEUtils.toValueString(fileType).toLowerCase())
}

export function getImagePreviewTypes () {
  return ['png', 'jpg', 'gif', 'jpeg']
}

export function hasImagePreviewType (fileType: string) {
  return getImagePreviewTypes().includes(XEUtils.toValueString(fileType).toLowerCase())
}

export function getVideoPreviewTypes () {
  return ['mp4']
}

export function hasVideoPreviewType (fileType: string) {
  return getVideoPreviewTypes().includes(XEUtils.toValueString(fileType).toLowerCase())
}

/**
 * 图片预览
 * @returns
 */
export function openImageByUrls (imgUrls: string[], activeIndex?: number) {
  return new Promise((resolve, reject) => {
    Promise.all(
      imgUrls.map(fileUrl => {
        return new Promise((resolve) => {
          uni.downloadFile({
            url: decodeURIComponent(fileUrl),
            success: (downRes) => {
              resolve({
                url: downRes.tempFilePath
              })
            },
            fail () {
              resolve({
                url: ''
              })
            }
          })
        })
      })
    ).then(res => {
      uni.previewImage({
        current: activeIndex || 0,
        urls: res.map((item: any) => item.url),
        longPressActions: {
          itemList: ['保存图片']
        },
        success () {
          resolve({
            filePaths: res.map((item: any) => item.url)
          })
        },
        fail (e) {
          reject(e)
        }
      })
    })
  })
}

/**
 * 附件预览
 * @param {*} fileUrl
 * @param {*} name
 * @param {*} options
 * @returns
 */
export function openFileByUrl (fileUrl: string, fileName: string, options?: any) {
  const opts = Object.assign({ type: '' }, options)
  const url = decodeURIComponent(fileUrl)
  const name = fileName || getFileName(url)
  return new Promise((resolve, reject) => {
    const fileType = opts.type || getFileSuffix(name || getFileName(url)).toLowerCase()
    uni.downloadFile({
      url,
      filePath: name ? `${getUserDataPath()}/${name.indexOf('.') === -1 ? `${name}.${fileType}` : name}` : '',
      success: (downRes) => {
        if (getFilePreviewTypes().includes(fileType)) {
          uni.openDocument({
            filePath: downRes.filePath || downRes.tempFilePath,
            showMenu: true,
            success () {
              resolve({
                filePath: downRes.filePath || downRes.tempFilePath
              })
            },
            fail (e) {
              reject(e)
            }
          })
        } else if (getImagePreviewTypes().includes(fileType)) {
          uni.previewImage({
            urls: [
              downRes.filePath || downRes.tempFilePath
            ],
            longPressActions: {
              itemList: ['保存图片']
            },
            success () {
              resolve({
                filePath: downRes.filePath || downRes.tempFilePath
              })
            },
            fail (e) {
              reject(e)
            }
          })
        } else {
          const e = {}
          reject(e)
        }
      },
      fail (e) {
        reject(e)
      }
    })
  })
}

/**
 * 下载文件
 * @param {*} url
 * @param {*} name
 */
export function saveFileByUrl (fileUrl: string, fileName: string, options?: any) {
  const opts = Object.assign({ showMsg: true }, options)
  const url = decodeURIComponent(fileUrl)
  const name = fileName || getFileName(url)
  return new Promise((resolve, reject) => {
    const fileType = opts.type || getFileSuffix(name || getFileName(url)).toLowerCase()
    uni.downloadFile({
      url,
      filePath: name ? `${getUserDataPath()}/${name.indexOf('.') === -1 ? `${name}.${fileType}` : name}` : '',
      success: (downRes) => {
        uni.saveFile({
          tempFilePath: downRes.filePath || downRes.tempFilePath,
          success (res) {
            if (opts.showMsg) {
              uni.showToast({
                icon: 'none',
                mask: false,
                title: '文件已保存：' + res.savedFilePath,
                duration: 4000
              })
            }
            resolve({
              filePath: res.savedFilePath
            })
          }
        })
      },
      fail (e) {
        reject(e)
      }
    })
  })
}