const script = document.createElement('script')
script.setAttribute(
  'src',
  'https://cdn.bootcdn.net/ajax/libs/jszip/3.10.1/jszip.min.js'
)
// 文件地址
const urls = []
// 压缩包的名字
const name = Date.now()
script.onload = () => {
  const zip = new JSZip()
  Promise.all(
    urls.map((url) => fetch(url).then(res => res.arrayBuffer()))
  ).then((arrayBuffers) => {
    arrayBuffers.forEach((arrayBuffer, index) => {
      const filename = `${index + 1}.${urls[index].split('.').pop()}`
      zip.file(filename, arrayBuffer)
    })
    zip.generateAsync({ type: 'blob' }).then((content) => {
      const link = document.createElement('a')
      link.href = URL.createObjectURL(content)
      link.download = name + '.zip'
      link.click()
    })
  })
}
document.body.appendChild(script)

/**
 * 队列执行函数
 * @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
}

/**
 * 获取多个经纬度适合的缩放等级及中心点坐标
 * @param { { lat: number, lng: number }[] } points 多个经纬度
 * @returns { { center: { lat: number, lng: number }, zoom: number } } 适合的缩放等级
 */
export function getPointsCalculateZoom(points) {
  if(!points.length) throw new Error('请传入经纬度')

  const getZoom = (minPoint, maxPoint) => {
    const zoom = [
      50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 25000, 50000, 100000,
      200000, 500000, 1000000, 2000000
    ] //级别18到3。
    const distance = getDistance(minPoint, maxPoint)
    for (let i = 0, zoomLen = zoom.length; i < zoomLen; i++) {
      if (zoom[i] - distance > 0) {
        // 不同平台可能不太准，可在此处进行调整，或在调用完成后进行调整
        return 18 - i + 1
      }
    }
  }
  let maxLng = points[0].lng
  let minLng = points[0].lng
  let maxLat = points[0].lat
  let minLat = points[0].lat
  let res
  for (let i = points.length - 1; i >= 0; i--) {
    res = points[i]
    if (res.lng > maxLng) maxLng = res.lng
    if (res.lng < minLng) minLng = res.lng
    if (res.lat > maxLat) maxLat = res.lat
    if (res.lat < minLat) minLat = res.lat
  }
  const cenLng = (maxLng + minLng) / 2
  const cenLat = (maxLat + minLat) / 2
  const zoom = getZoom(
    { lng: minLng, lat: minLat },
    { lng: maxLng, lat: maxLat }
  )
  return {
    center: {
      lng: cenLng,
      lat: cenLat
    },
    zoom
  }
}

/**
 * 获取多个经纬度的中间坐标
 * @param {{lat: number, lng: number}[]} points 多个经纬度点
 * @returns {{lat: number, lng: number}} 中间坐标
 */
export function getPointsCalculateCenter(points) {
  const point_num = points.length; //坐标点个数
  let X = 0,
    Y = 0,
    Z = 0;
  for (let i = 0; i < points.length; i++) {
    if (!points[i]) {
      continue;
    }
    const point = points[i];
    const lat = (point.lat * Math.PI) / 180;
    const lng = (point.lng * Math.PI) / 180;
    const x = Math.cos(lat) * Math.cos(lng);
    const y = Math.cos(lat) * Math.sin(lng);
    const z = Math.sin(lat);
    X += x;
    Y += y;
    Z += z;
  }
  X = X / point_num;
  Y = Y / point_num;
  Z = Z / point_num;
  const tmp_lng = Math.atan2(Y, X);
  const tmp_lat = Math.atan2(Z, Math.sqrt(X * X + Y * Y));
  return { lat: (tmp_lat * 180) / Math.PI, lng: (tmp_lng * 180) / Math.PI };
}