import * as Cesium from 'cesium';
import * as turf from '@turf/turf';

export const getLngLatDistance = (lat1, lng1, lat2, lng2) => {
  const radLat1 = (lat1 * Math.PI) / 180.0;
  const radLat2 = (lat2 * Math.PI) / 180.0;
  const a = radLat1 - radLat2;
  const b = (lng1 * Math.PI) / 180.0 - (lng2 * Math.PI) / 180.0;
  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),
      ),
    );
  s = s * 6378.137; // EARTH_RADIUS;
  s = Math.round(s * 10000) / 10000;
  return s * 1000;
};

// 获取限polyline长度
export const getPolylineLength = (entity) => {
  let length = 0;

  // 获取Polyline的所有顶点位置
  const positions = entity.polyline.positions.getValue();

  for (let i = 0; i < positions.length - 1; ++i) {
    const startPosition = positions[i];
    const endPosition = positions[i + 1];

    // 使用Cesium提供的distanceBetween函数计算两个顶点之间的距离
    const distance = Cesium.Cartesian3.distance(startPosition, endPosition);

    // 将每个顶点之间的距离相加得到总长度
    length += distance;
  }

  return length;
};

// 创建三角广告牌
export const createTriangleMarker = (title, color) => {
  // 创建canvas绘制广告牌
  const billboard = document.createElement('canvas');
  billboard.width = 30;
  billboard.height = 30;
  const ctx = billboard.getContext('2d');
  ctx.beginPath();
  ctx.moveTo(0, 0);
  ctx.lineTo(30, 0);
  ctx.lineTo(15, 22);
  ctx.fillStyle = color;
  ctx.fill();
  ctx.font = '18px serif';
  ctx.fillStyle = '#ffffff';
  ctx.fillText(title, 10, 15);
  ctx.closePath();
  return billboard;
};

export const createCircleBillboard = (title, color) => {
  const billboard = document.createElement('canvas');
  const ctx = billboard.getContext('2d');
  ctx.beginPath();
  ctx.ellipse(150, 90, 11, 11, 0, 0, Math.PI * 2);
  ctx.fillStyle = color;
  ctx.fill();
  ctx.font = 'bold 15px serif';
  ctx.textAlign = 'center';
  ctx.fillStyle = '#ffffff';
  ctx.fillText(title, 150, 95);
  ctx.closePath();
  return billboard;
};

// 获取当前经纬度海拔
export const getHaeHeight = (start, end) => {
  const ellipsoid = Cesium.Ellipsoid.WGS84; // 选择合适的椭圆体模型
  // const { longitude, latitude, height } = start
  // const { longitude: endLng, latitude: endLat, height: endHeight } = end
  // const startC3Position = new Cesium.Cartographic(longitude, latitude, height)
  // const endC3Position = new Cesium.Cartographic(endLng, endLat, endHeight)
  // const startCartesianPosition = ellipsoid.cartographicToCartesian(startC3Position)
  // const endCartesianPosition = ellipsoid.cartographicToCartesian(endC3Position)
  // // 计算两个位置之间的距离
  // const distance = new Cesium.EllipsoidGeodesic(startCartesianPosition, endCartesianPosition, ellipsoid)
  // return distance
  const { longitude, latitude, height } = end;
  const cartographic = Cesium.Cartographic.fromDegrees(
    longitude,
    latitude,
    height,
  );
  const cartesianPosition = ellipsoid.cartographicToCartesian(cartographic);
  const haeHeight = ellipsoid.cartesianToCartographic(cartesianPosition).height;
  return haeHeight;
};

// Cesium Cartesian3 转正常经纬度
export const cartesian3Convert = (cartesian3Position, viewer) => {
  // 转换为经纬度
  const ellipsoid = viewer.scene.globe.ellipsoid;
  const cartographicPosition = Cesium.Cartographic.fromCartesian(
    cartesian3Position,
    ellipsoid,
  );
  const longitude = Cesium.Math.toDegrees(cartographicPosition.longitude);
  const latitude = Cesium.Math.toDegrees(cartographicPosition.latitude);
  const height = cartographicPosition.height;

  //   console.log('经度: ' + longitude);
  //   console.log('纬度: ' + latitude);
  //   console.log('高度: ' + height);

  return {
    longitude,
    latitude,
    height,
  };
};

// Cesium Cartesian2 转正常经纬度
export const cartesian2Convert = (position, viewer) => {
  const ellipsoid = viewer.scene.globe.ellipsoid;
  const c3Position = viewer.scene.globe.pick(
    viewer.camera.getPickRay(position),
    viewer.scene,
  );
  const c2Postion = ellipsoid.cartesianToCartographic(c3Position);
  const longitude = Cesium.Math.toDegrees(c2Postion.longitude);
  const latitude = Cesium.Math.toDegrees(c2Postion.latitude);
  return { longitude, latitude };
};

// 根据经纬度获取距离
export const getLnglatDist = (lng1, lat1, lng2, lat2) => {
  const start = new Cesium.Cartesian3.fromDegrees(
    Number(lng1),
    Number(lat1),
    0,
  );
  const end = new Cesium.Cartesian3.fromDegrees(Number(lng2), Number(lat2), 0);
  const distance = Cesium.Cartesian3.distance(start, end);
  return distance;
};

/**
 * 地点坐标计算中心点
 * @param coordinateList {Array<Array<Object>>} [[{lat, lng}]]
 * @return { Object } {lat lng}
 */
export const getCenterPoint = (coordinateList) => {
  coordinateList = coordinateList.map((item) => {
    const [lng, lat] = item;
    return [{ lat, lng }];
  });
  const geoCoordinateListFlat = coordinateList.reduce((s, v) => {
    return (s = s.concat(v));
  }, []);
  const total = geoCoordinateListFlat.length;
  let X = 0;
  let Y = 0;
  let Z = 0;
  for (const g of geoCoordinateListFlat) {
    const lat = (g.lat * Math.PI) / 180;
    const lon = (g.lng * Math.PI) / 180;
    const x = Math.cos(lat) * Math.cos(lon);
    const y = Math.cos(lat) * Math.sin(lon);
    const z = Math.sin(lat);
    X += x;
    Y += y;
    Z += z;
  }

  X = X / total;
  Y = Y / total;
  Z = Z / total;
  const Lon = Math.atan2(Y, X);
  const Hyp = Math.sqrt(X * X + Y * Y);
  const Lat = Math.atan2(Z, Hyp);

  return { lng: (Lon * 180) / Math.PI, lat: (Lat * 180) / Math.PI };
};

/**
 * @description: 计算两组经纬度中距离最短的两个点
 * @param {*} lnglat1 [[xxx,xxx]]
 * @param {*} lnglat2 [[xxx,xxx]]
 * @return {*} { index: 1 }
 */
export const getShortestDistance = (lnglat1, lnglat2) => {
  const arr = [];
  lnglat1.forEach((v, i) => {
    const [lng, lat] = v;
    lnglat2.forEach((s, i2) => {
      const [vLng, vLat] = s;
      const distance = getLnglatDist(lng, lat, vLng, vLat);
      arr.push({
        distance,
        index: [i, i2],
        lnglat: [v, s],
      });
    });
  });
  const newArr = arr.sort((a, b) => a.distance - b.distance);
  return newArr[0];
};

// 获取当前经纬度地形数据
export const getLnglatAltitude = (longitude, latitude, viewer) => {
  return new Promise((resolve, reject) => {
    // 假设 viewer 已经初始化并且 terrainProvider 是有效的
    const terrainProvider = viewer?.terrainProvider;

    // 创建 Cartographic 对象
    const cartographic = Cesium.Cartographic.fromDegrees(longitude, latitude);

    // 获取地形数据的Promise
    const promise = Cesium.sampleTerrainMostDetailed(terrainProvider, [
      cartographic,
    ]);

    // 使用 Cesium.when 处理 Promise
    promise
      .then(function (updatedPositions) {
        // updatedPositions 是一个数组，包含更新后的 Cartographic 对象
        const updatedPosition = updatedPositions[0];
        const height = updatedPosition.height;

        resolve({
          longitude,
          latitude,
          height,
        });
        // 在这里，你可以使用 height 值进行后续操作
      })
      .catch(function (error) {
        // console.error('获取高程时发生错误:', error);
        reject(error);
      });
  });
};

// 批量获取经纬度对应高度信息
export const getPositionsHeight = (data, viewer) => {
  return new Promise((resolve, reject) => {
    if (!data || !data.length) {
      resolve([]);

      return;
    }

    // 假设 viewer 已经初始化并且 terrainProvider 是有效的
    const terrainProvider = viewer?.terrainProvider;

    // 创建 Cartographic 对象
    const cartographics = data.map((item) => {
      const [lng, lat] = item?.['Point']?.['coordinates']?.['#text'].split(',');

      return Cesium.Cartographic.fromDegrees(Number(lng), Number(lat));
    });

    // 获取地形数据的Promise
    const promise = Cesium.sampleTerrainMostDetailed(
      terrainProvider,
      cartographics,
    );

    // 使用 Cesium.when 处理 Promise
    promise
      .then(function (updatedPositions) {
        // updatedPositions 是一个数组，包含更新后的 Cartographic 对象
        const newPosition = updatedPositions.map((item, index) => {
          const longitude = Cesium.Math.toDegrees(item.longitude);
          const latitude = Cesium.Math.toDegrees(item.latitude);
          const FinalHeight =
            Number(data[index]?.['ellipsoidHeight']?.['#text']) +
            Number(item.height);

          return {
            ...data[index],
            longitude,
            latitude,
            FinalHeight,
            customHeight: Number(item.height),
          };
        });

        resolve(newPosition);
        // 在这里，你可以使用 height 值进行后续操作
      })
      .catch(function (error) {
        // console.error('获取高程时发生错误:', error);
        reject(error);
      });
  });
};

// 获取面中最高点
export const getPolygonMaxHeight = (turfPolygon, viewer) => {
  return new Promise((resolve, reject) => {
    const turfExtent = turf.bbox(turfPolygon);

    const turfSamplePoints = turf.pointGrid(turfExtent, 0.01, {
      units: 'kilometers',
      mask: turfPolygon,
    });

    // 假设 viewer 已经初始化并且 terrainProvider 是有效的
    const terrainProvider = viewer?.terrainProvider;

    const cesiumSamplePoints = [];
    for (let i = 0; i < turfSamplePoints.features.length; i++) {
      const coord = turfSamplePoints.features[i].geometry.coordinates;
      cesiumSamplePoints.push(
        Cesium.Cartographic.fromDegrees(coord[0], coord[1]),
      );
    }

    // 获取地形数据的Promise
    const promise = Cesium.sampleTerrainMostDetailed(
      terrainProvider,
      cesiumSamplePoints,
    );

    promise
      .then(function (updatedPositions) {
        const newPosition = updatedPositions.map((item) => Number(item.height));

        resolve(Math.max(...newPosition));
      })
      .catch(function (error) {
        reject(error);
      });
  });
};

// 展示当前的高度
export const getWaylineShowHeight = (positions) => {
  const { lng, lat } = getCenterPoint(positions);
  let maxDist = 0;
  positions.forEach((item) => {
    const [lng1, lat1] = item;
    let pointsDist = getLnglatDist(lng1, lat1, lng, lat);
    if (pointsDist > maxDist) {
      maxDist = pointsDist;
    }
  });
  return {
    lng,
    lat,
    showHeight: maxDist * 8,
  };
};

// 获取当前面是否有交叉点
export const isIntersection = (coordinates) => {
  const polyDikuai = turf.polygon([coordinates]);
  const result = turf.kinks(polyDikuai);
  const resultFeatures = result.features;
  if (resultFeatures.length == 0) {
    //无相交
    return false;
  } else {
    //有相交
    return true;
  }
};