/**
 * 队列执行函数
 * @param {Function} asyncFunction 异步函数
 * @param {Array} items 数据数组
 * @param {Number} maxConcurrent 最大并行
 * @returns
 */
export function executeAsyncFunctionInQueue(
  asyncFunction,
  items,
  maxConcurrent = 10
) {
  items = items.slice()
  return new Promise((resolve) => {
    const total = items.length
    const results = []
    const executing = new Set()
    const executeNext = async () => {
      if (items.length === 0) {
        return
      }
      const currentIndex = total - items.length
      const item = items.shift()
      const promise = asyncFunction(item, currentIndex)
        .then((result) => {
          results.push(result)
        })
        .catch((error) => {
          results.push(error)
        })
        .finally(() => {
          executing.delete(promise)
          if (executing.size || items.length) {
            executeNext()
          } else {
            resolve(results)
          }
        })
      executing.add(promise)
    }
    while (executing.size < maxConcurrent && items.length > 0) {
      executeNext()
    }
  })
}

/**
 * 获取两点间的距离
 * @param { { lat: number, lng: number } } point1 - 第一个点的经纬度
 * @param { { lat: number, lng: number } } point2 - 第二个点的经纬度
 * @param { boolean } kilometreFlag - 单位标志：true返回公里(km)并保留1位小数，false返回米(m)并取整
 * @returns { number } 两点间的距离
 */
export function getDistance(point1, point2, kilometreFlag = false) {
  const { lng: lng1, lat: lat1 } = point1
  const { lng: lng2, lat: lat2 } = point2
  // 将角度转换为弧度
  const rad = (d) => (d * Math.PI) / 180
  // 将经纬度从角度转换为弧度
  const radLat1 = rad(lat1)
  const radLat2 = rad(lat2)
  // 计算纬度和经度的差值（弧度）
  const a = radLat1 - radLat2
  const b = rad(lng1) - rad(lng2)
  // 使用哈弗辛公式计算两点间的球面距离
  let s =
    2 *
    Math.asin(
      Math.sqrt(
        Math.pow(Math.sin(a / 2), 2) +
          Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)
      )
    )
  // 乘以地球半径（6378.137公里）得到距离（公里）
  s = s * 6378.137
  // 根据单位标识返回不同单位和精度的结果
  if (kilometreFlag) {
    // 返回公里单位，保留1位小数
    s = Number(s.toFixed(1))
  } else {
    // 返回米单位，四舍五入取整
    s = Number(Math.round(s * 1000).toFixed(0))
  }
  return s
}

/**
 * 获取坐标的是否在围栏内
 * @param { { lat: number, lng: number } } point 坐标
 * @param { { lat: number, lng: number }[] } APoints 围栏
 * @returns { boolean } 在围栏内返回true，否则false
 */
export function isPointInPolygon(point, APoints) {
  const { lat, lng } = point
  let iSum = 0
  let dLon1, dLon2, dLat1, dLat2, dLon
  if (APoints.length < 3) return false
  const iCount = APoints.length
  for (let i = 0; i < iCount; i++) {
    if (i == iCount - 1) {
      dLon1 = APoints[i].lng
      dLat1 = APoints[i].lat
      dLon2 = APoints[0].lng
      dLat2 = APoints[0].lat
    } else {
      dLon1 = APoints[i].lng
      dLat1 = APoints[i].lat
      dLon2 = APoints[i + 1].lng
      dLat2 = APoints[i + 1].lat
    }
    //以下语句判断A点是否在边的两端点的水平平行线之间，在则可能有交点，开始判断交点是否在左射线上
    if ((lat >= dLat1 && lat < dLat2) || (lat >= dLat2 && lat < dLat1)) {
      if (Math.abs(dLat1 - dLat2) > 0) {
        //得到 A点向左射线与边的交点的x坐标：
        dLon = dLon1 - ((dLon1 - dLon2) * (dLat1 - lat)) / (dLat1 - dLat2)
        if (dLon < lng) iSum++
      }
    }
  }
  if (iSum % 2 != 0) return true
  return false
}

/**
 * 队列执行函数
 * @param asyncFunction 异步函数
 * @param items  参数数组
 * @param maxConcurrent  最大并发数
 * @returns 结果数组
 */
async executeAsyncFunctionInQueue<T, K>(
  asyncFunction: (item: K, index: number) => Promise<T>,
  items: K[],
  maxConcurrent: number = 10
): Promise<Array<T | Error>> {
  const queue = [...items]
  const results: Array<T | Error> = new Array(items.length)
  const executing = new Set<Promise<void>>()

  const executeNext = async (): Promise<void> => {
    if (queue.length === 0) return

    const currentIndex = items.length - queue.length
    const item = queue.shift()!

    const promise = (async () => {
      try {
        const result = await asyncFunction(item, currentIndex)
        results[currentIndex] = result
      } catch (error) {
        results[currentIndex] =
          error instanceof Error ? error : new Error(String(error))
      }
    })()

    executing.add(promise)
    await promise
    executing.delete(promise)

    if (queue.length > 0) {
      await executeNext()
    }
  }

  const workers = Array.from(
    { length: Math.min(maxConcurrent, queue.length) },
    () => executeNext()
  )

  await Promise.all(workers)
  return results
}