import Taro from '@tarojs/taro'

export function randomString(length) {
  let str = Math.random().toString(36).substr(2)
  if (str.length >= length) {
    return str.substr(0, length)
  }
  str += randomString(length - str.length)
  return str
}

export function getRandomId(prefix = 'canvas', length = 10) {
  return prefix + randomString(length)
}

export function mapHttpToHttps(rawUrl) {
  if (rawUrl.indexOf(':') < 0 || rawUrl.startsWith('http://tmp')) {
    return rawUrl
  }
  const urlComponent = rawUrl.split(':')
  if (urlComponent.length === 2) {
    if (urlComponent[0] === 'http') {
      urlComponent[0] = 'https'
      return `${urlComponent[0]}:${urlComponent[1]}`
    }
  }
  return rawUrl
}

export const getFactor = () => {
  const sysInfo = Taro.getSystemInfoSync()
  const { screenWidth } = sysInfo
  return screenWidth / 750
}

export const toPx = (rpx, factor = getFactor()) =>
  parseInt(String(rpx * factor), 10)

export const toRpx = (px, factor = getFactor()) =>
  parseInt(String(px / factor), 10)

export function downImage(url) {
  return new Promise((resolve, reject) => {
    const wx_user_data_path =
      (typeof wx !== 'undefined' && wx && wx.env && wx.env.USER_DATA_PATH)
        ? wx.env.USER_DATA_PATH
        : ''
    const is_local_user_path = wx_user_data_path
      ? new RegExp(wx_user_data_path).test(url)
      : false

    if (/^http/.test(url) && !is_local_user_path) {
      Taro.downloadFile({
        url: mapHttpToHttps(url),
        success: (res) => {
          if (res.statusCode === 200) {
            resolve(res.tempFilePath)
          } else {
            reject(res)
          }
        },
        fail(err) {
          reject(err)
        }
      })
    } else {
      resolve(url)
    }
  })
}

export const getImageInfo = (item, index) =>
  new Promise((resolve, reject) => {
    const { x, y, width, height, url, zIndex } = item
    downImage(url).then((imgPath) =>
      Taro.getImageInfo({ src: imgPath })
        .then((imgInfo) => {
          let sx
          let sy
          const borderRadius = item.borderRadius || 0
          const imgWidth = toRpx(imgInfo.width)
          const imgHeight = toRpx(imgInfo.height)
          if (imgWidth / imgHeight <= width / height) {
            sx = 0
            sy = (imgHeight - (imgWidth / width) * height) / 2
          } else {
            sy = 0
            sx = (imgWidth - (imgHeight / height) * width) / 2
          }
          const result = {
            type: 'image',
            borderRadius,
            borderWidth: item.borderWidth,
            borderColor: item.borderColor,
            borderRadiusGroup: item.borderRadiusGroup,
            zIndex: typeof zIndex !== 'undefined' ? zIndex : index,
            imgPath: url,
            sx,
            sy,
            sw: imgWidth - sx * 2,
            sh: imgHeight - sy * 2,
            x,
            y,
            w: width,
            h: height
          }
          resolve(result)
        })
        .catch((err) => {
          reject(err)
        })
    )
  })

export function getLinearColor(ctx, color, startX, startY, w, h) {
  if (
    typeof startX !== 'number' ||
    typeof startY !== 'number' ||
    typeof w !== 'number' ||
    typeof h !== 'number'
  ) {
    return color
  }
  let grd = color
  if (color.includes('linear-gradient')) {
    const colorList = color.match(/\((\d+)deg,\s(.+)\s\d+%,\s(.+)\s\d+%/)
    const radian = colorList[1]
    const color1 = colorList[2]
    const color2 = colorList[3]

    const L = Math.sqrt(w * w + h * h)
    const x = Math.ceil(Math.sin(180 - radian) * L)
    const y = Math.ceil(Math.cos(180 - radian) * L)

    if (Number(radian) === 180 || Number(radian) === 0) {
      if (Number(radian) === 180) {
        grd = ctx.createLinearGradient(startX, startY, startX, startY + h)
      }
      if (Number(radian) === 0) {
        grd = ctx.createLinearGradient(startX, startY + h, startX, startY)
      }
    } else if (radian > 0 && radian < 180) {
      grd = ctx.createLinearGradient(startX, startY, x + startX, y + startY)
    } else {
      throw new Error('只支持0 <= 颜色弧度 <= 180')
    }
    grd.addColorStop(0, color1)
    grd.addColorStop(1, color2)
  }
  return grd
}

export function getTextX(textAlign, x, width) {
  let newX = x
  if (textAlign === 'center') {
    newX = width / 2 + x
  } else if (textAlign === 'right') {
    newX = width + x
  }
  return newX
}