//#region 图转视频类型

import { t } from '@/i18n'
import { BookBackTaskType } from './bookEnum'

export type ToVIdeoType = 'textToVideo' | 'imageToVideo' | "firstLastFrame"

/** 图片转视频的方式 */
export enum ImageToVideoModels {
  /** runway 生成视频 */
  RUNWAY = 'RUNWAY',
  /** luma 生成视频 */
  LUMA = 'LUMA',
  /** 可灵生成视频 */
  KLING = 'KLING',
  /** 可灵视频拓展 */
  KLING_VIDEO_EXTEND = 'KLING_VIDEO_EXTEND',
  /** Pika 生成视频 */
  PIKA = 'PIKA',
  /** 海螺生成视频 */
  HAILUO = 'HAILUO',
  /** MJ 图转视频 */
  MJ_VIDEO = 'MJ_VIDEO',
  /** MJ 视频拓展 */
  MJ_VIDEO_EXTEND = 'MJ_VIDEO_EXTEND',
  /** Comfy UI 生成视频 */
  COMFY_UI = 'COMFY_UI',
}


/**
 * 根据任务类型映射到对应的图片转视频模型
 *
 * 该方法用于将后端任务类型（BookBackTaskType）或字符串类型，
 * 映射为前端使用的 ImageToVideoModels 枚举值。
 * 主要用于统一不同任务类型与视频模型的对应关系，便于后续视频处理逻辑。
 *
 * @param type 后端任务类型（BookBackTaskType）或字符串
 * @returns 对应的 ImageToVideoModels 枚举值，未匹配时返回 'UNKNOWN'
 *
 * @description
 * - 支持多种后端任务类型与视频模型的映射
 * - 未知类型返回 'UNKNOWN'，便于异常处理
 * - 常用于视频生成、任务分发等场景
 *
 * @example
 * ```typescript
 * const model = MappingTaskTypeToVideoModel(BookBackTaskType.LUMA_VIDEO);
 * // model === ImageToVideoModels.LUMA
 * ```
 *
 * @see BookBackTaskType - 后端任务类型枚举
 * @see ImageToVideoModels - 图片转视频模型枚举
 */
export const MappingTaskTypeToVideoModel = (type: BookBackTaskType | string) => {
  switch (type) {
    case BookBackTaskType.LUMA_VIDEO:
      return ImageToVideoModels.LUMA
    case BookBackTaskType.HAILUO_TEXT_TO_VIDEO:
      return ImageToVideoModels.HAILUO
    case BookBackTaskType.RUNWAY_VIDEO:
      return ImageToVideoModels.RUNWAY
    case BookBackTaskType.KLING_VIDEO:
      return ImageToVideoModels.KLING
    case BookBackTaskType.KLING_VIDEO_EXTEND:
      return ImageToVideoModels.KLING_VIDEO_EXTEND
    case BookBackTaskType.MJ_VIDEO:
      return ImageToVideoModels.MJ_VIDEO
    case BookBackTaskType.MJ_VIDEO_EXTEND:
      return ImageToVideoModels.MJ_VIDEO_EXTEND
    case BookBackTaskType.COMFYUI_VIDEO:
        return ImageToVideoModels.COMFY_UI
    default:
      return 'UNKNOWN'
  }
}

/**
 * 图片转视频模型的名称转换
 * @param model 图片转视频的模型类型
 * @returns 模型的中文名称
 */
export const GetImageToVideoModelsLabel = (model: ImageToVideoModels | string) => {
  switch (model) {
    case ImageToVideoModels.RUNWAY:
      return 'Runway'
    case ImageToVideoModels.LUMA:
      return 'Luma'
    case ImageToVideoModels.KLING:
      return t('可灵')
    case ImageToVideoModels.PIKA:
      return 'Pika'
    case ImageToVideoModels.HAILUO:
      return t('海螺')
    case ImageToVideoModels.MJ_VIDEO:
    case ImageToVideoModels.MJ_VIDEO_EXTEND:
      return t('MJ视频')
    case ImageToVideoModels.COMFY_UI:
      return t('ComfyUI')
    default:
      return '未知'
  }
}

/**
 * 获取图像转视频模型选项的函数
 *
 * 该函数返回一个包含所有可用图像转视频模型的选项数组。
 * 每个选项包含一个标签（label）和一个值（value）。
 * 标签通过调用 GetImageToVideoModelsLabel 函数获得，而值则直接使用 ImageToVideoModels 枚举值。
 *
 * @returns 图像转视频模型选项数组，每个选项包含 label 和 value 属性
 */
export const GetImageToVideoModelsOptions = () => {
  return [
    {
      label: GetImageToVideoModelsLabel(ImageToVideoModels.MJ_VIDEO),
      value: ImageToVideoModels.MJ_VIDEO
    }, {

      label: GetImageToVideoModelsLabel(ImageToVideoModels.HAILUO),
      value: ImageToVideoModels.HAILUO
    },
    // {
    //   label: GetImageToVideoModelsLabel(ImageToVideoModels.RUNWAY),
    //   value: ImageToVideoModels.RUNWAY
    // },
    // { label: GetImageToVideoModelsLabel(ImageToVideoModels.LUMA), value: ImageToVideoModels.LUMA },
    {
      label: GetImageToVideoModelsLabel(ImageToVideoModels.KLING),
      value: ImageToVideoModels.KLING
    },
    {
      label: GetImageToVideoModelsLabel(ImageToVideoModels.COMFY_UI),
      value: ImageToVideoModels.COMFY_UI
    },
    // { label: GetImageToVideoModelsLabel(ImageToVideoModels.PIKA), value: ImageToVideoModels.PIKA }
  ]
}

//#endregion

//#region 通用

/** 生成视频的方式 */
export enum VideoModel {
  /** 文生视频 */
  TEXT_TO_VIDEO = 'textToVideo',
  /** 图生视频 */
  IMAGE_TO_VIDEO = 'imageToVideo'
}

/** 图转视频的状态 */
export enum VideoStatus {
  /** 等待 */
  WAIT = 'wait',
  /** 提交成功 */
  SUBMITTED = 'submitted',
  /** 处理中 */
  PROCESSING = 'processing',
  /** 完成 */
  SUCCESS = 'success',
  /** 失败 */
  FAIL = 'fail'
}

export const GetVideoStatus = (status: VideoStatus | string) => {
  switch (status) {
    case VideoStatus.WAIT:
    case '0':
      return t('等待')
    case VideoStatus.PROCESSING:
    case '1':
      return t('处理中')
    case VideoStatus.SUCCESS:
    case '3':
      return t('完成')
    case VideoStatus.FAIL:
    case '2':
      return t('失败')
    default:
      return t('未知')
  }
}

//#endregion

//#region  runway 相关

/** runway 生成视频的模型 */
export enum RunawayModel {
  GNE2 = 'gen2',
  GNE3 = 'gen3'
}

/** runway 合成视频的时长 */
export enum RunwaySeconds {
  FIVE = 5,
  TEN = 10
}
//#endregion

//#region 可灵相关


/**
 * 可灵生成视频的模式
 * - std：高性能
 * - pro：高表现
 */
export enum KlingMode {
  /** 高性能 */
  STD = 'std',
  /** 高表现 */
  PRO = 'pro'
}

/**
 * 获取可灵生成模式的标签
 * 
 * @param mode 可灵生成模式枚举值或字符串
 * @returns 返回对应的中文标签
 */
export function GetKlingModeLabel(mode: KlingMode | string) {
  switch (mode) {
    case KlingMode.STD:
      return t('高性能 (std)')
    case KlingMode.PRO:
      return t('高表现 (pro)')
    default:
      return t('未知')
  }
}

/**
 * 获取可灵生成模式的选项列表
 * 
 * @returns 返回包含标签和值的选项数组，用于下拉选择框等UI组件
 */
export function GetKlingModeOptions() {
  return [
    {
      label: GetKlingModeLabel(KlingMode.STD),
      value: KlingMode.STD
    },
    {
      label: GetKlingModeLabel(KlingMode.PRO),
      value: KlingMode.PRO
    }
  ]
}


/**
 * 可灵生成视频的时长
 * - '5'：5秒
 * - '10'：10秒
 */
export enum KlingDuration {
  FIVE = 5,
  TEN = 10
}

/**
 * 获取可灵视频时长的标签
 * 
 * @param duration 可灵视频时长枚举值或字符串
 * @returns 返回对应的中文标签
 */
export function GetKlingDurationLabel(duration: KlingDuration | string) {
  switch (duration) {
    case KlingDuration.FIVE:
      return t('5秒')
    case KlingDuration.TEN:
      return t('10秒')
    default:
      return t('未知')
  }
}

/**
 * 获取可灵视频时长的选项列表
 * 
 * @returns 返回包含标签和值的选项数组，用于下拉选择框等UI组件
 */
export function GetKlingDurationOptions() {
  return [
    {
      label: GetKlingDurationLabel(KlingDuration.FIVE),
      value: KlingDuration.FIVE
    },
    {
      label: GetKlingDurationLabel(KlingDuration.TEN),
      value: KlingDuration.TEN
    }
  ]
}


/**
 * 可灵模型名称
 * - kling-v1：V1 版本
 * - kling-v1-5：V1.5 版本
 * - kling-v1-6：V1.6 版本
 * - kling-v2-master：V2 master 版本
 * - kling-v2-1：V2.1 版本
 * - kling-v2-1-master：V2.1 master 版本
 */
export enum KlingModelName {
  /** V1 版本 */
  KLING_V1 = 'kling-v1',
  /** V1.5 版本 */
  KLING_V1_5 = 'kling-v1-5',
  /** V1.6 版本 */
  KLING_V1_6 = 'kling-v1-6',
  /** V2 master 版本 */
  KLING_V2_MASTER = 'kling-v2-master',
  /** V2.1 版本 */
  KLING_V2_1 = 'kling-v2-1',
  /** V2.1 master 版本 */
  KLING_V2_1_MASTER = 'kling-v2-1-master'
}

/**
 * 获取可灵模型名称的标签
 * 
 * @param modelName 可灵模型名称枚举值或字符串
 * @returns 返回对应的中文标签
 */
export function GetKlingModelNameLabel(modelName: KlingModelName | string) {
  switch (modelName) {
    case KlingModelName.KLING_V1:
      return t('Kling V1')
    case KlingModelName.KLING_V1_5:
      return t('Kling V1.5')
    case KlingModelName.KLING_V1_6:
      return t('Kling V1.6')
    case KlingModelName.KLING_V2_MASTER:
      return t('Kling V2 Master')
    case KlingModelName.KLING_V2_1:
      return t('Kling V2.1')
    case KlingModelName.KLING_V2_1_MASTER:
      return t('Kling V2.1 Master')
    default:
      return t('未知')
  }
}

/**
 * 获取可灵模型名称的选项列表
 * 
 * @returns 返回包含标签和值的选项数组，用于下拉选择框等UI组件
 */
export function GetKlingModelNameOptions() {
  return [
    {
      label: GetKlingModelNameLabel(KlingModelName.KLING_V1),
      value: KlingModelName.KLING_V1
    },
    {
      label: GetKlingModelNameLabel(KlingModelName.KLING_V1_5),
      value: KlingModelName.KLING_V1_5
    },
    {
      label: GetKlingModelNameLabel(KlingModelName.KLING_V1_6),
      value: KlingModelName.KLING_V1_6
    },
    {
      label: GetKlingModelNameLabel(KlingModelName.KLING_V2_MASTER),
      value: KlingModelName.KLING_V2_MASTER
    },
    {
      label: GetKlingModelNameLabel(KlingModelName.KLING_V2_1),
      value: KlingModelName.KLING_V2_1
    },
    {
      label: GetKlingModelNameLabel(KlingModelName.KLING_V2_1_MASTER),
      value: KlingModelName.KLING_V2_1_MASTER
    }
  ]
}

//#endregion

//#region  MJ Video

/**
 * 对视频任务进行操作。不为空时，index、taskId必填
 */
export enum MJVideoAction {
  Extend = 'extend'
}

/**
 * 首帧图片，扩展时可为空
 */
export enum MJVideoImageType {
  Base64 = 'base64',
  Url = 'url'
}

/**
 * MJ Video的动作幅度
 */
export enum MJVideoMotion {
  High = 'high',
  Low = 'low'
}

/**
 * 获取MJ视频动作幅度的标签
 *
 * @param model MJ视频动作幅度枚举值或字符串
 * @returns 返回对应的中英文标签
 */
export function GetMJVideoMotionLabel(model: MJVideoMotion | string) {
  switch (model) {
    case MJVideoMotion.High:
      return t('高 (High)')
    case MJVideoMotion.Low:
      return t('低 (Low)')
    default:
      return t('未知')
  }
}

/**
 * 获取MJ视频动作幅度的选项列表
 *
 * @returns 返回包含标签和值的选项数组，用于下拉选择框等UI组件
 */
export function GetMJVideoMotionOptions() {
  return [
    {
      label: GetMJVideoMotionLabel(MJVideoMotion.Low),
      value: MJVideoMotion.Low
    },
    {
      label: GetMJVideoMotionLabel(MJVideoMotion.High),
      value: MJVideoMotion.High
    }
  ]
}

/**
 * MJ Video 视频质量类型
 */
export enum MJVideoType {
  /** 标清 480p */
  SD = 'vid_1.1_i2v_480',
  /** 高清 720p */
  HD = 'vid_1.1_i2v_720'
}

/**
 * 获取MJ视频质量类型的标签
 * 
 * @param type MJ视频质量类型枚举值或字符串
 * @returns 返回对应的中英文标签
 */
export function GetMJVideoTypeLabel(type: MJVideoType | string) {
  switch (type) {
    case MJVideoType.SD:
      return t('标清 (SD 480p)')
    case MJVideoType.HD:
      return t('高清 (HD 720p)')
    default:
      return t('未知')
  }
}

/**
 * 获取MJ视频质量类型的选项列表
 * 
 * @returns 返回包含标签和值的选项数组，用于下拉选择框等UI组件
 */
export function GetMJVideoTypeOptions() {
  return [
    {
      label: GetMJVideoTypeLabel(MJVideoType.SD),
      value: MJVideoType.SD
    },
    { label: GetMJVideoTypeLabel(MJVideoType.HD), value: MJVideoType.HD }
  ]
}

/**
 * MJ Video 批次大小
 */
export enum MJVideoBatchSize {
  /** 生成1个视频 */
  ONE = 1,
  /** 生成2个视频 */
  TWO = 2,
  /** 生成4个视频 */
  FOUR = 4
}

/**
 * 获取MJ视频批次大小的标签
 * 
 * @param batchSize MJ视频批次大小枚举值或数字
 * @returns 返回对应的中文标签
 */
export function GetMJVideoBatchSizeLabel(batchSize: MJVideoBatchSize | number) {
  switch (batchSize) {
    case MJVideoBatchSize.ONE:
      return t('1个视频')
    case MJVideoBatchSize.TWO:
      return t('2个视频')
    case MJVideoBatchSize.FOUR:
      return t('4个视频')
    default:
      return t('未知')
  }
}

/**
 * 获取MJ视频批次大小的选项列表
 * 
 * @returns 返回包含标签和值的选项数组，用于下拉选择框等UI组件
 */
export function GetMJVideoBatchSizeOptions() {
  return [
    {
      label: GetMJVideoBatchSizeLabel(MJVideoBatchSize.ONE),
      value: MJVideoBatchSize.ONE
    },
    {
      label: GetMJVideoBatchSizeLabel(MJVideoBatchSize.TWO),
      value: MJVideoBatchSize.TWO
    },
    {
      label: GetMJVideoBatchSizeLabel(MJVideoBatchSize.FOUR),
      value: MJVideoBatchSize.FOUR
    }
  ]
}

//#endregion

//#region 海螺视频相关

/**
 * 海螺视频模型名称
 */
export enum HailuoModel {
  /** MiniMax-Hailuo-02 模型 */
  MINIMAX_HAILUO_02 = 'MiniMax-Hailuo-02',
  /** I2V-01-Director 模型 */
  I2V_01_DIRECTOR = 'I2V-01-Director',
  /** I2V-01-live 模型 */
  I2V_01_LIVE = 'I2V-01-live',
  /** I2V-01 模型 */
  I2V_01 = 'I2V-01',
  /** T2V-01-Director 模型 */
  T2V_01_DIRECTOR = "T2V-01-Director",
  /** T2V-01 模型 */
  T2V_01 = 'T2V-01'
}

/**
 * 海螺视频分辨率
 */
export enum HailuoResolution {
  /** 512P 分辨率 */
  P512 = '512P',
  /** 720P 分辨率 */
  P720 = '720P',
  /** 768P 分辨率 */
  P768 = '768P',
  /** 1080P 分辨率 */
  P1080 = '1080P'
}

/**
 * 海螺视频时长
 */
export enum HailuoDuration {
  /** 6秒 */
  SIX = 6,
  /** 10秒 */
  TEN = 10
}

/**
 * 获取海螺视频模型名称的标签
 * 
 * @param model 海螺视频模型枚举值或字符串
 * @returns 返回对应的中文标签
 */
export function GetHailuoModelLabel(model: HailuoModel | string) {
  switch (model) {
    case HailuoModel.MINIMAX_HAILUO_02:
      return t('MiniMax-Hailuo-02')
    case HailuoModel.I2V_01_DIRECTOR:
      return t('I2V-01-Director')
    case HailuoModel.I2V_01_LIVE:
      return t('I2V-01-live')
    case HailuoModel.I2V_01:
      return t('I2V-01')
    case HailuoModel.T2V_01_DIRECTOR:
      return t('T2V-01-Director')
    case HailuoModel.T2V_01:
      return t('T2V-01')
    default:
      return t('未知')
  }
}

/**
 * 获取海螺视频模型选项列表
 * 
 * @returns 返回包含标签和值的选项数组，用于下拉选择框等UI组件
 */
export function GetHailuoModelOptions(type: ToVIdeoType) {
  if (type == "textToVideo") {
    return [
      {
        label: GetHailuoModelLabel(HailuoModel.MINIMAX_HAILUO_02),
        value: HailuoModel.MINIMAX_HAILUO_02
      },
      {
        label: GetHailuoModelLabel(HailuoModel.T2V_01_DIRECTOR),
        value: HailuoModel.T2V_01_DIRECTOR
      },
      {
        label: GetHailuoModelLabel(HailuoModel.T2V_01),
        value: HailuoModel.T2V_01
      }
    ]
  } else if (type == "imageToVideo") {
    return [
      {
        label: GetHailuoModelLabel(HailuoModel.MINIMAX_HAILUO_02),
        value: HailuoModel.MINIMAX_HAILUO_02
      },
      {
        label: GetHailuoModelLabel(HailuoModel.I2V_01_DIRECTOR),
        value: HailuoModel.I2V_01_DIRECTOR
      },
      {
        label: GetHailuoModelLabel(HailuoModel.I2V_01_LIVE),
        value: HailuoModel.I2V_01_LIVE
      },
      {
        label: GetHailuoModelLabel(HailuoModel.I2V_01),
        value: HailuoModel.I2V_01
      }
    ]
  } else if (type == "firstLastFrame") {
    return [
      {
        label: GetHailuoModelLabel(HailuoModel.MINIMAX_HAILUO_02),
        value: HailuoModel.MINIMAX_HAILUO_02
      }]
  }

  return [
    [
      {
        label: GetHailuoModelLabel(HailuoModel.MINIMAX_HAILUO_02),
        value: HailuoModel.MINIMAX_HAILUO_02
      },
      {
        label: GetHailuoModelLabel(HailuoModel.I2V_01_DIRECTOR),
        value: HailuoModel.I2V_01_DIRECTOR
      },
      {
        label: GetHailuoModelLabel(HailuoModel.I2V_01_LIVE),
        value: HailuoModel.I2V_01_LIVE
      },
      {
        label: GetHailuoModelLabel(HailuoModel.I2V_01),
        value: HailuoModel.I2V_01
      },
      {
        label: GetHailuoModelLabel(HailuoModel.T2V_01_DIRECTOR),
        value: HailuoModel.T2V_01_DIRECTOR
      },
      {
        label: GetHailuoModelLabel(HailuoModel.T2V_01),
        value: HailuoModel.T2V_01
      }
    ]
  ]
}

/**
 * 判断海螺视频模型是否支持运镜指令
 * 
 * @param model 海螺视频模型枚举值或字符串
 * @returns 返回是否支持运镜指令
 */
export function IsHailuoModelSupportDirectorCommands(model: HailuoModel | string): boolean {
  return model === HailuoModel.MINIMAX_HAILUO_02 || model === HailuoModel.I2V_01_DIRECTOR
}

/**
 * 获取海螺视频模型支持的分辨率选项
 * 
 * @param type 视频生成类型: 'textToVideo' (文生视频), 'imageToVideo' (图生视频), 'firstLastFrame' (首尾帧)
 * @param model 海螺视频模型枚举值或字符串
 * @param duration 视频时长
 * @returns 返回支持的分辨率选项数组
 */
export function GetHailuoModelSupportedResolutions(type: ToVIdeoType, model: HailuoModel | string, duration: HailuoDuration | number = HailuoDuration.SIX) {
  if (model === HailuoModel.MINIMAX_HAILUO_02) {
    // MiniMax-Hailuo-02 模型根据类型和时长的不同支持
    if (type === 'textToVideo') {
      // 文生视频
      if (duration === HailuoDuration.SIX) {
        return [
          { label: GetHailuoResolutionLabel(HailuoResolution.P768), value: HailuoResolution.P768 }, // 默认
          { label: GetHailuoResolutionLabel(HailuoResolution.P1080), value: HailuoResolution.P1080 }
        ]
      } else if (duration === HailuoDuration.TEN) {
        return [
          { label: GetHailuoResolutionLabel(HailuoResolution.P768), value: HailuoResolution.P768 } // 默认
        ]
      }
    } else if (type === 'imageToVideo') {
      // 图生视频
      if (duration === HailuoDuration.SIX) {
        return [
          { label: GetHailuoResolutionLabel(HailuoResolution.P512), value: HailuoResolution.P512 },
          { label: GetHailuoResolutionLabel(HailuoResolution.P768), value: HailuoResolution.P768 }, // 默认
          { label: GetHailuoResolutionLabel(HailuoResolution.P1080), value: HailuoResolution.P1080 }
        ]
      } else if (duration === HailuoDuration.TEN) {
        return [
          { label: GetHailuoResolutionLabel(HailuoResolution.P512), value: HailuoResolution.P512 },
          { label: GetHailuoResolutionLabel(HailuoResolution.P768), value: HailuoResolution.P768 } // 默认
        ]
      }
    } else if (type === 'firstLastFrame') {
      // 首尾帧视频
      if (duration === HailuoDuration.SIX) {
        return [
          { label: GetHailuoResolutionLabel(HailuoResolution.P768), value: HailuoResolution.P768 }, // 默认
          { label: GetHailuoResolutionLabel(HailuoResolution.P1080), value: HailuoResolution.P1080 }
        ]
      } else if (duration === HailuoDuration.TEN) {
        return [
          { label: GetHailuoResolutionLabel(HailuoResolution.P768), value: HailuoResolution.P768 }
        ]
      }
    }
  } else {
    // 其他模型 (I2V-01-Director, I2V-01-live, I2V-01)
    if (duration === HailuoDuration.SIX) {
      return [
        { label: GetHailuoResolutionLabel(HailuoResolution.P720), value: HailuoResolution.P720 } // 默认
      ]
    }
    // 其他模型不支持10秒时长
  }

  return []
}

/**
 * 验证海螺视频分辨率是否有效
 * 
 * 根据视频生成类型、模型和时长，验证指定的分辨率是否被支持。
 * 不同的海螺视频模型在不同类型和时长下支持的分辨率范围不同。
 * 
 * @param type 视频生成类型 - 'textToVideo' (文生视频), 'imageToVideo' (图生视频), 'firstLastFrame' (首尾帧)
 * @param model 海螺视频模型 - 不同模型支持的分辨率范围不同
 * @param duration 视频时长 - 6秒或10秒，影响支持的分辨率选项
 * @param resolution 要验证的分辨率 - 512P, 720P, 768P, 1080P
 * 
 * @returns {boolean} 如果分辨率被支持则返回true，否则返回false
 * 
 * @description
 * - MiniMax-Hailuo-02 模型支持多种分辨率，但具体支持范围依赖于类型和时长
 * - I2V系列模型通常只支持720P分辨率
 * - 1080P分辨率通常只在6秒时长下被支持
 * 
 * @example
 * ```typescript
 * // 验证文生视频在MiniMax-Hailuo-02模型下6秒时长是否支持768P
 * const isValid = IsValidResolution('textToVideo', HailuoModel.MINIMAX_HAILUO_02, HailuoDuration.SIX, HailuoResolution.P768);
 * // isValid === true
 * 
 * // 验证图生视频在I2V-01模型下6秒时长是否支持1080P  
 * const isValid2 = IsValidResolution('imageToVideo', HailuoModel.I2V_01, HailuoDuration.SIX, HailuoResolution.P1080);
 * // isValid2 === false
 * ```
 * 
 * @see GetHailuoModelSupportedResolutions - 获取模型支持的分辨率列表
 */
export function IsValidResolution(type: ToVIdeoType, model: HailuoModel, duration: HailuoDuration, resolution: HailuoResolution): boolean {
  let spportedResolutions = GetHailuoModelSupportedResolutions(type, model, duration)

  // 检查传入的分辨率是否在支持的列表中
  return spportedResolutions.some(r => r.value === resolution)
}

/**
 * 获取海螺视频模型支持的时长选项
 * 
 * @param type 视频生成类型: 'textToVideo' (文生视频), 'imageToVideo' (图生视频), 'firstLastFrame' (首尾帧)
 * @param model 海螺视频模型枚举值或字符串
 * @param resolution 视频分辨率
 * @returns 返回支持的时长选项数组
 */
export function GetHailuoModelSupportedDurations(type: ToVIdeoType, model: HailuoModel | string, resolution?: HailuoResolution | string) {
  if (model === HailuoModel.MINIMAX_HAILUO_02) {
    if (type === 'textToVideo') {
      // 文生视频 - MiniMax-Hailuo-02 支持 6s 和 10s，但 1080P 只支持 6s
      if (resolution === HailuoResolution.P1080) {
        return [
          { label: GetHailuoDurationLabel(HailuoDuration.SIX), value: HailuoDuration.SIX }
        ]
      } else {
        return [
          { label: GetHailuoDurationLabel(HailuoDuration.SIX), value: HailuoDuration.SIX },
          { label: GetHailuoDurationLabel(HailuoDuration.TEN), value: HailuoDuration.TEN }
        ]
      }
    } else if (type === 'imageToVideo') {
      // 图生视频 - MiniMax-Hailuo-02 支持 6s 和 10s，1080P 只支持 6s
      if (resolution === HailuoResolution.P1080) {
        return [
          { label: GetHailuoDurationLabel(HailuoDuration.SIX), value: HailuoDuration.SIX }
        ]
      } else {
        // 512P, 768P 都支持 6s 和 10s
        return [
          { label: GetHailuoDurationLabel(HailuoDuration.SIX), value: HailuoDuration.SIX },
          { label: GetHailuoDurationLabel(HailuoDuration.TEN), value: HailuoDuration.TEN }
        ]
      }
    } else if (type === 'firstLastFrame') {
      // 首尾帧视频 - MiniMax-Hailuo-02 支持 6s 和 10s，但 1080P 只支持 6s
      if (resolution === HailuoResolution.P1080) {
        return [
          { label: GetHailuoDurationLabel(HailuoDuration.SIX), value: HailuoDuration.SIX }
        ]
      } else {
        return [
          { label: GetHailuoDurationLabel(HailuoDuration.SIX), value: HailuoDuration.SIX },
          { label: GetHailuoDurationLabel(HailuoDuration.TEN), value: HailuoDuration.TEN }
        ]
      }
    } else {
      // 兼容旧版本调用，默认逻辑
      if (resolution === HailuoResolution.P1080) {
        return [
          { label: GetHailuoDurationLabel(HailuoDuration.SIX), value: HailuoDuration.SIX }
        ]
      } else {
        return [
          { label: GetHailuoDurationLabel(HailuoDuration.SIX), value: HailuoDuration.SIX },
          { label: GetHailuoDurationLabel(HailuoDuration.TEN), value: HailuoDuration.TEN }
        ]
      }
    }
  } else {
    // 其他模型 (I2V-01-Director, I2V-01-live, I2V-01) 只支持6秒
    return [
      { label: GetHailuoDurationLabel(HailuoDuration.SIX), value: HailuoDuration.SIX }
    ]
  }
}

/**
 * 验证海螺视频时长是否有效
 * 
 * 根据视频生成类型、模型和分辨率，验证指定的时长是否被支持。
 * 不同的海螺视频模型在不同类型和分辨率下支持的时长范围不同。
 * 
 * @param type 视频生成类型 - 'textToVideo' (文生视频), 'imageToVideo' (图生视频), 'firstLastFrame' (首尾帧)
 * @param model 海螺视频模型 - 不同模型支持的时长范围不同
 * @param resolution 视频分辨率 - 512P, 720P, 768P, 1080P，影响支持的时长选项
 * @param duration 要验证的时长 - 6秒或10秒
 * 
 * @returns {boolean} 如果时长被支持则返回true，否则返回false
 * 
 * @description
 * - MiniMax-Hailuo-02 模型通常支持6秒和10秒，但1080P分辨率只支持6秒
 * - I2V系列模型 (I2V-01-Director, I2V-01-live, I2V-01) 只支持6秒时长
 * - 高分辨率（如1080P）通常限制为较短时长以保证生成质量
 * 
 * @example
 * ```typescript
 * // 验证文生视频在MiniMax-Hailuo-02模型下768P分辨率是否支持10秒
 * const isValid = IsValidDuratio('textToVideo', HailuoModel.MINIMAX_HAILUO_02, HailuoResolution.P768, HailuoDuration.TEN);
 * // isValid === true
 * 
 * // 验证图生视频在MiniMax-Hailuo-02模型下1080P分辨率是否支持10秒
 * const isValid2 = IsValidDuratio('imageToVideo', HailuoModel.MINIMAX_HAILUO_02, HailuoResolution.P1080, HailuoDuration.TEN);
 * // isValid2 === false (1080P只支持6秒)
 * 
 * // 验证I2V-01模型是否支持10秒时长
 * const isValid3 = IsValidDuratio('imageToVideo', HailuoModel.I2V_01, HailuoResolution.P720, HailuoDuration.TEN);
 * // isValid3 === false (I2V系列只支持6秒)
 * ```
 * 
 * @see GetHailuoModelSupportedDurations - 获取模型支持的时长列表
 */
export function IsValidDuratio(type: ToVIdeoType, model: HailuoModel, resolution: HailuoResolution, duration: HailuoDuration): boolean {
  // 获取当前模型、类型和分辨率组合下支持的所有时长选项
  let spportedResolutions = GetHailuoModelSupportedDurations(type, model, resolution)

  // 检查传入的时长是否在支持的列表中
  return spportedResolutions.some(r => r.value === duration)
}



/**
 * 获取海螺视频分辨率的标签
 * 
 * @param resolution 海螺视频分辨率枚举值或字符串
 * @returns 返回对应的中文标签
 */
export function GetHailuoResolutionLabel(resolution: HailuoResolution | string) {
  switch (resolution) {
    case HailuoResolution.P512:
      return t('512P')
    case HailuoResolution.P720:
      return t('720P')
    case HailuoResolution.P768:
      return t('768P')
    case HailuoResolution.P1080:
      return t('1080P')
    default:
      return t('未知')
  }
}

/**
 * 获取海螺视频分辨率选项列表
 * 
 * @returns 返回包含标签和值的选项数组，用于下拉选择框等UI组件
 */
export function GetHailuoResolutionOptions() {
  return [
    {
      label: GetHailuoResolutionLabel(HailuoResolution.P512),
      value: HailuoResolution.P512
    },
    {
      label: GetHailuoResolutionLabel(HailuoResolution.P720),
      value: HailuoResolution.P720
    },
    {
      label: GetHailuoResolutionLabel(HailuoResolution.P768),
      value: HailuoResolution.P768
    },
    {
      label: GetHailuoResolutionLabel(HailuoResolution.P1080),
      value: HailuoResolution.P1080
    }
  ]
}

/**
 * 获取海螺视频时长的标签
 * 
 * @param duration 海螺视频时长枚举值或数字
 * @returns 返回对应的中文标签
 */
export function GetHailuoDurationLabel(duration: HailuoDuration | number) {
  switch (duration) {
    case HailuoDuration.SIX:
      return t('6秒')
    case HailuoDuration.TEN:
      return t('10秒')
    default:
      return t('未知')
  }
}

/**
 * 获取海螺视频时长选项列表
 * 
 * @returns 返回包含标签和值的选项数组，用于下拉选择框等UI组件
 */
export function GetHailuoDurationOptions() {
  return [
    {
      label: GetHailuoDurationLabel(HailuoDuration.SIX),
      value: HailuoDuration.SIX
    },
    {
      label: GetHailuoDurationLabel(HailuoDuration.TEN),
      value: HailuoDuration.TEN
    }
  ]
}

//#endregion