import { basename, extname } from 'node:path'

import { Injectable } from '@nestjs/common'
import { ConfigService } from '@nestjs/config'
import { isEmpty } from 'lodash'
import * as qiniu from 'qiniu'
import { auth, conf, rs } from 'qiniu'

import { ConfigKeyPaths } from '~/config'
import { NETDISK_COPY_SUFFIX, NETDISK_DELIMITER, NETDISK_HANDLE_MAX_ITEM, NETDISK_LIMIT } from '~/constants/oss.constant'

import { AccountInfo } from '~/modules/user/user.model'
import { UserService } from '~/modules/user/user.service'

import { generateRandomValue } from '~/utils'

import { SFileInfo, SFileInfoDetail, SFileList } from './manage.class'
import { FileOpItem } from './manage.dto'

@Injectable()
export class NetDiskManageService {
  private config: conf.ConfigOptions
  private mac: auth.digest.Mac
  private bucketManager: rs.BucketManager

  private get qiniuConfig() {
    return this.configService.get('oss', { infer: true })
  }

  constructor(
    private configService: ConfigService<ConfigKeyPaths>,
    private userService: UserService,
  ) {
    this.mac = new qiniu.auth.digest.Mac(
      this.qiniuConfig.accessKey,
      this.qiniuConfig.secretKey,
    )
    this.config = new qiniu.conf.Config({
      zone: this.qiniuConfig.zone,
    })
    // bucket manager
    this.bucketManager = new qiniu.rs.BucketManager(this.mac, this.config)
  }

  /**
   * 获取文件列表
   * @param prefix 当前文件夹路径，搜索模式下会被忽略
   * @param marker 下一页标识
   * @returns iFileListResult
   */
  async getFileList(prefix = '', marker = '', skey = ''): Promise<SFileList> {
    // 是否需要搜索
    const searching = !isEmpty(skey)
    return new Promise<SFileList>((resolve, reject) => {
      this.bucketManager.listPrefix(
        this.qiniuConfig.bucket,
        {
          prefix: searching ? '' : prefix,
          limit: NETDISK_LIMIT,
          delimiter: searching ? '' : NETDISK_DELIMITER,
          marker,
        },
        (err, respBody, respInfo) => {
          if (err) {
            reject(err)
            return
          }
          if (respInfo.statusCode === 200) {
            // 如果这个nextMarker不为空，那么还有未列举完毕的文件列表，下次调用listPrefix的时候，
            // 指定options里面的marker为这个值
            const fileList: SFileInfo[] = []
            // 处理目录，但只有非搜索模式下可用
            if (!searching && !isEmpty(respBody.commonPrefixes)) {
              // dir
              for (const dirPath of respBody.commonPrefixes) {
                const name = (dirPath as string)
                  .substr(0, dirPath.length - 1)
                  .replace(prefix, '')
                if (isEmpty(skey) || name.includes(skey)) {
                  fileList.push({
                    name: (dirPath as string)
                      .substr(0, dirPath.length - 1)
                      .replace(prefix, ''),
                    type: 'dir',
                    id: generateRandomValue(10),
                  })
                }
              }
            }
            // handle items
            if (!isEmpty(respBody.items)) {
              // file
              for (const item of respBody.items) {
                // 搜索模式下处理
                if (searching) {
                  const pathList: string[] = item.key.split(NETDISK_DELIMITER)
                  // dir is empty stirng, file is key string
                  const name = pathList.pop()
                  if (
                    item.key.endsWith(NETDISK_DELIMITER)
                    && pathList[pathList.length - 1].includes(skey)
                  ) {
                    // 结果是目录
                    const ditName = pathList.pop()
                    fileList.push({
                      id: generateRandomValue(10),
                      name: ditName,
                      type: 'dir',
                      belongTo: pathList.join(NETDISK_DELIMITER),
                    })
                  }
                  else if (name.includes(skey)) {
                    // 文件
                    fileList.push({
                      id: generateRandomValue(10),
                      name,
                      type: 'file',
                      fsize: item.fsize,
                      mimeType: item.mimeType,
                      putTime: new Date(Number.parseInt(item.putTime) / 10000),
                      belongTo: pathList.join(NETDISK_DELIMITER),
                    })
                  }
                }
                else {
                  // 正常获取列表
                  const fileKey = item.key.replace(prefix, '') as string
                  if (!isEmpty(fileKey)) {
                    fileList.push({
                      id: generateRandomValue(10),
                      name: fileKey,
                      type: 'file',
                      fsize: item.fsize,
                      mimeType: item.mimeType,
                      putTime: new Date(Number.parseInt(item.putTime) / 10000),
                    })
                  }
                }
              }
            }
            resolve({
              list: fileList,
              marker: respBody.marker || null,
            })
          }
          else {
            reject(
              new Error(
                `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
              ),
            )
          }
        },
      )
    })
  }

  /**
   * 获取文件信息
   */
  async getFileInfo(name: string, path: string): Promise<SFileInfoDetail> {
    return new Promise((resolve, reject) => {
      this.bucketManager.stat(
        this.qiniuConfig.bucket,
        `${path}${name}`,
        (err, respBody, respInfo) => {
          if (err) {
            reject(err)
            return
          }
          if (respInfo.statusCode === 200) {
            const detailInfo: SFileInfoDetail = {
              fsize: respBody.fsize,
              hash: respBody.hash,
              md5: respBody.md5,
              mimeType: respBody.mimeType.split('/x-qn-meta')[0],
              putTime: new Date(Number.parseInt(respBody.putTime) / 10000),
              type: respBody.type,
              uploader: '',
              mark: respBody?.['x-qn-meta']?.['!mark'] ?? '',
            }
            if (!respBody.endUser) {
              resolve(detailInfo)
            }
            else {
              this.userService
                .getAccountInfo(Number.parseInt(respBody.endUser))
                .then((user: AccountInfo) => {
                  if (isEmpty(user)) {
                    resolve(detailInfo)
                  }
                  else {
                    detailInfo.uploader = user.username
                    resolve(detailInfo)
                  }
                })
            }
          }
          else {
            reject(
              new Error(
                `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
              ),
            )
          }
        },
      )
    })
  }

  /**
   * 修改文件MimeType
   */
  async changeFileHeaders(
    name: string,
    path: string,
    headers: { [k: string]: string },
  ): Promise<void> {
    return new Promise((resolve, reject) => {
      this.bucketManager.changeHeaders(
        this.qiniuConfig.bucket,
        `${path}${name}`,
        headers,
        (err, _, respInfo) => {
          if (err) {
            reject(err)
            return
          }
          if (respInfo.statusCode === 200) {
            resolve()
          }
          else {
            reject(
              new Error(
                `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
              ),
            )
          }
        },
      )
    })
  }

  /**
   * 创建文件夹
   * @returns true创建成功
   */
  async createDir(dirName: string): Promise<void> {
    const safeDirName = dirName.endsWith('/') ? dirName : `${dirName}/`
    return new Promise((resolve, reject) => {
      // 上传一个空文件以用于显示文件夹效果
      const formUploader = new qiniu.form_up.FormUploader(this.config)
      const putExtra = new qiniu.form_up.PutExtra()
      formUploader.put(
        this.createUploadToken(''),
        safeDirName,
        ' ',
        putExtra,
        (respErr, respBody, respInfo) => {
          if (respErr) {
            reject(respErr)
            return
          }
          if (respInfo.statusCode === 200) {
            resolve()
          }
          else {
            reject(
              new Error(
                `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
              ),
            )
          }
        },
      )
    })
  }

  /**
   * 检查文件是否存在，同可检查目录
   */
  async checkFileExist(filePath: string): Promise<boolean> {
    return new Promise((resolve, reject) => {
      // fix path end must a /

      // 检测文件夹是否存在
      this.bucketManager.stat(
        this.qiniuConfig.bucket,
        filePath,
        (respErr, respBody, respInfo) => {
          if (respErr) {
            reject(respErr)
            return
          }
          if (respInfo.statusCode === 200) {
            // 文件夹存在
            resolve(true)
          }
          else if (respInfo.statusCode === 612) {
            // 文件夹不存在
            resolve(false)
          }
          else {
            reject(
              new Error(
                `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
              ),
            )
          }
        },
      )
    })
  }

  /**
   * 创建Upload Token, 默认过期时间一小时
   * @returns upload token
   */
  createUploadToken(endUser: string): string {
    const policy = new qiniu.rs.PutPolicy({
      scope: this.qiniuConfig.bucket,
      insertOnly: 1,
      fsizeLimit: 1024 ** 2 * 10,
      endUser,
    })
    const uploadToken = policy.uploadToken(this.mac)
    return uploadToken
  }

  /**
   * 重命名文件
   * @param dir 文件路径
   * @param name 文件名称
   */
  async renameFile(dir: string, name: string, toName: string): Promise<void> {
    const fileName = `${dir}${name}`
    const toFileName = `${dir}${toName}`
    const op = {
      force: true,
    }
    return new Promise((resolve, reject) => {
      this.bucketManager.move(
        this.qiniuConfig.bucket,
        fileName,
        this.qiniuConfig.bucket,
        toFileName,
        op,
        (err, respBody, respInfo) => {
          if (err) {
            reject(err)
          }
          else {
            if (respInfo.statusCode === 200) {
              resolve()
            }
            else {
              reject(
                new Error(
                  `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
                ),
              )
            }
          }
        },
      )
    })
  }

  /**
   * 移动文件
   */
  async moveFile(dir: string, toDir: string, name: string): Promise<void> {
    const fileName = `${dir}${name}`
    const toFileName = `${toDir}${name}`
    const op = {
      force: true,
    }
    return new Promise((resolve, reject) => {
      this.bucketManager.move(
        this.qiniuConfig.bucket,
        fileName,
        this.qiniuConfig.bucket,
        toFileName,
        op,
        (err, respBody, respInfo) => {
          if (err) {
            reject(err)
          }
          else {
            if (respInfo.statusCode === 200) {
              resolve()
            }
            else {
              reject(
                new Error(
                  `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
                ),
              )
            }
          }
        },
      )
    })
  }

  /**
   * 复制文件
   */
  async copyFile(dir: string, toDir: string, name: string): Promise<void> {
    const fileName = `${dir}${name}`
    // 拼接文件名
    const ext = extname(name)
    const bn = basename(name, ext)
    const toFileName = `${toDir}${bn}${NETDISK_COPY_SUFFIX}${ext}`
    const op = {
      force: true,
    }
    return new Promise((resolve, reject) => {
      this.bucketManager.copy(
        this.qiniuConfig.bucket,
        fileName,
        this.qiniuConfig.bucket,
        toFileName,
        op,
        (err, respBody, respInfo) => {
          if (err) {
            reject(err)
          }
          else {
            if (respInfo.statusCode === 200) {
              resolve()
            }
            else {
              reject(
                new Error(
                  `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
                ),
              )
            }
          }
        },
      )
    })
  }

  /**
   * 重命名文件夹
   */
  async renameDir(path: string, name: string, toName: string): Promise<void> {
    const dirName = `${path}${name}`
    const toDirName = `${path}${toName}`
    let hasFile = true
    let marker = ''
    const op = {
      force: true,
    }
    const bucketName = this.qiniuConfig.bucket
    while (hasFile) {
      await new Promise<void>((resolve, reject) => {
        // 列举当前目录下的所有文件
        this.bucketManager.listPrefix(
          this.qiniuConfig.bucket,
          {
            prefix: dirName,
            limit: NETDISK_HANDLE_MAX_ITEM,
            marker,
          },
          (err, respBody, respInfo) => {
            if (err) {
              reject(err)
              return
            }
            if (respInfo.statusCode === 200) {
              const moveOperations = respBody.items.map((item) => {
                const { key } = item
                const destKey = key.replace(dirName, toDirName)
                return qiniu.rs.moveOp(
                  bucketName,
                  key,
                  bucketName,
                  destKey,
                  op,
                )
              })
              this.bucketManager.batch(
                moveOperations,
                (err2, respBody2, respInfo2) => {
                  if (err2) {
                    reject(err2)
                    return
                  }
                  if (respInfo2.statusCode === 200) {
                    if (isEmpty(respBody.marker))
                      hasFile = false
                    else
                      marker = respBody.marker

                    resolve()
                  }
                  else {
                    reject(
                      new Error(
                        `Qiniu Error Code: ${respInfo2.statusCode}, Info: ${respInfo2.statusMessage}`,
                      ),
                    )
                  }
                },
              )
            }
            else {
              reject(
                new Error(
                  `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
                ),
              )
            }
          },
        )
      })
    }
  }

  /**
   * 获取七牛下载的文件url链接
   * @param key 文件路径
   * @returns 连接
   */
  getDownloadLink(key: string): string {
    if (this.qiniuConfig.access === 'public') {
      return this.bucketManager.publicDownloadUrl(this.qiniuConfig.domain, key)
    }
    else if (this.qiniuConfig.access === 'private') {
      return this.bucketManager.privateDownloadUrl(
        this.qiniuConfig.domain,
        key,
        Date.now() / 1000 + 36000,
      )
    }
    throw new Error('qiniu config access type not support')
  }

  /**
   * 删除文件
   * @param dir 删除的文件夹目录
   * @param name 文件名
   */
  async deleteFile(dir: string, name: string): Promise<void> {
    return new Promise((resolve, reject) => {
      this.bucketManager.delete(
        this.qiniuConfig.bucket,
        `${dir}${name}`,
        (err, respBody, respInfo) => {
          if (err) {
            reject(err)
            return
          }
          if (respInfo.statusCode === 200) {
            resolve()
          }
          else {
            reject(
              new Error(
                `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
              ),
            )
          }
        },
      )
    })
  }

  /**
   * 删除文件夹
   * @param dir 文件夹所在的上级目录
   * @param name 文件目录名称
   */
  async deleteMultiFileOrDir(
    fileList: FileOpItem[],
    dir: string,
  ): Promise<void> {
    const files = fileList.filter(item => item.type === 'file')
    if (files.length > 0) {
      // 批处理文件
      const copyOperations = files.map((item) => {
        const fileName = `${dir}${item.name}`
        return qiniu.rs.deleteOp(this.qiniuConfig.bucket, fileName)
      })
      await new Promise<void>((resolve, reject) => {
        this.bucketManager.batch(copyOperations, (err, respBody, respInfo) => {
          if (err) {
            reject(err)
            return
          }
          if (respInfo.statusCode === 200) {
            resolve()
          }
          else if (respInfo.statusCode === 298) {
            reject(new Error('操作异常，但部分文件夹删除成功'))
          }
          else {
            reject(
              new Error(
                `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
              ),
            )
          }
        })
      })
    }
    // 处理文件夹
    const dirs = fileList.filter(item => item.type === 'dir')
    if (dirs.length > 0) {
      // 处理文件夹的复制
      for (let i = 0; i < dirs.length; i++) {
        const dirName = `${dir}${dirs[i].name}/`
        let hasFile = true
        let marker = ''
        while (hasFile) {
          await new Promise<void>((resolve, reject) => {
            // 列举当前目录下的所有文件
            this.bucketManager.listPrefix(
              this.qiniuConfig.bucket,
              {
                prefix: dirName,
                limit: NETDISK_HANDLE_MAX_ITEM,
                marker,
              },
              (err, respBody, respInfo) => {
                if (err) {
                  reject(err)
                  return
                }
                if (respInfo.statusCode === 200) {
                  const moveOperations = respBody.items.map((item) => {
                    const { key } = item
                    return qiniu.rs.deleteOp(this.qiniuConfig.bucket, key)
                  })
                  this.bucketManager.batch(
                    moveOperations,
                    (err2, respBody2, respInfo2) => {
                      if (err2) {
                        reject(err2)
                        return
                      }
                      if (respInfo2.statusCode === 200) {
                        if (isEmpty(respBody.marker))
                          hasFile = false
                        else
                          marker = respBody.marker

                        resolve()
                      }
                      else {
                        reject(
                          new Error(
                            `Qiniu Error Code: ${respInfo2.statusCode}, Info: ${respInfo2.statusMessage}`,
                          ),
                        )
                      }
                    },
                  )
                }
                else {
                  reject(
                    new Error(
                      `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
                    ),
                  )
                }
              },
            )
          })
        }
      }
    }
  }

  /**
   * 复制文件，含文件夹
   */
  async copyMultiFileOrDir(
    fileList: FileOpItem[],
    dir: string,
    toDir: string,
  ): Promise<void> {
    const files = fileList.filter(item => item.type === 'file')
    const op = {
      force: true,
    }
    if (files.length > 0) {
      // 批处理文件
      const copyOperations = files.map((item) => {
        const fileName = `${dir}${item.name}`
        // 拼接文件名
        const ext = extname(item.name)
        const bn = basename(item.name, ext)
        const toFileName = `${toDir}${bn}${NETDISK_COPY_SUFFIX}${ext}`
        return qiniu.rs.copyOp(
          this.qiniuConfig.bucket,
          fileName,
          this.qiniuConfig.bucket,
          toFileName,
          op,
        )
      })
      await new Promise<void>((resolve, reject) => {
        this.bucketManager.batch(copyOperations, (err, respBody, respInfo) => {
          if (err) {
            reject(err)
            return
          }
          if (respInfo.statusCode === 200) {
            resolve()
          }
          else if (respInfo.statusCode === 298) {
            reject(new Error('操作异常，但部分文件夹删除成功'))
          }
          else {
            reject(
              new Error(
                `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
              ),
            )
          }
        })
      })
    }
    // 处理文件夹
    const dirs = fileList.filter(item => item.type === 'dir')
    if (dirs.length > 0) {
      // 处理文件夹的复制
      for (let i = 0; i < dirs.length; i++) {
        const dirName = `${dir}${dirs[i].name}/`
        const copyDirName = `${toDir}${dirs[i].name}${NETDISK_COPY_SUFFIX}/`
        let hasFile = true
        let marker = ''
        while (hasFile) {
          await new Promise<void>((resolve, reject) => {
            // 列举当前目录下的所有文件
            this.bucketManager.listPrefix(
              this.qiniuConfig.bucket,
              {
                prefix: dirName,
                limit: NETDISK_HANDLE_MAX_ITEM,
                marker,
              },
              (err, respBody, respInfo) => {
                if (err) {
                  reject(err)
                  return
                }
                if (respInfo.statusCode === 200) {
                  const moveOperations = respBody.items.map((item) => {
                    const { key } = item
                    const destKey = key.replace(dirName, copyDirName)
                    return qiniu.rs.copyOp(
                      this.qiniuConfig.bucket,
                      key,
                      this.qiniuConfig.bucket,
                      destKey,
                      op,
                    )
                  })
                  this.bucketManager.batch(
                    moveOperations,
                    (err2, respBody2, respInfo2) => {
                      if (err2) {
                        reject(err2)
                        return
                      }
                      if (respInfo2.statusCode === 200) {
                        if (isEmpty(respBody.marker))
                          hasFile = false
                        else
                          marker = respBody.marker

                        resolve()
                      }
                      else {
                        reject(
                          new Error(
                            `Qiniu Error Code: ${respInfo2.statusCode}, Info: ${respInfo2.statusMessage}`,
                          ),
                        )
                      }
                    },
                  )
                }
                else {
                  reject(
                    new Error(
                      `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
                    ),
                  )
                }
              },
            )
          })
        }
      }
    }
  }

  /**
   * 移动文件，含文件夹
   */
  async moveMultiFileOrDir(
    fileList: FileOpItem[],
    dir: string,
    toDir: string,
  ): Promise<void> {
    const files = fileList.filter(item => item.type === 'file')
    const op = {
      force: true,
    }
    if (files.length > 0) {
      // 批处理文件
      const copyOperations = files.map((item) => {
        const fileName = `${dir}${item.name}`
        const toFileName = `${toDir}${item.name}`
        return qiniu.rs.moveOp(
          this.qiniuConfig.bucket,
          fileName,
          this.qiniuConfig.bucket,
          toFileName,
          op,
        )
      })
      await new Promise<void>((resolve, reject) => {
        this.bucketManager.batch(copyOperations, (err, respBody, respInfo) => {
          if (err) {
            reject(err)
            return
          }
          if (respInfo.statusCode === 200) {
            resolve()
          }
          else if (respInfo.statusCode === 298) {
            reject(new Error('操作异常，但部分文件夹删除成功'))
          }
          else {
            reject(
              new Error(
                `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
              ),
            )
          }
        })
      })
    }
    // 处理文件夹
    const dirs = fileList.filter(item => item.type === 'dir')
    if (dirs.length > 0) {
      // 处理文件夹的复制
      for (let i = 0; i < dirs.length; i++) {
        const dirName = `${dir}${dirs[i].name}/`
        const toDirName = `${toDir}${dirs[i].name}/`
        // 移动的目录不是是自己
        if (toDirName.startsWith(dirName))
          continue

        let hasFile = true
        let marker = ''
        while (hasFile) {
          await new Promise<void>((resolve, reject) => {
            // 列举当前目录下的所有文件
            this.bucketManager.listPrefix(
              this.qiniuConfig.bucket,
              {
                prefix: dirName,
                limit: NETDISK_HANDLE_MAX_ITEM,
                marker,
              },
              (err, respBody, respInfo) => {
                if (err) {
                  reject(err)
                  return
                }
                if (respInfo.statusCode === 200) {
                  const moveOperations = respBody.items.map((item) => {
                    const { key } = item
                    const destKey = key.replace(dirName, toDirName)
                    return qiniu.rs.moveOp(
                      this.qiniuConfig.bucket,
                      key,
                      this.qiniuConfig.bucket,
                      destKey,
                      op,
                    )
                  })
                  this.bucketManager.batch(
                    moveOperations,
                    (err2, respBody2, respInfo2) => {
                      if (err2) {
                        reject(err2)
                        return
                      }
                      if (respInfo2.statusCode === 200) {
                        if (isEmpty(respBody.marker))
                          hasFile = false
                        else
                          marker = respBody.marker

                        resolve()
                      }
                      else {
                        reject(
                          new Error(
                            `Qiniu Error Code: ${respInfo2.statusCode}, Info: ${respInfo2.statusMessage}`,
                          ),
                        )
                      }
                    },
                  )
                }
                else {
                  reject(
                    new Error(
                      `Qiniu Error Code: ${respInfo.statusCode}, Info: ${respInfo.statusMessage}`,
                    ),
                  )
                }
              },
            )
          })
        }
      }
    }
  }
}