LaiTool/src/define/enum/bookEnum.ts

export enum BookType {
  // 原创
  ORIGINAL = 'original',
  // 区分老版本的原创
  NEW_ORIGINAL = 'new_original',
  // 反推
  SD_REVERSE = 'sd_reverse',
  // MJ 反推
  MJ_REVERSE = 'mj_reverse'
}

// 出图方式
export enum BookImageCategory {
  // MJ
  MJ = 'mj',
  // SD
  SD = 'sd',
  // D3
  D3 = 'd3',
  // FLUX  API 
  FLUX_API = 'flux-api',
  // FLUX FORGE
  FLUX_FORGE = 'flux-forge'
}

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',
  // 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'
}

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',

}

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 '分镜计算';
    case BookBackTaskType.SPLIT:
      return '分割视频';
    case BookBackTaskType.AUDIO:
      return '提取音频';
    case BookBackTaskType.RECOGNIZE:
      return '识别字幕';
    case BookBackTaskType.FRAME:
      return '抽帧';
    case BookBackTaskType.MJ_REVERSE:
      return 'MJ反推';
    case BookBackTaskType.SD_REVERSE:
      return 'SD反推';
    case BookBackTaskType.MJ_IMAGE:
      return 'MJ生成图片';
    case BookBackTaskType.SD_IMAGE:
      return 'SD生成图片';
    case BookBackTaskType.FLUX_FORGE_IMAGE:
      return 'flux forge生成图片';
    case BookBackTaskType.FLUX_API_IMAGE:
      return 'flux api生成图片';
    case BookBackTaskType.D3_IMAGE:
      return 'D3生成图片';
    case BookBackTaskType.HD:
      return '高清';
    case BookBackTaskType.COMPOSING:
      return '合成视频';
    case BookBackTaskType.INFERENCE:
      return '推理';
    case BookBackTaskType.TRANSLATE:
      return '翻译';
    default:
      return key;
  }
}

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

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