import { BookBackTaskListService } from '../../define/db/service/Book/bookBackTaskListService'
import { BookService } from '../../define/db/service/Book/bookService'
import { BookTaskDetailService } from '../../define/db/service/Book/bookTaskDetailService'
import { BookTaskService } from '../../define/db/service/Book/bookTaskService'
import { OtherData } from '../../define/enum/softwareEnum'
import { BookBackTaskStatus, BookBackTaskType, TaskExecuteType } from '../../define/enum/bookEnum'
import { isEmpty } from 'lodash'
import { SoftwareService } from '../../define/db/service/SoftWare/softwareService'
import { errorMessage, successMessage } from '../generalTools'
import { BasicReverse } from './basicReverse'

export class TaskManager {
  constructor() {
    this.isExecuting = false
    this.currentTaskList = []
    this.globalConfig = global.config
    // this.taskExecute = new TaskExecute()
    this.basicReverse = new BasicReverse()
  }

  /**
   * 初始化服务
   */
  async InitService() {
    if (!this.softwareService) {
      this.softwareService = await SoftwareService.getInstance()
    }
    if (!this.bookBackTaskListService) {
      this.bookBackTaskListService = await BookBackTaskListService.getInstance()
    }
  }
  /**
   * 加载数据库中的配置到全局变量中
   */
  async GetGlobalConfig() {
    try {
      await this.InitService()
      let softData = this.softwareService.GetSoftwareData(null)
      if (softData.data.length <= 0) {
        throw new Error('获取软件数据失败')
      }
      let config = softData.data[0]
      global.config = JSON.parse(config.globalSetting)
      this.globalConfig = global.config
      return successMessage(global.config, '获取全局配置完成', 'TaskManager_GetGlobalConfig')
    } catch (error) {
      return errorMessage(
        `获取全局配置失败，失败信息如下：` + error.message,
        'TaskManager_GetGlobalConfig'
      )
    }
  }

  /**
   * 执行自动任务
   * @returns
   */
  async ExecuteAutoTask() {
    await this.InitService()
    if (this.isExecuting && this.currentTaskList.length > this.globalConfig.task_number) {
      console.log('任务正在执行，跳过此次执行')
      return
    }
    this.isExecuting = true
    try {
      while (this.currentTaskList.length < this.globalConfig.task_number) {
        // 获取正在等待中第一个任务
        const tasks = this.bookBackTaskListService.GetWaitTaskAndSlice(TaskExecuteType.AUTO, 1)
        if (!tasks.data || tasks.data.length <= 0) {
          console.log('没有等待中的任务')
          break
        }
        let task = tasks.data[0]
        this.currentTaskList.push(task)
        this.handleTask(task)
          .then((data) => {
            if (data.code == 0) {
              this.bookBackTaskListService.UpdateTaskStatus({
                id: task.id,
                status: BookBackTaskStatus.FAIL,
                errorMessage: data.message
              })
              return Promise.reject(new Error(data.message))
            } else if (data.code == 1) {
              this.bookBackTaskListService.UpdateTaskStatus({
                id: task.id,
                status: BookBackTaskStatus.DONE
              })
            } else {
              return Promise.reject(new Error(`${task.type} 返回的数据结构不对`))
            }
          })
          .catch((error) => {
            // 失败，修改当前task的状态为fail
            this.bookBackTaskListService.UpdateTaskStatus({
              id: task.id,
              status: BookBackTaskStatus.FAIL,
              errorMessage: error.message
            })
            throw error
          })
          .finally(() => {
            this.currentTaskList = this.currentTaskList.filter((t) => t.id != task.id)
            this.ExecuteAutoTask()
          })
      }
    } catch (err) {
      return errorMessage(
        `执行任务失败，失败信息如下：${err.message}`,
        'TaskManager_ExecuteAutoTask'
      )
    } finally {
      // 判断是不是还有任务，没有则设置任务执行状态为false
      if (this.currentTaskList.length <= 0) {
        this.isExecuting = false
      }
    }
  }

  async handleTask(task) {
    try {
      let _bookBackTaskListService = await BookBackTaskListService.getInstance()
      let res
      // 调用分镜头任务
      if (task.type == BookBackTaskType.STORYBOARD) {
        res = await this.basicReverse.GetFrameData(task)
      } else if (task.type == BookBackTaskType.SPLIT) {
        // 调用分割视频任务
        res = await this.basicReverse.CutVideoData(task)
      } else if (task.type == BookBackTaskType.AUDIO) {
        // 提取音频任务
        res = await this.basicReverse.SplitAudioData(task)
      } else if (task.type == BookBackTaskType.FRAME) {
        // 抽取视频帧任务
        res = await this.basicReverse.GetFrame(task)
      } else if (task.type == BookBackTaskType.RECOGNIZE) {
        // 识别识别字幕任务
        res = await this.basicReverse.ExtractSubtitlesData(task)
      }
      // 未知的任务类型
      else {
        throw new Error('未知的任务类型')
      }

      if (res.code == 0) {
        // 修改当前队列的任务状态
        let updateRes = _bookBackTaskListService.UpdateTaskStatus({
          id: task.id,
          status: BookBackTaskStatus.FAIL,
          errorMessage: res.message
        })
        if (updateRes.code == 0) {
          throw new Error(updateRes.message)
        }
        throw new Error(res.message)
      }

      // 判断是不是要添加后续任务
      await this.AddTaskHandle(task, true)

      // 修改当前队列的任务状态
      let updateRes = _bookBackTaskListService.UpdateTaskStatus({
        id: task.id,
        status: BookBackTaskStatus.DONE
      })
      if (updateRes.code == 0) {
        throw new Error(updateRes.message)
      }
      return successMessage(null, '任务执行成功', 'TaskManager_handleTask')
    } catch (error) {
      return errorMessage(
        `处理 ${task.type} 类型任务 ${task.name} 失败，失败信息如下：${error.message}`,
        'TaskManager_handleTask'
      )
    }
  }

  /**
   * 是否添加后续任务
   * @param {*} task
   * @param {*} isAdd
   */
  async AddTaskHandle(task, isAdd = false) {
    if (!isAdd) {
      return
    }

    if (task.type == BookBackTaskType.STORYBOARD) {
      await this.basicReverse.AddCutVideoDataTask(task.bookId)
    } else if (task.type == BookBackTaskType.SPLIT) {
      await this.basicReverse.AddSplitAudioDataTask(task.bookId, task.bookTaskId)
    } else if (task.type == BookBackTaskType.AUDIO) {
      await this.basicReverse.AddGetFrameTask(task.bookId, task.bookTaskId)
    } else if (task.type == BookBackTaskType.FRAME) {
      await this.basicReverse.AddExtractSubtitlesDataTask(task.bookId, task.bookTaskId)
    } else {
      throw new Error('不支持的任务类型')
    }
  }
}