import { TaskModal } from '@/define/model/task'
import { t } from '@/i18n'

//#region 小说类型

export enum BookType {
  // 原创
  ORIGINAL = 'original',
  // 反推
  SD_REVERSE = 'sd_reverse',
  // MJ 反推
  MJ_REVERSE = 'mj_reverse'
}

/**
 * 根据小说类型返回小说类型的label
 * @param type 小说类型
 * @returns
 */
export function GetBookTypeLabel(type: BookType) {
  switch (type) {
    case BookType.ORIGINAL:
      return t('原创')
    case BookType.SD_REVERSE:
      return t('SD反推')
    case BookType.MJ_REVERSE:
      return t('MJ反推')
    default:
      return t('未知类型')
  }
}

/**
 *  获取小说类型的选项列表
 * @returns
 */
export function GetBookTypeOptions() {
  return [
    { label: t('原创'), value: BookType.ORIGINAL },
    { label: t('SD反推'), value: BookType.SD_REVERSE },
    { label: t('MJ反推'), value: BookType.MJ_REVERSE }
  ]
}

//#endregion

export enum AddBookTaskCopyData {
  AFTER_GPT = 'after_gpt', // 文案
  OLD_IMAGE = 'old_image', // 抽帧/视频
  GPT_PROMPT = 'gpt_prompt', // 反推/GPT提示词
  CHARACTER = 'character', // 角色
  IMAGE_STYLE = 'image_style', // 风格
  PROMPT = 'prompt', // 生图提示词
  IMAGE = 'image' // 生图
}

export enum MJCategroy {
  // 本地MJ
  LOCAL_MJ = 'local_mj',
  // 代理MJ
  REMOTE_MJ = 'remote_mj',
  // 浏览器模式
  BROWSER_MJ = 'browser_mj',
  // API模式
  API_MJ = 'api_mj'
}

export enum MJAction {
  // 生图
  IMAGINE = 'IMAGINE',

  // 反推describe
  DESCRIBE = 'DESCRIBE'
}

export enum BookBackTaskType {
  // 分镜计算
  STORYBOARD = 'storyboard',
  // 分割视频
  SPLIT = 'split',
  // 提取音频
  AUDIO = 'audio',
  // 识别字幕
  RECOGNIZE = 'recognize',
  // 抽帧
  FRAME = 'frame',
  // MJ反推
  MJ_REVERSE = BookType.MJ_REVERSE,
  // SD反推
  SD_REVERSE = BookType.SD_REVERSE,
  // MJ生成图片
  MJ_IMAGE = 'mj_image',
  // SD 生成图片
  SD_IMAGE = 'sd_image',
  // ComfyUI 生成图片
  ComfyUI_IMAGE = 'comfyui_image',
  // flux forge 生成图片
  FLUX_FORGE_IMAGE = 'flux_forge_image',
  // flux api 生成图片
  FLUX_API_IMAGE = 'flux_api_image',
  // D3 生成图片
  D3_IMAGE = 'd3_image',
  // 高清
  HD = 'hd',
  // 合成视频
  COMPOSING = 'composing',
  // 推理
  INFERENCE = 'inference',
  // 翻译
  TRANSLATE = 'translate',

  // ruanway 生成视频
  RUNWAY_VIDEO = 'runway_video',
  // luma 生成视频
  LUMA_VIDEO = 'luma_video',
  // kling 生成视频
  KLING_VIDEO = 'kling_video',
  // kling 视频拓展
  KLING_VIDEO_EXTEND = 'kling_video_extend',
  // MJ Video
  MJ_VIDEO = 'mj_video',
  // MJ VIDEO EXTEND 视频拓展
  MJ_VIDEO_EXTEND = 'mj_video_extend',
  // 海螺文生视频
  HAILUO_TEXT_TO_VIDEO = 'hailuo_text_to_video',
  // 海螺图生视频
  HAILUO_IMAGE_TO_VIDEO = 'hailuo_image_to_video',
  // 海螺视频首尾帧
  HAILUO_FIRST_LAST_FRAME = 'hailuo_first_last_frame'
}

export enum BookBackTaskStatus {
  // 等待
  WAIT = 'wait',
  // 运行中
  RUNNING = 'running',
  // 暂停
  PAUSE = 'pause',
  // 完成
  DONE = 'done',
  // 失败
  FAIL = 'fail',
  // 重连
  RECONNECT = 'reconnect'
}

export enum TaskExecuteType {
  // 自动
  AUTO = 'auto',

  // 手动
  OPERATE = 'operate'
}

// 弹窗类型
export enum DialogType {
  // 单独弹窗
  DIALOG = 'dialog',
  // 消息提示
  MESSAGE = 'message',
  // 右上角通知
  NOTIFICATION = 'notification'
}

/**
 * 小说任务状态
 */
export enum BookTaskStatus {
  // 等待
  WAIT = 'wait',

  // 分镜中
  STORYBOARD = 'storyboard',

  // 分镜失败
  STORYBOARD_FAIL = 'storyboard_fail',

  // 分镜完成，等待分割视频
  STORYBOARD_DONE = 'storyboard_done',

  // 分割视频中
  SPLIT = 'split',

  // 分割视频失败
  SPLIT_FAIL = 'split_fail',

  // 分割视频完成，等待提取音频
  SPLIT_DONE = 'split_done',

  // 提取音频中
  AUDIO = 'audio',

  // 提取音频失败
  AUDIO_FAIL = 'audio_fail',

  // 提取音频完成，等待识别字幕
  AUDIO_DONE = 'audio_done',

  // 识别字幕中
  RECOGNIZE = 'recognize',

  // 识别字幕失败
  RECOGNIZE_FAIL = 'recognize_fail',

  // 识别字幕完成，等待抽帧
  RECOGNIZE_DONE = 'recognize_done',

  // 抽帧中
  FRAME = 'frame',

  // 抽帧完成，等待反推
  FRAME_DONE = 'frame_done',

  // 抽帧失败
  FRAME_FAIL = 'frame_fail',

  // 反推中
  REVERSE = 'reverse',

  // 反推失败
  REVERSE_FAIL = 'reverse_fail',

  // 反推完成，等待生成图片
  REVERSE_DONE = 'reverse_done',

  // 生成图片中
  IMAGE = 'image',

  // 图片生成完成，等待高清
  IMAGE_DONE = 'image_done',

  // 图片生成失败
  IMAGE_FAIL = 'image_fail',

  // 高清中
  HD = 'hd',

  // 高清失败
  HD_FAIL = 'hd_fail',

  // 高清完成，等待合成视频
  HD_DONE = 'hd_done',

  // 合成视频中
  COMPOSING = 'composing',

  // 合成视频完成
  COMPOSING_DONE = 'composing_done',

  // 合成视频失败
  COMPOSING_FAIL = 'composing_fail',
  /** 添加草稿完成 */
  DRAFT_DONE = 'draft_done',
  /** 添加草稿失败 */
  DRAFT_FAIL = 'draft_fail',

  /** 图转视频失败 */
  IMAGE_TO_VIDEO_ERROR = 'image_to_video_error',
  /** 图转视频成功 */
  IMAGE_TO_VIDEO_SUCCESS = 'IMAGE_TO_VIDEO_SUCCESS'
}

export enum TagDefineType {
  // 默认风格
  DEFAULT_STYLE = 'default_style',
  // 角色标签
  CHARACTER_MAIN = 'character_main',

  // 角色小标签
  CHARACTER_SUB = 'min',

  // 风格主标签
  STYLE_MAIN = 'style_main',

  // 场景主标签
  SCENE_MAIN = 'scene_main'
}

export enum OperateBookType {
  BOOK = 'book', // 这个小说的所有批次
  BOOKTASK = 'bookTask', // 整个小说批次分镜合并
  BOOKTASKDETAIL = 'bookTaskDetail', // 单个分镜合并
  UNDERBOOKTASK = 'underBookTask', // 执行小说批次任务的指定ID以及后面的所有的东西
  ASSIGNBOOKTASK = 'assignBookTask' // 指定小说批次任务
}

export enum CopyImageType {
  // 所有，包括原图
  ALL = 'all',
  // 出原图外其他，一个个对应
  ONE = 'one',
  // 不包含图
  NONE = 'none'
}

export enum PromptMergeType {
  // mj 合并
  MJ_MERGE = 'mj_merge',

  // SD 合并
  SD_MERGE = 'sd_merge',

  // D3 合并
  D3_MERGE = 'd3_merge'
}

/**
 * 小说数据替换类型
 */
export enum BookRepalceDataType {
  // 文案
  AFTER_GPT = 'after_gpt',
  // GPT提示词
  GPT_PROMPT = 'gpt_prompt',
  // 提示词
  PROMPT = 'prompt'
}

/**
 * 小说选择标签的方式类型，可以是下拉和标签
 */
export enum BookTagSelectType {
  // 下拉
  DROP = 'drop',
  // 标签
  TAG = 'tag'
}

/**
 * 根据Key返回指定的后台任务类型的label
 * @param key
 * @returns
 */
export function GetBookBackTaskTypeLabel(key: string) {
  switch (key) {
    case BookBackTaskType.STORYBOARD:
      return t('分镜计算')
    case BookBackTaskType.SPLIT:
      return t('分割视频')
    case BookBackTaskType.AUDIO:
      return t('提取音频')
    case BookBackTaskType.RECOGNIZE:
      return t('识别字幕')
    case BookBackTaskType.FRAME:
      return t('抽帧')
    case BookBackTaskType.MJ_REVERSE:
      return t('MJ反推')
    case BookBackTaskType.SD_REVERSE:
      return t('SD反推')
    case BookBackTaskType.MJ_IMAGE:
      return t('MJ生成图片')
    case BookBackTaskType.SD_IMAGE:
      return t('SD生成图片')
    case BookBackTaskType.FLUX_FORGE_IMAGE:
      return t('flux forge生成图片')
    case BookBackTaskType.FLUX_API_IMAGE:
      return t('flux api生成图片')
    case BookBackTaskType.D3_IMAGE:
      return t('D3生成图片')
    case BookBackTaskType.HD:
      return t('高清')
    case BookBackTaskType.COMPOSING:
      return t('合成视频')
    case BookBackTaskType.INFERENCE:
      return t('推理')
    case BookBackTaskType.TRANSLATE:
      return t('翻译')
    case BookBackTaskType.RUNWAY_VIDEO:
      return t('runway生成视频')
    case BookBackTaskType.LUMA_VIDEO:
      return t('luma生成视频')
    case BookBackTaskType.KLING_VIDEO:
      return t('kling生成视频')
    default:
      return key
  }
}

/**
 * 根据Key返回指定的后台任务状态的label
 * @param key
 * @returns
 */
export function GetBookTaskDetailStatusLabel(key: string): TaskModal.TaskStatus {
  switch (key) {
    case BookTaskStatus.WAIT:
      return {
        status: BookTaskStatus.WAIT,
        label: t('等待'),
        type: 'warning'
      }
    case BookTaskStatus.STORYBOARD:
      return {
        status: BookTaskStatus.STORYBOARD,
        label: t('分镜计算中'),
        type: 'info'
      }
    case BookTaskStatus.STORYBOARD_FAIL:
      return {
        status: BookTaskStatus.STORYBOARD_FAIL,
        label: t('分镜计算失败'),
        type: 'error'
      }
    case BookTaskStatus.STORYBOARD_DONE:
      return {
        status: BookTaskStatus.STORYBOARD_DONE,
        label: t('分镜计算完成'),
        type: 'success'
      }
    case BookTaskStatus.SPLIT:
      return {
        status: BookTaskStatus.SPLIT,
        label: t('分割视频中'),
        type: 'info'
      }
    case BookTaskStatus.SPLIT_FAIL:
      return {
        status: BookTaskStatus.SPLIT_FAIL,
        label: t('分割视频失败'),
        type: 'error'
      }
    case BookTaskStatus.SPLIT_DONE:
      return {
        status: BookTaskStatus.SPLIT_DONE,
        label: t('分割视频完成'),
        type: 'success'
      }
    case BookTaskStatus.AUDIO:
      return {
        status: BookTaskStatus.AUDIO,
        label: t('提取音频中'),
        type: 'info'
      }
    case BookTaskStatus.AUDIO_FAIL:
      return {
        status: BookTaskStatus.AUDIO_FAIL,
        label: t('提取音频失败'),
        type: 'error'
      }
    case BookTaskStatus.AUDIO_DONE:
      return {
        status: BookTaskStatus.AUDIO_DONE,
        label: t('提取音频完成'),
        type: 'success'
      }
    case BookTaskStatus.RECOGNIZE:
      return {
        status: BookTaskStatus.RECOGNIZE,
        label: t('识别字幕中'),
        type: 'info'
      }
    case BookTaskStatus.RECOGNIZE_FAIL:
      return {
        status: BookTaskStatus.RECOGNIZE_FAIL,
        label: t('识别字幕失败'),
        type: 'error'
      }
    case BookTaskStatus.RECOGNIZE_DONE:
      return {
        status: BookTaskStatus.RECOGNIZE_DONE,
        label: t('识别字幕完成'),
        type: 'success'
      }
    case BookTaskStatus.FRAME:
      return {
        status: BookTaskStatus.FRAME,
        label: t('抽帧中'),
        type: 'info'
      }
    case BookTaskStatus.FRAME_FAIL:
      return {
        status: BookTaskStatus.FRAME_FAIL,
        label: t('抽帧失败'),
        type: 'error'
      }
    case BookTaskStatus.FRAME_DONE:
      return {
        status: BookTaskStatus.FRAME_DONE,
        label: t('抽帧完成'),
        type: 'success'
      }
    case BookTaskStatus.REVERSE:
      return {
        status: BookTaskStatus.REVERSE,
        label: t('反推中'),
        type: 'info'
      }
    case BookTaskStatus.REVERSE_FAIL:
      return {
        status: BookTaskStatus.REVERSE_FAIL,
        label: t('反推失败'),
        type: 'error'
      }
    case BookTaskStatus.REVERSE_DONE:
      return {
        status: BookTaskStatus.REVERSE_DONE,
        label: t('反推完成'),
        type: 'success'
      }
    case BookTaskStatus.IMAGE:
      return {
        status: BookTaskStatus.IMAGE,
        label: t('生成图片中'),
        type: 'info'
      }
    case BookTaskStatus.IMAGE_FAIL:
      return {
        status: BookTaskStatus.IMAGE_FAIL,
        label: t('生成图片失败'),
        type: 'error'
      }
    case BookTaskStatus.IMAGE_DONE:
      return {
        status: BookTaskStatus.IMAGE_DONE,
        label: t('生成图片完成'),
        type: 'success'
      }
    case BookTaskStatus.HD:
      return {
        status: BookTaskStatus.HD,
        label: t('高清中'),
        type: 'info'
      }
    case BookTaskStatus.HD_FAIL:
      return {
        status: BookTaskStatus.HD_FAIL,
        label: t('高清失败'),
        type: 'error'
      }
    case BookTaskStatus.HD_DONE:
      return {
        status: BookTaskStatus.HD_DONE,
        label: t('高清完成'),
        type: 'success'
      }
    case BookTaskStatus.COMPOSING:
      return {
        status: BookTaskStatus.COMPOSING,
        label: t('合成视频中'),
        type: 'info'
      }
    case BookTaskStatus.COMPOSING_FAIL:
      return {
        status: BookTaskStatus.COMPOSING_FAIL,
        label: t('合成视频失败'),
        type: 'error'
      }
    case BookTaskStatus.COMPOSING_DONE:
      return {
        status: BookTaskStatus.COMPOSING_DONE,
        label: t('合成视频完成'),
        type: 'success'
      }
    case BookTaskStatus.DRAFT_DONE:
      return {
        status: BookTaskStatus.DRAFT_DONE,
        label: t('添加草稿完成'),
        type: 'success'
      }
    case BookTaskStatus.DRAFT_FAIL:
      return {
        status: BookTaskStatus.DRAFT_FAIL,
        label: t('添加草稿失败'),
        type: 'error'
      }
    case BookTaskStatus.IMAGE_TO_VIDEO_ERROR:
      return {
        status: BookTaskStatus.IMAGE_TO_VIDEO_ERROR,
        label: t('图转视频失败'),
        type: 'error'
      }
    case BookTaskStatus.IMAGE_TO_VIDEO_SUCCESS:
      return {
        status: BookTaskStatus.IMAGE_TO_VIDEO_SUCCESS,
        label: t('图转视频成功'),
        type: 'success'
      }
    default:
      return {
        status: 'UNKNOWN',
        label: t('未知'),
        type: 'warning'
      }
  }
}

/**
 * 根据Key返回指定的后台任务状态的label
 * @param key
 * @returns
 */
export function GetBookBackTaskStatusLabel(key: string): TaskModal.TaskStatus {
  switch (key) {
    case BookBackTaskStatus.WAIT:
      return {
        status: BookBackTaskStatus.WAIT,
        label: t('等待'),
        type: 'warning'
      }
    case BookBackTaskStatus.RUNNING:
      return {
        status: BookBackTaskStatus.RUNNING,
        label: t('运行中'),
        type: 'info'
      }
    case BookBackTaskStatus.PAUSE:
      return {
        status: BookBackTaskStatus.PAUSE,
        label: t('暂停'),
        type: 'warning'
      }
    case BookBackTaskStatus.DONE:
      return {
        status: BookBackTaskStatus.DONE,
        label: t('完成'),
        type: 'success'
      }
    case BookBackTaskStatus.FAIL:
      return {
        status: BookBackTaskStatus.FAIL,
        label: t('失败'),
        type: 'error'
      }
    case BookBackTaskStatus.RECONNECT:
      return {
        status: BookBackTaskStatus.RECONNECT,
        label: t('重连'),
        type: 'warning'
      }
    default:
      return {
        status: 'UNKNOWN',
        label: t('未知'),
        type: 'warning'
      }
  }
}