// uniapp people side tools

import './ican-H5Api.js' // 对齐H5Api: https://ext.dcloud.net.cn/plugin?id=415 // 注意要取消默认自带的 showToast https://uniapp.dcloud.io/api/system/clipboard?id=%e6%b3%a8%e6%84%8f
const BASE_TYPE_DEFAULT = 'SERVER' // one of { SERVER: 服务器, UNICLOUD_FUNC: 云函数, UNICLOUD_OBJECT: 云对象 }

function langNow () {
  // getCurrentPages() 在 topWindow/App.vue 里有可能为空，所以用 getApp().$store 更安全. 20230513: 发现在微信小程序模拟器里，getApp().$store.state 未定义，所以还是用 wo.ss
  return wo?.ss?.i18n?.mylang || getApp()?.$store?.state?.i18n?.mylang
}

export default {
  // 用直观的色彩，代替语义化的类型：
  // uView 中大量组件都使用 type 来设置颜色，而 uni-ui 中只有少量组件用到。
  c2t: {
    RED: 'error',
    GREEN: 'success',
    BLUE: 'primary',
    YELLOW: 'warning',
    GREY: 'info',

    uAlertTips: { YELLOW: 'warning', BLUE: 'primary', RED: 'error', GREY: 'info', GREEN: 'success' },
    uBadge: { RED: 'error', BLUE: 'primary', YELLOW: 'warning', GREY: 'info', GREEN: 'success' },
    uButton: { WHITE: 'default', BLUE: 'primary', YELLOW: 'warning', RED: 'error', GREY: 'info', GREEN: 'success' },
    uNoticeBar: { YELLOW: 'warning', BLUE: 'primary', RED: 'error', GREY: 'info', GREEN: 'success', TRANS: 'none' },
    uTag: { BLUE: 'primary', RED: 'error', YELLOW: 'warning', GREY: 'info', GREEN: 'success' },
    uToast: { BLACK: 'default', BLUE: 'primary', YELLOW: 'warning', RED: 'error', GREY: 'info', GREEN: 'success' },
    uTopTips: { BLUE: 'primary', RED: 'error', YELLOW: 'warning', GREY: 'info', GREEN: 'success' },

    uniBadge: { GREY: 'default', YELLOW: 'warning', BLUE: 'primary', GREEN: 'success', RED: 'error' },
    uniButton: { GREY: 'default', RED: 'warn', RGB: 'primary' },
    uniPopupDialog: { GREEN: 'success', YELLOW: 'warn', RED: 'error', GREY: 'info' },
    uniPopupMessage: { GREEN: 'success', YELLOW: 'warn', RED: 'error', GREY: 'info' },
    uniTag: { GREY: 'default', YELLOW: 'warning', BLUE: 'primary', GREEN: 'success', RED: 'error', PURPLE: 'royal' },
  },

  thisPage () {
    return this.__page__
      ? this // constructor.name==='VueComponent' 只在 development 环境有用，在 production 环境会被简化成 'o'。
      : getCurrentPages().pop() || {} // [20220401] 发现在 topWindow 里，或者在 App.vue 里, getCurrentPages() 是 undefined 和 空数组 []，因此在这里默认 {} 做保护。
  },

  localizeText (i18nText) {
    i18nText =
      i18nText || // 如果传入i18n参数 ({zhCN:'...', enUS:'...'})
      this.i18nText || // 1) 如果挂载到具体页面的 computed { lote: wo.localizeText } 那么 this 就是当前页面，直接取用 this.i18nText 即可。2) 对于组件内定义的 i18nText，要使用 this 来获得组件内的 i18nText
      getCurrentPages()?.pop()?.i18nText // 如果不是挂载到 Vue.prototype 而是 挂载到 wo 下调用，那么 this.i18nText 就不存在了。因此通过 pageNow.i18nText 访问。
    return i18nText?.[langNow()] || (typeof i18nText === 'string' ? i18nText : '') // 必须检测是否string，如果直接返回 i18nText 可能返回{}等，导致依赖于返回空值的前端出错
  },

  localeText () {
    // 专供绑定到 computed { lote: wo.localeText } 使用，这时 this 就是当前页面。
    return this.i18nText?.[langNow()] || {}
  },

  setBarTitles ({ windowTitle, pageTitle, pagesJson = this.pagesJson || wo?.pagesJson, envar = this.envar || wo?.envar } = {}) {
    const langNow = langNow()
    const pageNow = getCurrentPages()?.pop?.() // 需要兼顾在 App.vue 时无法获取当前页面的情况，因为如果在 topWindow 里调用本函数，getApp() 和 getCurrentPages() 就是 undefined。

    const navibarTitle =
      pageTitle ||
      pageNow?.i18nPageTitle?.[langNow] || // 页面.vue 的 i18nPageTitle 变量
      pageNow?.i18nText?.[langNow]?.tPageTitle || // 页面.vue 的 i18nText 对象
      pageNow?.pageTitle ||
      pagesJson?.pages?.find((page) => page.path === pageNow?.route)?.i18nPageTitle?.[langNow] || // pages.json 的页面配置里
      ''

    windowTitle =
      windowTitle || wo?.envar?.callname?.[langNow] || pagesJson?.appInfo?.i18nText?.[langNow] || pagesJson?.globalStyle?.navigationBarTitleText || ''

    if (uni.getSystemInfoSync().deviceType === 'pc') {
      uni.setNavigationBarTitle({ title: windowTitle + (navibarTitle ? ` - ${navibarTitle}` : '') })
    } else {
      uni.setNavigationBarTitle({ title: navibarTitle })
    }

    //#ifdef H5
    //// 设置窗口标题栏 document.title
    //// navibarTitle 也会被用于浏览器的标签标题，可用 document.title 去覆盖。必须放在 setNavigationBarTitle 之后。
    //// 但这个方案，在电脑上，还是会显示 navibarTitle 在浏览器窗口顶栏，不知为何。
    if (uni.getSystemInfoSync().deviceType === 'phone' && /MicroMessenger/i.test(globalThis.window?.navigator?.userAgent)) {
      //// 微信浏览器里，本身就显示了标题栏，和自有的导航栏形成功能重叠和混淆。
      //// 设置标题栏为空或覆盖
      document.title = windowTitle
      //// 或者设置导航栏隐藏。但这样导致，用户容易误点微信浏览器标题栏的 X 关掉页面，所以还是显示导航栏吧。
      // document.getElementsByTagName('uni-page-head')?.[0]?.remove() // 或者 [0]?.style?.display = 'none'
    }
    //#endif

    if (uni.getSystemInfoSync().deviceType === 'pc') {
      uni.hideTabBar()
    } else {
      // 必须要在有 tab 的页面里 setTabBarItem 才有效果
      //const midIndex = parseInt(pagesJson?.tabBar?.list?.length/2) // 如果存在midButton,实际上tabBar.list.length必须为偶数。不过为了心安，再parseInt一下。
      pagesJson?.tabBar?.list?.forEach((tab, tabIndex) => {
        if (tab.i18nText && tab.i18nText[langNow]) {
          uni.setTabBarItem({
            // #ifdef H5
            index: tabIndex, // + ((pagesJson?.tabBar?.midButton?.iconPath && tabIndex >= midIndex)?1:0), // H5 里，如果使用了 midButton，tabBarItem的index出现错位，需hack调整。推测，在H5里 midButton 作为一个普通tab被插入到 tabBar 里，导致 tabBar 的 index 和 pagesJson.tabBar.list 的 index 错位了。[20211031] 注意到，从 HBuilderX 3.2.12.20211029 起，在 H5 里也没有错位了。
            // #endif
            // #ifndef H5
            index: tabIndex,
            // #endif
            text: tab.i18nText[langNow],
          })
        }
      })
    }
  },

  makeServerUrl (route = '') {
    if (/^https?:\/\//.test(route)) {
      return route
    }

    if (typeof route !== 'string') route = '' // 防止 route 为 null, undefined 等由于后台数据库默认值而造成的异常。
    route = route.replace('\\', '/').replace(/^\//, '')

    const envar = this.envar || wo?.envar || {}

    if (envar.servUrl) {
      return `${envar.servUrl}/${route}`
    } else {
      const hostname = envar.servHostname /*|| globalThis.window?.location?.hostname*/ || 'localhost'
      const port = envar.servPort /*|| globalThis.window?.location?.port*/ || ''
      const protocol = hostname === 'localhost' ? 'http' : envar.servProtocol || (process.env.NODE_ENV === 'production' ? 'https' : 'http')
      return `${protocol}://${hostname}${port ? ':' : ''}${port}/${route}`
    }
  },

  makeBgUrl (path) {
    if (path) {
      return `url(${this.makeServerUrl(path)})`
    }
    return ''
  },

  /** 统一 uni.request 和 uniCloud.callFunction 的调用方法，提供统一、透明的后台调用
   * 返回值：{ _state, 成功结果或错误结果 }，其中 _state 除了后台返回的，还可以是
   * - CLIENT_WOBASE_BROKEN: 前端发现后台断线
   * - CLIENT_WOBASE_TIMEOUT: 前端发现后台超时
   * - CLINET_WOBASE_EXCEPTION: 前端发现后台异常
   **/
  async callBase ({
    baseType = this.envar?.baseTypeDefault || wo?.envar?.baseTypeDefault || BASE_TYPE_DEFAULT,
    httpMethod = 'POST',
    apiVersion = 'api',
    apiWho,
    apiTodo,
    apiWhat = {},
    timeout,
  }) {
    const thisRoute = getCurrentPages()?.pop?.()?.route || 'VueApp' // 立刻保存 route，因为在调用后台后，可能已切换到了其他页面。
    const startTime = new Date().toJSON()
    let url = undefined
    let result = {}
    if (baseType === 'UNICLOUD_OBJECT') {
      const uniObj = uniCloud.importObject(apiWho)
      try {
        result = await uniObj[apiTodo](apiWhat)
      } catch (error) {
        result = { _state: 'CLINET_WOBASE_EXCEPTION', error }
      }
    } else if (baseType === 'UNICLOUD_FUNC') {
      let { /* success, header, requestedId, */ result: resultCloud = {} } = await uniCloud
        .callFunction({
          name: apiWho,
          data: {
            apiTodo,
            apiWhat,
            _passtoken: uni.getStorageSync('_passtoken'),
            // uniIdToken // uniCloud自动getStorageSync('uni_id_token')并传递为 uniIdToken；也可自行组装传入 uniIdToken
          },
        })
        .catch((error) => {
          // {errMsg, stack} = error
          if (/request:fail/.test(error.errMsg)) {
            // 后台云服务无法连接
            return { _state: 'CLIENT_WOBASE_BROKEN', error }
          } else {
            // 后台云服务返回异常
            return { _state: 'CLIENT_WOBASE_EXCEPTION', error }
          }
        })
      result = resultCloud
    } else if (baseType === 'SERVER') {
      if (httpMethod === 'GET') {
        // 如果不是 POST 方法,要额外把参数JSON化
        for (let key in apiWhat) {
          apiWhat[key] = JSON.stringify(apiWhat[key])
        }
      }
      url = this.makeServerUrl(`${apiVersion}/${apiWho}/${apiTodo}`)
      let [error, { statusCode, header, errMsg, data: resultServer = {} } = {}] = await uni.request({
        method: httpMethod,
        url: url,
        data: { ...apiWhat, _passtoken: uni.getStorageSync('_passtoken') },
        timeout,
      })
      if (error) {
        if (error.errMsg === 'request:fail') {
          // 后台服务器无法连接
          result = { _state: 'CLIENT_WOBASE_BROKEN', error }
        } else if (error.errMsg === 'request:fail timeout') {
          // 后台服务器超时
          result = { _state: 'CLIENT_WOBASE_TIMEOUT', error }
        } else {
          // 后台服务器返回异常
          result = { _state: 'CLIENT_WOBASE_EXCEPTION', error }
        }
      } else {
        result = resultServer
      }
    } else {
      result = { _state: 'CLIENT_WOBASE_TYPE_UNKNOWN' }
    }
    // 注意1，resultServer 和 resultCloud 推荐遵循同样的格式 { _state, error | data }，这样方便前端做统一判断。
    // 注意2，虽然预设了 resultServer 和 resultCloud = {}，但如果后台返回了 null，那么 resultServer/resultCloud 也是 null。
    if (process.env.NODE_ENV !== 'production') {
      console.log(
        `%c(IN) ${startTime} ${thisRoute} :: ${apiTodo}`,
        'background: #87cefa; border-radius: 0.5em;color: white; font-weight: bold; padding: 2px 0.5em;',
        {
          baseType,
          apiWho,
          apiTodo,
          apiWhat,
          timeout,
          url,
        }
      )
      console.log(
        `%c(OUT) ${new Date().toJSON()} ${thisRoute} :: ${apiTodo}`,
        'background: #4169e1; border-radius: 0.5em;color: white; font-weight: bold; padding: 2px 0.5em;',
        result
      )
    }
    return result
  },

  async pickupFile2Server ({
    mediaType = 'image',
    count = 1,
    sizeType = ['original', 'compressed'],
    sourceType = ['album', 'camera'],
    url = 'api/Fileloader/receiveFile', // 默认后台用这个接口来接受文件
    header = {},
    formData = {},
    name = 'file',
  } = {}) {
    // 有的管理后台不需要登录就允许上传，例如 cmctoy。因此不要在这里依赖登录状态。

    let filePath
    if (mediaType === 'image') {
      let [errorChoose, { tempFilePaths, tempFiles } = {}] = await uni.chooseImage({ count, sizeType, sourceType })
      filePath = tempFilePaths[0]
    } else if (mediaType === 'video') {
      let [errorChoose, { tempFilePath }] = await uni.chooseVideo({ sourceType })
      filePath = tempFilePath
    } else {
      return { _state: 'UNKNOWN_MEDIATYPE' }
    }

    if (filePath) {
      for (let key in formData) {
        // multer 不会自动处理 JSON 数据,必须前后端配合处理
        formData[key] = JSON.stringify(formData[key])
      }
      // 在 Fileloader/fileloader.js 里，已经不再依赖 _passtoken，而且 header 在被 nginx 或 cloudflare （没搞清楚是谁干的）代理之后也被过滤掉了，因此不再使用这一句： header._passtoken = uni.getStorageSync('_passtoken')

      uni.showLoading()
      let [errorUpload, { data, statusCode } = {}] = await uni.uploadFile({ url: this.makeServerUrl(url), filePath, name, header, formData })
      // 后台 Multer 处理 req.file = { destination, filename, originalname, path, mimetype, size }, 其中 path 包括了 destination 和 filename 的文件相对路径。
      // url 所在方法进一步处理后，通过 uni.uploadFile 存在 data 里返回结果
      uni.hideLoading()

      if (typeof data === 'string') {
        // 不知为何，uni.uploadFile返回的 data 是字符串而不是对象
        try {
          data = JSON.parse(data)
        } catch (exp) {
          return { _state: 'CLIENT_FAIL_RESPONSE_JSON_MALFORMED' }
        }
      }

      if (data?._state === 'SUCCESS' && data?.path) {
        return { _state: 'SUCCESS', fileUrl: this.makeServerUrl(data.path), filePath: data.path, ...data }
      } else {
        return { _state: 'CLIENT_FAIL_UPLOAD_FILE', error: errorUpload }
      }
    } else {
      return { _state: 'CLIENT_FAIL_CHOOSE_FILE' }
    }
  },

  async pickupFile2Cloud ({ mediaType = 'image', count = 1, sizeType = ['original', 'compressed'], sourceType = ['album', 'camera'], maxDuration } = {}) {
    // 有的管理后台不需要登录就允许上传，例如 cmctoy。因此不要在这里依赖登录状态。
    // if (!uni.getStorageSync('_passtoken')) {
    //   return { _state: 'USER_OFFLINE', errMsg: 'offline user cannot upload files' }
    // }

    let filePath,
      cloudPath,
      osName = uni.getSystemInfoSync().osName
    if (mediaType === 'image') {
      let [errorChoose, { tempFilePaths, tempFiles } = {}] = await uni.chooseImage({ count, sizeType, sourceType })
      //      uni.showModal({ title: 'tempFilePaths[0]=' + tempFilePaths[0] })
      filePath = tempFilePaths[0] // 在 H5 上并不是文件路径名，而是类似 "blob:http://localhost:8080/f0d3e54d-0694-4803-8097-641d76a10b0d“。
      // #ifndef H5
      // let [errorGetImageInfo, { path, width, height, orientation, type }] = await uni.getImageInfo({ src: filePath })
      // cloudPath = path // 完整路径，包含后缀名。形如 file:///var/mobile/Containers/Data/Application/55A76332-44F5-4D5F-A9F6-3F857D584883/Documents/Pandora/apps/D064A425A8BEC13F9D8F741B98B37BC5/doc/uniapp_temp_1598593902955/compressed/1598593925815.png
      cloudPath = `APP_${osName}__${filePath}` // 在 iOS 上是 "_doc/uniapp_temp_1598593902955/compressed/1598593925815.png", 有时还包含从 file:/// 开始的完整路径名
      // #endif
      // #ifdef H5
      cloudPath = `H5_${osName}_${this.parse_ua_to_browser()}__${tempFiles[0].name}` // name is available in H5 only. 只包含文件名和后缀名，不包含路径。
      // #endif
    } else if (mediaType === 'video') {
      let [errorChoose, { tempFilePath, tempFile, duration, size, width, height, name }] = await uni.chooseVideo({ sourceType, maxDuration })
      //      uni.showModal({ title: 'tempFilePath=' + tempFilePath })
      filePath = tempFilePath // 在 iOS 上形如 "file:///var/mobile/Containers/Data/Application/55A76332-44F5-4D5F-A9F6-3F857D584883/Documents/Pandora/apps/26B43CD2F587D37FC6799108434A6F84/doc/uniapp_temp_1598596171580/gallery/IMG_3082.MOV"
      // #ifndef H5
      cloudPath = `APP_${osName}_dur${duration}__${filePath}`
      // #endif
      // #ifdef H5
      cloudPath = `H5_${osName}_${this.parse_ua_to_browser()}_dur${duration}__${name}` // tempFile and name are H5 only
      // #endif
      // iOS 上测试，filePath 为 *.MOV，而阿里云只允许 *.mp4, 所以添加 .mp4 后缀。参见 https://uniapp.dcloud.net.cn/uniCloud/storage?id=clouduploadfile
      // 20200915测试，阿里云支持上传 *.mov 了。
      if (!/\.(mp4|mov)$/i.test(cloudPath)) cloudPath = cloudPath + '.mp4'
    } else {
      let { errMsg, tempFilePaths, tempFiles } = await uniCloud.chooseAndUploadFile({
        type: 'all',
        count: 1,
        // extention: [],
        // onChooseFile: ({ errMsg, tempFilePaths, tempFiles }) => { },
        // onUploadProgress: ({ index, loaded, total, tempFilePath, tempFile }) => { }
      })
      if (errMsg === 'chooseAndUploadFile:ok') {
        return { _state: 'SUCCESS', fileUrl: tempFiles?.[0]?.url }
      } else {
        return { _state: 'CLIENT_FAIL_chooseAndUploadFile' }
      }
    }

    if (filePath) {
      uni.showLoading()
      const { fileID, requestId } = await uniCloud.uploadFile({
        filePath: filePath,
        cloudPath: process.env.NODE_ENV !== 'production' ? 'dev_' + cloudPath : cloudPath, // 关键是要具有文件格式后缀名，这样可以保持阿里云下载链接也用这个后缀名。
        fileType: mediaType, // = image, video, audio
        onUploadProgress: function (progressEvent) {
          var percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total)
        },
      })
      uni.hideLoading()

      if (fileID) {
        return { _state: 'SUCCESS', fileUrl: fileID, requestId }
      } else {
        return { _state: 'CLIENT_WOBASE_FAIL_uploadFile' }
      }
    }
    return { _state: 'CLIENT_FAIL_chooseFile' }
  },

  async pickupFile ({
    baseType = this.envar?.baseTypeDefault || wo?.envar?.baseTypeDefault || BASE_TYPE_DEFAULT,
    mediaType = 'image',
    count = 1,
    sizeType = ['original', 'compressed'],
    sourceType = ['album', 'camera'],
    maxDuration,
    url,
    header = {},
    formData = {},
    name = 'file',
  } = {}) {
    if (/^UNICLOUD/.test(baseType)) {
      return await this.pickupFile2Cloud({ mediaType, count, sizeType, sourceType, maxDuration })
      return resultCloud
    } else if (baseType === 'SERVER') {
      return await this.pickupFile2Server({ mediaType, count, sizeType, sourceType, maxDuration, url, header, formData, name })
    } else {
      return { _state: 'CLEINT_FAIL_UNKNOWN_WOBASE_TYPE', baseType }
    }
  },

  open_url_in_browser (url) {
    // #ifdef APP-PLUS
    plus.runtime.openURL(url)
    // #endif
    // #ifdef H5
    window.open(url, '_blank')
    // #endif
  },

  parse_ua_to_browser () {
    let userAgent = ''
    // #ifdef H5
    userAgent = window.navigator.userAgent.toLowerCase()
    return /msie/.test(userAgent) && !/opera/.test(userAgent)
      ? 'msie'
      : /opera/.test(userAgent)
      ? 'opera'
      : /version.*safari/.test(userAgent)
      ? 'safari'
      : /chrome/.test(userAgent)
      ? 'chrome'
      : /gecko/.test(userAgent) && !/webkit/.test(userAgent)
      ? 'firefox'
      : /micromessenger/.test(userAgent)
      ? 'wechat'
      : 'unknown' // 只要在 H5, 即使不认识也要返回一个名称。
    // #endif
    return '' // 如果不在 H5。
  },

  /*
   * uni.showToast({ 
     icon=success (by default)/loading/none, 
     position(app only):center|top|bottom, 
     success, fail, complete // 函数调用后立刻发生，不是在toast之后
    })
   * ucToast.show({ 
     type=info (by default)/success/error/warning|loading, 
     position:top/bottom 
    })
   * uToptips.show({ 
     type=default (by default)/primary/success/error/warning/info, 
     position:center/top/bottom, 
     callback // 发生在 toast 之后
    })
   */
  showToast ({ tool, type = 'success', image, title, duration = 2000, ...rest }) {
    // rename to popToast?
    if (tool !== 'uni') {
      // 来自 <ucToast> 或 <u-toast> 或 <u-top-tips>
      const toast = getCurrentPages()?.pop()?.$refs?.toast || getApp().globalData?.toast || wo.toast
      const popup = getCurrentPages()?.pop()?.$refs?.popup || getApp().globalData?.popup || wo.popup
      if (toast) {
        toast.show({ type, title, duration, ...rest })
        return
      } else if (popup) {
        wo.ss.popMessage = title
        wo.ss.popType = type // success/error/warning/info
        wo.ss.popDuration = duration
        popup.open()
        return
      }
    }
    // #ifdef APP-PLUS
    uni.showToast({ icon: 'none', title, duration, ...rest })
    // #endif
    // #ifdef H5
    uni.showToast({ icon: 'none', image, title, duration, ...rest })
    // #endif
  },

  // precision 要有默认值，以防无法连接后台时，这个方法会导致 part-header.vue 出错。
  formatMoney (amount, { precision = 2 } = {}) {
    // parseInt(NaN/undefined/false/null/'') 都返回 NaN，而 Number(false/null/'')===0，因此用 parseInt 来过滤无效输入。
    // 或者可以 if (!['number', 'string'].includes(typeof amount) && [NaN, undefined, false, null, ''].includes(amount))
    if (Number.isNaN(parseInt(amount))) {
      return ''
    }
    // Number(amount).toFixed(precision) // toFixed 虽然方便，但是会自动四舍五入。
    return `${parseInt(Number(amount) * Math.pow(10, precision)) / Math.pow(10, precision)}`
  },

  format_coin (amount, { coin = wo.envar.KEYNAME, precision = 8 } = {}) {
    if (Number.isNaN(parseInt(amount))) {
      return ''
    }
    if (coin === wo.envar.KEYNAME && wo.ss.envarRemote?.pexPrecision) {
      precision = wo.ss.envarRemote?.pexPrecision
    }
    return `${parseInt(Number(amount) * Math.pow(10, precision)) / Math.pow(10, precision)}`
  },

  formatPercent (value, precision = 2) {
    return Number(value * 100 || 0).toFixed(precision)
  },

  formatDate (date, format) {
    if (!(date instanceof Date)) {
      if (typeof date === 'string' && /^\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d$/.test(date)) {
        // 这是从 typeorm 数据库得到的Date类型的值
        date = date.replace(/-/g, '/') // safari 不支持 yyyy-mm-dd，必须改成 yyyy/mm/dd
      }
      date = new Date(date)
    }
    if (!date.toJSON()) {
      date = new Date()
    }

    format = format && typeof format === 'string' ? format : 'yyyy-mm-dd HH:MM:SS'
    let o = {
      'm+': date.getMonth() + 1, //月份
      'q+': Math.floor((date.getMonth() + 3) / 3), //季度
      'd+': date.getDate(), //日
      'H+': date.getHours(), //小时
      'M+': date.getMinutes(), //分
      'S+': date.getSeconds(), //秒
      s: date.getMilliseconds(), //毫秒
    }
    if (/(y+)/.test(format)) format = format.replace(RegExp.$1, `${date.getFullYear()}`.substr(4 - RegExp.$1.length))
    for (var k in o) {
      if (new RegExp(`(${k})`).test(format)) format = format.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] : `00${o[k]}`.substr(`${o[k]}`.length))
    }
    return format
  },

  getUserEndLanIp (callback) {
    let recode = {}
    let RTCPeerConnection = window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection
    // 如果不存在则使用一个iframe绕过
    if (!RTCPeerConnection) {
      // 因为这里用到了iframe，所以在调用这个方法的script上必须有一个iframe标签
      // <iframe id="iframe" sandbox="allow-same-origin" style="display:none;"></iframe>
      let win = iframe.contentWindow
      RTCPeerConnection = win.RTCPeerConnection || win.mozRTCPeerConnection || win.webkitRTCPeerConnection
    }
    //创建实例，生成连接
    let pc = new RTCPeerConnection()
    // 匹配字符串中符合ip地址的字段
    function handleCandidate (candidate) {
      let ip_regexp = /([0-9]{1,3}(\.[0-9]{1,3}){3}|([a-f0-9]{1,4}((:[a-f0-9]{1,4}){7}|:+[a-f0-9]{1,4}){6}))/
      let ip_isMatch = candidate.match(ip_regexp)[1]
      if (!recode[ip_isMatch]) {
        callback(ip_isMatch)
        recode[ip_isMatch] = true
      }
    }
    //监听icecandidate事件
    pc.onicecandidate = (ice) => {
      if (ice.candidate) {
        handleCandidate(ice.candidate.candidate)
      }
    }
    //建立一个伪数据的通道
    pc.createDataChannel('')
    pc.createOffer(
      (res) => {
        pc.setLocalDescription(res)
      },
      () => {}
    )
    //延迟，让一切都能完成
    setTimeout(() => {
      let lines = pc.localDescription.sdp.split('\n')
      lines.forEach((item) => {
        if (item.indexOf('a=candidate:') === 0) {
          handleCandidate(item)
        }
      })
    }, 1000)
  },

  goto_page (pageName, { forget = false, pagesJson = this.pagesJson || wo?.pagesJson } = {}) {
    if (pageName) {
      if (pagesJson?.tabBar?.list?.find((item) => item?.pagePath?.substr(6) === pageName)) {
        // 注意，即使在 PC 上 topWindow 代替了 tabBar 时，从标签页转化而来的菜单页，也是用 switchTab 跳转。
        uni.switchTab({ url: pageName })
      } else if (forget) {
        uni.navigateTo({ url: pageName })
      } else {
        uni.redirectTo({ url: pageName })
      }
    } else {
      uni.navigateBack()
    }
  },

  next_focus (currentFocus, focusList) {
    focusList = focusList || getCurrentPages?.pop()?.focusList
    if (focusList) {
      for (let n in focusList) {
        focusList[n] = false
      }
      setTimeout(() => {
        focusList[(parseInt(currentFocus) + 1) % Object.keys(focusList).length] = true
      }, 200) // 如果没有 setTimeout 至少 200ms, 焦点短暂跳到下一个后，又会消失
    }
  },

  copy_to_clipboard (text, toastLength = 50) {
    uni.setClipboardData({
      data: text,
      success: () => {
        uni.hideToast()
        wo.tt.showToast({
          type: wo.c2t.GREEN,
          title: `${wo.ll({ zhCN: '已成功拷贝到剪贴板', enUS: 'Successfully copied to clipboard ' })}\n${String(text).substring(0, toastLength)}`,
        })
      },
    })
  },
}