/* 引入Cesium */
// import * as Cesium from 'Cesium';

/**
 * 剖面分析
 */
class Profile {
	/**
	 * 默认初始化
	 * @param {Object} viewer 三维场景
	 */
	constructor(viewer) {
		if (!viewer) throw new Cesium.DeveloperError('no viewer object!');
		this._viewer = viewer;
		this._profileEntities = [];
	}

	/**
	 * 线段插值点
	 * @ignore 忽略注释，注释不生成Doc
	 * @param {*} positions 线段节点集合
	 * @param {*} objectsToExclude 高度采集时排除的对象集合
	 * @returns 经纬度点集合，包含距离值
	 */
	_interPoints(positions, objectsToExclude) {
		let positionsCartographic = [];
		let terrainSamplePositions = [];
		for (let index = 0; index < positions.length; index++) {
			const element = positions[index];
			let ellipsoid = this._viewer.scene.globe.ellipsoid;
			let cartographic = ellipsoid.cartesianToCartographic(element);
			positionsCartographic.push(cartographic);
		}
		for (let i = 0; i < positionsCartographic.length; i++) {
			const m_Cartographic0 = positionsCartographic[i];
			const m_Cartographic1 = positionsCartographic[i + 1];
			if (m_Cartographic1) {
				let a = Math.abs(m_Cartographic0.longitude - m_Cartographic1.longitude) * 10000000;
				let b = Math.abs(m_Cartographic0.latitude - m_Cartographic1.latitude) * 10000000;
				//等距采样
				if (a > b) b = a;
				let length = parseInt(b / 2);
				if (length > 1000) length = 1000;
				if (length < 2) length = 2;
				for (let j = 0; j < length; j++) {
					terrainSamplePositions.push(
						new Cesium.Cartographic(
							Cesium.Math.lerp(
								m_Cartographic0.longitude,
								m_Cartographic1.longitude,
								j / (length - 1)
							),
							Cesium.Math.lerp(
								m_Cartographic0.latitude,
								m_Cartographic1.latitude,
								j / (length - 1)
							)
						)
					);
				}
				terrainSamplePositions.pop();
			} else {
				terrainSamplePositions.push(m_Cartographic0);
			}
		}
		let positions_Inter = [];
		let distance = 0;
		for (let n = 0; n < terrainSamplePositions.length; n++) {
			//地理坐标（弧度）转经纬度坐标
			let curCartographic = terrainSamplePositions[n];
			let height = this._viewer.scene.sampleHeight(curCartographic, objectsToExclude);
			const lon = (curCartographic.longitude / Math.PI) * 180;
			const lat = (curCartographic.latitude / Math.PI) * 180;
			let point = Cesium.Cartesian3.fromDegrees(lon, lat, height);
			let preCartographic = terrainSamplePositions[n - 1];
			if (preCartographic) {
				const lon1 = (preCartographic.longitude / Math.PI) * 180;
				const lat1 = (preCartographic.latitude / Math.PI) * 180;
				let point1 = Cesium.Cartesian3.fromDegrees(lon1, lat1, height);
				let curDis = Cesium.Cartesian3.distance(point1, point);
				distance += curDis;
			}
			positions_Inter.push({
				position: {
					lon: lon,
					lat: lat,
					height: height
				},
				distance: distance,
			});
		}
		return positions_Inter;
	}
}

/**
 * 通用对外公开函数 
 */
Object.assign(Profile.prototype, /** @lends Profile.prototype */{

	/**
	 * 开启剖面分析
	 * @param {Object} [points] 坐标:[lng,lat,lng,lat,......]  
	 * @param {Object} entity 线对象
	 */
	startProfileAnalysis(points, entity) {
		//异步函数
		return new Promise((resolve, reject) => {

			let _self = this;

			/* 转换坐标 */
			let positions = points.map(point => {
				return Cesium.Cartesian3.fromDegrees(point[0], point[1], point[2] || 0);
			});

			_self.removeProfileAnalysis();

			entity.clampToGround = true;
			console.log(positions);
			let pointsList = _self._interPoints(positions, [entity]);
			console.log(pointsList);

			resolve(pointsList);
		});
	},

	/**
	 * 移除剖面检测
	 */
	removeProfileAnalysis() {
		let _self = this;
		if (_self._profileEntities && _self._profileEntities.length > 0) {
			_self._profileEntities.forEach((element) => {
				_self._viewer.entities.remove(element);
			});
		}
		_self._profileEntities = [];
	},
});

export default Profile;