import tencentcloud from 'tencentcloud-sdk-nodejs'
import { MD5 } from 'crypto-js'
import axios from 'axios'
import * as alimt20181012 from '@alicloud/alimt20181012'
import * as OpenApi from '@alicloud/openapi-client'
import * as Util from '@alicloud/tea-util'
import { GetOpenAISuccessResponse } from '../../../define/response/openAIResponse'
import { RetryWithBackoff } from '../../../define/Tools/common'
import { TranslateModel } from '@/define/model/translate'
import { GeneralResponse } from '@/define/model/generalResponse'
import { successMessage } from '@/public/generalTools'

let { Signer } = require('@volcengine/openapi')
import { OptionRealmService } from '@/define/db/service/optionService'
import { OptionKeyName } from '@/define/enum/option'
import { optionSerialization } from '../option/optionSerialization'
import { SettingModal } from '@/define/model/setting'
import { GetApiDefineDataById } from '@/define/data/apiData'
import { isEmpty } from 'lodash'

export class TranslateCommon {
  /** 请求的地址 */
  translationBusiness!: string
  /** 翻译的APPID，AI翻译的话是 模型 */
  translationAppId!: string
  /** 翻译的密钥，AI翻译的话是token */
  translationSecret!: string

  optionRealmService!: OptionRealmService

  constructor() {}

  /**
   * 初始化翻译设置
   */
  private async InitTranslate() {
    if (!this.optionRealmService) {
      this.optionRealmService = await OptionRealmService.getInstance()
    }
    // 当前默认是使用API翻译
    let aiSettingOptionString = this.optionRealmService.GetOptionByKey(
      OptionKeyName.InferenceAI.InferenceSetting
    )

    let aiSetting = optionSerialization<SettingModal.InferenceAISettings>(
      aiSettingOptionString,
      '‘设置-> 推理设置’'
    )

    let apiProvider = GetApiDefineDataById(aiSetting.apiProvider)
    if (apiProvider.gpt_url == null || isEmpty(apiProvider.gpt_url)) {
      throw new Error('未找到有效的GPT API地址')
    }
    this.translationBusiness = apiProvider.gpt_url
    this.translationAppId = aiSetting.translationModel
    this.translationSecret = aiSetting.apiToken
  }

  /**
   *
   * @param {*} value 0：当前要翻译的字符串
   * 1：源语言
   * 2：目标语言
   * 3：是否拆分（以逗号拆分）
   * [tags,'zh','en',false]
   */
  async TranslateReturnNow(
    value: TranslateModel.TranslateNowReturnParams
  ): Promise<GeneralResponse.SuccessItem> {
    try {
      await this.InitTranslate()
      // 百度翻译
      if (this.translationBusiness.includes('baidu')) {
        return await this.TranslateReturnNowBaidu(value)
      } else if (this.translationBusiness.includes('volcengine')) {
        // 火山引擎
        return await this.TranslateReturnNowVolcengine(value)
      } else if (this.translationBusiness.includes('tencent')) {
        // 腾讯翻译
        return await this.TranslateReturnNowTencent(value)
      } else if (this.translationBusiness.includes('aliyun')) {
        return await this.TranslateReturnNowAliyun(value)
      } else if (this.translationBusiness.includes('laitool')) {
        return await this.TranslateReturnNowGPT(value)
      } else {
        throw new Error('没有找到对应的翻译API')
      }
    } catch (error) {
      throw error
    }
  }

  //#region LAITOOL GPT翻译（只支持这个）

  /**
   *
   * @param value 使用laitool GPT翻译
   */
  async TranslateReturnNowGPT(
    value: TranslateModel.TranslateNowReturnParams
  ): Promise<GeneralResponse.SuccessItem> {
    try {
      // 判断该当前的翻译API
      let from = value.from
      let to = value.to
      if (value.isSplit) {
        throw new Error('使用GPT翻译不支持拆分')
      }
      let model = this.translationAppId
      let token = this.translationSecret

      let data = {
        model: model,
        messages: [] as any[]
      }
      // 开始调用GPT进行翻译
      if (from == 'en' && to == 'zh') {
        data.messages.push({
          role: 'system',
          content:
            '我想让你充当英译中专家，用中文100%还原描述，不要加其他的联想，只翻译字面意思，请检查所有信息是否准确，并在回答时保持简活，不需要任何其他反馈。'
        })
        // 添加示例
        data.messages.push({
          role: 'user',
          content:
            'A woman in her twenties with messy hair and a look of shock and despair. She is wearing a simple white shirt and jeans. Her face shows mixed emotions. The background is a dim and quiet room. The historical background is modern. The screen content is a close-up of the woman’s face with tear marks.'
        })
        data.messages.push({
          role: 'assistant',
          content:
            '一位二十多岁的女人，头发凌乱，表情震惊和绝望。她穿着一件简单的白色衬衫和牛仔裤。她的脸上显示出复杂的情感。背景是一个昏暗安静的房间。历史背景是现代的。屏幕内容是女人脸部的特写，带有泪痕。'
        })
        data.messages.push({
          role: 'user',
          content:
            'A twenty-something woman with short curly hair, smiling, wearing a casual white shirt and jeans, sitting on a comfortable sofa with a cup of coffee in her hand. She is in a small and cozy living room with a few books on the bookshelf, modern interior design, and natural light pouring into the room in the late afternoon. Screen content: Part of the sofa cushions.'
        })
        data.messages.push({
          role: 'assistant',
          content:
            '一位二十多岁的女性，留着短卷发，面带微笑，穿着休闲的白色衬衫和牛仔裤，手拿一杯咖啡，坐在一个舒适的沙发上。她所在的是一个小而温馨的客厅，书架上有几本书，现代室内设计，下午晚些时候，自然光线洒进房间。屏幕内容：沙发垫的一部分。'
        })
        data.messages.push({
          role: 'user',
          content:
            "In a modern city, a streamlined car is parked on the street. A man in his thirties, with short brown hair combed back, a calm, confident look, tall and thin in a clean white shirt and black pants, sits in the car. The interior of the car is clean and modern, and the background is blurred to highlight the man's calm demeanor. The man's cell phone is ringing. The scene is set in the present."
        })
        data.messages.push({
          role: 'assistant',
          content:
            '在现代城市，一辆流线型轿车停在街上。一个三十多岁的男人，短短的棕色头发梳向后，神情冷静，自信，穿着干净的白衬衫和黑裤子，身材高挑瘦长，坐在车里。车内干净而现代，背景模糊，以突出男人平静的神态。男人的手机正在响。场景设定在现在。'
        })
      } else if (from == 'zh' && to == 'en') {
        data.messages.push({
          role: 'system',
          content:
            '我想让你充当中译英专家，用中文100%还原描述，不要加其他的联想，只翻译字面意思，请检查所有信息是否准确，并在回答时保持简活，不需要任何其他反馈。'
        })
        // 添加示例
        data.messages.push({
          role: 'user',
          content:
            '一位二十多岁的女人，头发凌乱，表情震惊和绝望。她穿着一件简单的白色衬衫和牛仔裤。她的脸上显示出复杂的情感。背景是一个昏暗安静的房间。历史背景是现代的。屏幕内容是女人脸部的特写，带有泪痕。'
        })
        data.messages.push({
          role: 'assistant',
          content:
            'A woman in her twenties with messy hair and a look of shock and despair. She is wearing a simple white shirt and jeans. Her face shows mixed emotions. The background is a dim and quiet room. The historical background is modern. The screen content is a close-up of the woman’s face with tear marks.'
        })
        data.messages.push({
          role: 'user',
          content:
            '一位二十多岁的女性，留着短卷发，面带微笑，穿着休闲的白色衬衫和牛仔裤，手拿一杯咖啡，坐在一个舒适的沙发上。她所在的是一个小而温馨的客厅，书架上有几本书，现代室内设计，下午晚些时候，自然光线洒进房间。屏幕内容：沙发垫的一部分。'
        })
        data.messages.push({
          role: 'assistant',
          content:
            'A twenty-something woman with short curly hair, smiling, wearing a casual white shirt and jeans, sitting on a comfortable sofa with a cup of coffee in her hand. She is in a small and cozy living room with a few books on the bookshelf, modern interior design, and natural light pouring into the room in the late afternoon. Screen content: Part of the sofa cushions.'
        })
        data.messages.push({
          role: 'user',
          content:
            '在现代城市，一辆流线型轿车停在街上。一个三十多岁的男人，短短的棕色头发梳向后，神情冷静，自信，穿着干净的白衬衫和黑裤子，身材高挑瘦长，坐在车里。车内干净而现代，背景模糊，以突出男人平静的神态。男人的手机正在响。场景设定在现在。'
        })
        data.messages.push({
          role: 'assistant',
          content:
            "In a modern city, a streamlined car is parked on the street. A man in his thirties, with short brown hair combed back, a calm, confident look, tall and thin in a clean white shirt and black pants, sits in the car. The interior of the car is clean and modern, and the background is blurred to highlight the man's calm demeanor. The man's cell phone is ringing. The scene is set in the present."
        })
      } else {
        throw new Error('GPT翻译只支持中英互译')
      }

      data.messages.push({
        role: 'user',
        content: value.text
      })

      let config = {
        method: 'post',
        maxBodyLength: Infinity,
        url: this.translationBusiness,
        headers: {
          'Content-Type': 'application/json',
          Authorization: `Bearer ${token}`
        },
        data: JSON.stringify(data)
      }
      let res = await RetryWithBackoff(
        async () => {
          return await axios.request(config)
        },
        5,
        2000
      )
      // 将返回的数据进行拼接数据处理
      let content = GetOpenAISuccessResponse(res.data)

      let res_data = [] as any[]

      res_data.push({
        src: value.text,
        dst: content
      })
      return successMessage(
        {
          to: to,
          data: res_data
        },
        `GPT${from == 'en' ? '英' : '中'}译${from == 'en' ? '英' : '中'}翻译成功`,
        'Translate_TranslateReturnNowGPT'
      )
    } catch (error) {
      throw error
    }
  }

  //#endregion

  //#region 阿里云翻译

  /**
   * 阿里云翻译实时返回
   * @param {*} value
   */
  async TranslateReturnNowAliyun(
    value: TranslateModel.TranslateNowReturnParams
  ): Promise<GeneralResponse.SuccessItem> {
    try {
      // 判断该当前的翻译API
      let from = value.from
      let to = value.to
      let ts_d = value.text.replaceAll('_', ' ').replaceAll('，', ',')
      let req_data = {}
      let req_count = 0
      let req_arr = [] as string[]
      if (value.isSplit) {
        let tmp_arr = ts_d.split(',')
        for (let i = 0; i < tmp_arr.length; i++) {
          const element = tmp_arr[i]
          if (element != '' && element != null) {
            req_data[i.toString()] = element
            req_arr.push(element)
          }
          req_count += 1
        }
      } else {
        req_data['0'] = ts_d
        req_count = 1
        req_arr.push(ts_d)
      }
      if (req_count <= 0) {
        throw new Error('没有传入数据')
      }

      let config = new OpenApi.Config({
        accessKeyId: this.translationAppId,
        accessKeySecret: this.translationSecret
      })
      config.endpoint = `mt.cn-hangzhou.aliyuncs.com`

      let client = new alimt20181012.default(config)

      let getBatchTranslateRequest = new alimt20181012.GetBatchTranslateRequest({
        apiType: 'translate_standard',
        scene: 'general',
        sourceLanguage: from,
        targetLanguage: to,
        formatType: 'text',
        sourceText: JSON.stringify(req_data)
      })
      let runtime = new Util.RuntimeOptions({})

      // 复制代码运行请自行打印 API 的返回值
      let res = await client.getBatchTranslateWithOptions(getBatchTranslateRequest, runtime)
      console.log(res)

      if (!res.body) {
        throw new Error('aliyun翻译返回数据错误，请检查设置')
      }
      // 处理返回的数据
      // 检出返回的数据和输入的数据是不是一样的
      let translateList = res.body.translatedList as any[]
      if (translateList.length != req_count) {
        throw new Error('请求的数据长度和返回的数据长度不一致。请重试')
      }
      // {
      //     "src": "blush",
      //     "dst": "脸红"
      // }
      // 数据处理
      let res_data = [] as any[]
      for (let j = 0; j < req_arr.length; j++) {
        const item = req_arr[j]
        let res_tmp = translateList.find((item) => item.index == j)
        let obj = {
          src: item,
          dst: res_tmp.translated
        }
        res_data.push(obj)
      }

      // 直接返回数据
      return successMessage(
        {
          to: to,
          data: res_data
        },
        '翻译成功',
        'Translate_TranslateReturnNowAliyun'
      )
    } catch (error) {
      throw error
    }
  }

  //#endregion

  //#region 腾讯翻译

  /**
   * 腾讯翻译实时返回
   * @param {*} value
   */
  async TranslateReturnNowTencent(
    value: TranslateModel.TranslateNowReturnParams
  ): Promise<GeneralResponse.SuccessItem> {
    try {
      // 判断该当前的翻译API
      let from = value.from
      let to = value.to
      let ts_d = value.text.replaceAll('_', ' ').replaceAll('，', ',')
      let req_data = [] as string[]
      if (value.isSplit) {
        req_data = ts_d.split(',')
      } else {
        req_data.push(ts_d)
      }
      req_data = req_data.filter((item) => item != '' && item != null)
      if (req_data.length <= 0) {
        throw new Error('没有传入数据')
      }
      const CvmClient = tencentcloud.tmt.v20180321.Client
      const client = new CvmClient({
        credential: {
          secretId: this.translationAppId,
          secretKey: this.translationSecret
        },
        // 产品地域
        region: 'ap-shanghai',
        // 可选配置实例
        profile: {
          signMethod: 'TC3-HMAC-SHA256', // 签名方法
          httpProfile: {
            reqMethod: 'POST', // 请求方法
            reqTimeout: 60 // 请求超时时间，默认60s
          }
        }
      })

      let res = await client.TextTranslateBatch({
        SourceTextList: req_data,
        Source: from,
        Target: to,
        ProjectId: 0
      })
      console.log(res)

      // 处理返回的数据
      if (!res.TargetTextList) {
        throw new Error('腾讯翻译返回数据错误，请检查设置')
      }
      // 检出返回的数据和输入的数据是不是一样的
      let translateList = res.TargetTextList as string[]
      if (translateList.length != req_data.length) {
        throw new Error('请求的数据长度和返回的数据长度不一致。请重试')
      }
      // {
      //     "src": "blush",
      //     "dst": "脸红"
      // }
      // 数据处理
      let res_data = [] as any[]
      for (let j = 0; j < req_data.length; j++) {
        const item = req_data[j]
        let obj = {
          src: item,
          dst: translateList[j]
        }
        res_data.push(obj)
      }

      // 直接返回数据
      return successMessage(
        {
          to: to,
          data: res_data
        },
        '翻译成功',
        'Translate_TranslateReturnNowTencent'
      )
    } catch (error) {
      throw error
    }
  }
  //#endregion

  //#region 火山引擎翻译

  /**
   * 火山引擎翻译实时返回
   * @param {*} value
   */
  async TranslateReturnNowVolcengine(
    value: TranslateModel.TranslateNowReturnParams
  ): Promise<GeneralResponse.SuccessItem> {
    try {
      // 判断该当前的翻译API
      let from = value.from
      let to = value.to
      let ts_d = value.text.replaceAll('_', ' ').replaceAll('，', ',')
      let req_data = [] as string[]
      if (value.isSplit) {
        req_data = ts_d.split(',')
      } else {
        req_data.push(ts_d)
      }
      if (req_data.length <= 0) {
        throw new Error('没有传入数据')
      }
      let signer = await this.GetVolcengineSinger()

      let config = {
        method: 'post',
        maxBodyLength: Infinity,
        url: `${this.translationBusiness}${signer}`,
        headers: {
          'Content-Type': 'application/json'
        },
        data: JSON.stringify({
          SourceLanguage: from,
          TargetLanguage: to,
          TextList: req_data
        })
      }
      let res = await axios.request(config)
      if (res.status != 200) {
        throw new Error('请求错误。请检查网络')
      }
      // 判断是不是有返回错误
      if (res.data.ResponseMetadata && res.data.ResponseMetadata.Error) {
        let err = res.data.ResponseMetadata.Error
        throw new Error(
          `错误码： ${err.Code}  错误编号：${err.CodeN}  错误详细信息：${err.Message}`
        )
      }

      // 处理返回的数据
      // 检出返回的数据和输入的数据是不是一样的
      let translateList = res.data.TranslationList
      if (translateList.length != req_data.length) {
        throw new Error('请求的数据长度和返回的数据长度不一致。请重试')
      }

      // 数据处理
      let res_data = [] as any[]
      for (let j = 0; j < req_data.length; j++) {
        const item = req_data[j]
        let obj = {
          src: item,
          dst: translateList[j].Translation
        }
        res_data.push(obj)
      }

      // 直接返回数据
      return successMessage(
        {
          to: to,
          data: res_data
        },
        '翻译成功',
        'Translate_TranslateReturnNowVolcengine'
      )
    } catch (error) {
      throw error
    }
  }

  /**
   * 获取火山引擎请求的签名
   */
  async GetVolcengineSinger() {
    try {
      const openApiRequestData = {
        method: 'POST',
        region: 'cn-north-1',
        params: {
          Action: 'TranslateText',
          Version: '2020-06-01'
        },
        Service: 'translate'
      }

      const credentials = {
        accessKeyId: this.translationAppId,
        secretKey: this.translationSecret
      }

      const signer = new Signer(openApiRequestData, 'translate')

      // 最终经过加签的 HTTP Query Params
      const signedQueryString = signer.getSignUrl(credentials)
      console.log(signedQueryString)
      return signedQueryString
    } catch (error) {
      throw error
    }
  }

  //#endregion

  //#region  百度翻译
  /**
   * 百度翻译引擎翻译单个数据。立即返回
   * @param {*} value
   * @returns
   */
  async TranslateReturnNowBaidu(value: TranslateModel.TranslateNowReturnParams) {
    try {
      // 判断该当前的翻译API
      let appId = this.translationAppId
      let ts_d = value.text.replaceAll('_', ' ').replaceAll('，', ',')
      if (value.isSplit) {
        ts_d = ts_d.replaceAll('.', '\n')
      }
      let salt = Date.now()
      let sign = MD5(`${this.translationAppId}${ts_d}${salt}${this.translationSecret}`).toString()
      let res = await axios.get(this.translationBusiness, {
        params: {
          q: ts_d,
          appid: appId,
          salt: salt,
          from: value.from,
          to: value.to,
          sign: sign
        }
      })
      if (res.status != 200) {
        throw new Error('请求错误。请检查网络')
      }
      // 判断是不是有错误码
      if (res.data.error_code) {
        throw new Error(res.data.error_msg)
      }

      let res_data = []
      res_data = res.data.trans_result
      // 直接返回数据
      return successMessage(
        {
          to: value.to,
          data: res_data
        },
        '翻译成功',
        'Translate_TranslateReturnNowBaidu'
      )
    } catch (error) {
      throw error
    }
  }
  //#endregion
}