import * as Cesium from 'cesium'

import takeoffImg from '@/assets/images/routePlan/pointAirLine/takeoff.svg'
import _, { cloneDeep, throttle } from 'lodash'
import { cartesian3Convert } from '@/utils/cesium/mapUtil'
import * as turf from '@turf/turf'
import { ElMessage } from 'element-plus'

import { analyzeKmzFile, removeTextKey, XMLToJSON } from '@/utils/cesium/kmz'
import { camelToSnake } from '@/utils/util'

import { boxTransformScale } from '@/utils/turfFunc'


function _getMouseInfo (position, viewer) {
	let scene = viewer.scene
	let target = scene.pick(position)
	let cartesian = undefined
	let surfaceCartesian = undefined
	let wgs84Position = undefined
	let wgs84SurfacePosition = undefined
	if (scene.pickPositionSupported) {
		cartesian = scene.pickPosition(position)
	}
	if (cartesian) {
		let c = Cesium.Ellipsoid.WGS84.cartesianToCartographic(cartesian)
		if (c) {
			wgs84Position = {
				lng: Cesium.Math.toDegrees(c.longitude),
				lat: Cesium.Math.toDegrees(c.latitude),
				alt: c.height,
			}
		}
	}
	if (scene.mode === Cesium.SceneMode.SCENE3D && !(viewer.terrainProvider instanceof Cesium.EllipsoidTerrainProvider)) {
		let ray = scene.camera.getPickRay(position)
		surfaceCartesian = scene.globe.pick(ray, scene)
	} else {
		surfaceCartesian = scene.camera.pickEllipsoid(position, Cesium.Ellipsoid.WGS84)
	}
	if (surfaceCartesian) {
		let c = Cesium.Ellipsoid.WGS84.cartesianToCartographic(surfaceCartesian)
		if (c) {
			wgs84SurfacePosition = {
				lng: Cesium.Math.toDegrees(c.longitude),
				lat: Cesium.Math.toDegrees(c.latitude),
				alt: c.height,
			}
		}
	}

	return {
		target: target,
		windowPosition: position,
		position: cartesian,
		wgs84Position: wgs84Position,
		surfacePosition: surfaceCartesian,
		wgs84SurfacePosition: wgs84SurfacePosition,
	}
}

let startPointEntity = null
// 生成起飞点
function generateStartPoint (movement, viewer) {
	// 1. 获取笛卡尔坐标
	const cartesian = viewer.scene.pickPosition(movement.endPosition)
	if (!cartesian) return
	// 2. 笛卡尔转为弧度
	const cartographic = Cesium.Cartographic.fromCartesian(cartesian)
	// 3. 精确获取地形高度（异步）
	Cesium.sampleTerrainMostDetailed(viewer.terrainProvider, [cartographic])
		.then(updatedPositions => {
			const terrainHeight = updatedPositions[0].height
			const position = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, terrainHeight)
			// 4. 更新或创建点实体
			if (startPointEntity) {
				startPointEntity.position = position
			} else {
				startPointEntity = viewer.entities.add({
					position,
					id: 'wayline-point-start-init',
					billboard: {
						image: takeoffImg,
						outlineWidth: 0,
						width: 36,
						height: 36,
						scale: 1.0,
					},
				})
			}
		})
		.catch(error => console.error("地形加载失败:", error))
}
export const createStartThrottle = throttle(generateStartPoint, 20)

// 获取起飞点位置
export function getStartPointLast (viewer) {
	const point = cartesian3Convert(startPointEntity.position.getValue(), viewer) //经纬度
	startPointEntity && viewer.entities.remove(startPointEntity)
	return point
}

export function removeStartPoint (viewer) {
	if (startPointEntity) {
		viewer.entities.remove(startPointEntity)
		startPointEntity = null
	}
}

// 检查位置是否在合理范围内
export function isValidPosition (cartographic) {
	// 检查经纬度是否在合理范围内
	return (
		cartographic.longitude >= -Math.PI &&
		cartographic.longitude <= Math.PI &&
		cartographic.latitude >= -Math.PI / 2 &&
		cartographic.latitude <= Math.PI / 2
	)
}

export class PolygonDrawer {
	/**
	 * @param {Function} updatePosition - Position update callback function
	 * @param {Object} idShowWaringTip - Warning tip visibility flag
	 */
	constructor(updatePosition, idShowWaringTip) {
		// Initialize properties
		this.viewer = null
		this.curPolygon = null
		this.drawingMode = false
		this.settingMode = false
		this.isDragging = false
		this.draggedEntity = null
		this.polygonEntity = null
		this.editPolygonPointDataSource = null
		this.handler = null
		this.updatePosition = updatePosition
		this.menuPopup = null
		this.delPolygonPoint = null
		this.idShowWaringTip = idShowWaringTip
		this.currentDragPointIsValid = false
		this.currentDragPointPosition = null

		// Bind methods to maintain context
		this.handleLeftDown = this.handleLeftDown.bind(this)
		this.handleLeftUp = this.handleLeftUp.bind(this)
		this.handleMouseMove = this.handleMouseMove.bind(this)
		this.handleLeftClick = this.handleLeftClick.bind(this)
		this.handleRightClick = this.handleRightClick.bind(this)
		this.delPolygon = this.delPolygon.bind(this)
		this.delPoint = this.delPoint.bind(this)
	}

	// Constants for entity names and IDs
	static ENTITY_NAMES = {
		POLYGON: '面状航线-面',
		POINT: '面状航线-端点',
		POLYGON_ID: 'planar-route-polygon',
		POINT_ID_PREFIX: 'planar-route-point-'
	};

	// Constants for colors
	static COLORS = {
		DEFAULT_POLYGON: Cesium.Color.fromBytes(45, 140, 240, 99),
		DEFAULT_LINE: Cesium.Color.fromBytes(45, 140, 240, 255),
		ERROR_POLYGON: Cesium.Color.fromCssColorString('rgba(255, 0, 0, .3)'),
		ERROR_LINE: Cesium.Color.fromCssColorString('rgba(255, 0, 0, 1)')
	};

	/**
	 * Initialize polygon with existing positions
	 * @param {Cesium.Viewer} viewer - Cesium viewer instance
	 * @param {Array} positions - Array of position objects {lng, lat, height}
	 */
	initPolygon (viewer, positions) {
		this.initHandler(viewer)
		this.startDrawing()

		positions.forEach(item => {
			this.addPosition(
				Cesium.Cartesian3.fromDegrees(Number(item.lng), Number(item.lat), Number(item.height)),
				false
			)
		})

		const newBox = boxTransformScale(positions.map(item => [item.lng, item.lat]), 5)
		viewer.camera.flyTo({
			destination: Cesium.Rectangle.fromDegrees(...newBox),
			offset: new Cesium.HeadingPitchRange(0, Cesium.Math.toRadians(-90), 0),
			duration: 0.5,
		})

		this.drawingMode = false
		this.settingMode = true
	}

	/**
	 * Start drawing a new polygon
	 */
	startDrawing () {
		this.drawingMode = true
		this.curPolygon = new Cesium.PolygonHierarchy()

		if (!this.editPolygonPointDataSource) {
			this.editPolygonPointDataSource = new Cesium.CustomDataSource('editPolygonPointDataSource')
			this.viewer?.dataSources.add(this.editPolygonPointDataSource)
		}

		this.editPolygonPointDataSource?.entities.removeAll()
	}

	/**
	 * Add a position to the current polygon
	 * @param {Cesium.Cartesian3} position - Position to add
	 * @param {Boolean} isAdd - Whether this is an additional point (vs initial point)
	 */
	addPosition (position, isAdd = true) {
		if (this.curPolygon.positions.length === 0 && isAdd) {
			this.curPolygon.positions.push(position.clone())
		}

		this.curPolygon.positions.push(position.clone())

		if (!this.polygonEntity) {
			this.createPolygonEntity()
		}

		this.createPointEntity(position, isAdd)
	}

	/**
	 * Create the main polygon entity
	 */
	createPolygonEntity () {
		this.polygonEntity = this.viewer.entities.add({
			name: PolygonDrawer.ENTITY_NAMES.POLYGON,
			id: PolygonDrawer.ENTITY_NAMES.POLYGON_ID,
			polygon: {
				hierarchy: new Cesium.CallbackProperty(() => this.curPolygon, false),
				material: PolygonDrawer.COLORS.DEFAULT_POLYGON,
				outline: false,
				outlineWidth: 2,
				heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
			},
			polyline: {
				width: 2,
				material: PolygonDrawer.COLORS.DEFAULT_LINE,
				clampToGround: true,
				positions: new Cesium.CallbackProperty(
					() => [...this.curPolygon.positions, this.curPolygon.positions[0]],
					false
				)
			},
		})
	}

	/**
	 * Create a point entity for the polygon
	 * @param {Cesium.Cartesian3} position - Position of the point
	 * @param {Boolean} isAdd - Whether this is an additional point
	 */
	createPointEntity (position, isAdd) {
		const pointIndex = isAdd ? this.curPolygon.positions.length - 2 : this.curPolygon.positions.length - 1

		this.editPolygonPointDataSource.entities.add({
			name: PolygonDrawer.ENTITY_NAMES.POINT,
			id: `${PolygonDrawer.ENTITY_NAMES.POINT_ID_PREFIX}${pointIndex}`,
			position: position.clone(),
			point: {
				pixelSize: 14,
				color: Cesium.Color.WHITE,
				heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
				disableDepthTestDistance: Number.POSITIVE_INFINITY,
			},
			customData: {
				ind: pointIndex,
			},
		})
	}

	/**
	 * Finish drawing the polygon
	 */
	finishDrawing () {
		this.curPolygon.positions.pop()

		if (this.curPolygon.positions.length >= 3) {
			this.drawingMode = false
			this.settingMode = true
			this.editPolygonPointDataSource.entities.show = true

			if (!this.curDragPointIsValid(this.curPolygon.positions)) {
				this.idShowWaringTip.value = true
				this.currentDragPointIsValid = true
				this.updatePolygonAppearance(PolygonDrawer.COLORS.ERROR_POLYGON, PolygonDrawer.COLORS.ERROR_LINE)
			} else {
				this.idShowWaringTip.value = false
				this.currentDragPointIsValid = false
				this.updatePolygonAppearance(PolygonDrawer.COLORS.DEFAULT_POLYGON, PolygonDrawer.COLORS.DEFAULT_LINE)
			}

			this.updatePosition(this.curPolygon.positions)
		}
	}

	/**
	 * Delete the current polygon
	 */
	delPolygon () {
		this.removeEntities()
		this.removeMenuPopup()
		this.updatePosition([])
		this.startDrawing()
	}

	/**
	 * Delete a point from the polygon
	 */
	delPoint () {
		if (this.curPolygon.positions.length <= 3) {
			this.removeMenuPopup()
			return ElMessage.warning('端点不可少于3个')
		}
		if (!this.delPolygonPoint) return

		this.curPolygon.positions.splice(this.delPolygonPoint.customData.ind, 1)
		this.editPolygonPointDataSource.entities.remove(this.delPolygonPoint)
		this.removeMenuPopup()

		// Update indices of remaining points
		this.editPolygonPointDataSource.entities.values.forEach((item, index) => {
			item.customData.ind = index
		})

		this.updatePosition(this.curPolygon.positions)
	}

	/**
	 * Create a context menu popup
	 * @param {String} type - Type of menu ('polygon' or 'edit-point')
	 * @returns {HTMLElement} The created menu element
	 */
	createMenuPopup (type = 'polygon') {
		const menuPopupVBox = document.createElement('div')
		menuPopupVBox.id = 'planarPolygonEdit'
		menuPopupVBox.className = 'planar-polygon-edit-tooltip'

		const menuPopup = document.createElement('div')
		menuPopup.id = 'planarPolygonEditMenu'
		menuPopup.className = 'planar-polygon-edit-menu'

		const menuItems = type === 'polygon'
			? [{ title: '删除测区', class: 'del-planar-polygon' }]
			: [{ title: '删除端点', class: 'del-planar-point' }]

		menuItems.forEach(item => {
			const titleDiv = document.createElement('div')
			titleDiv.innerText = item.title
			titleDiv.className = item.class
			menuPopup.appendChild(titleDiv)
		})

		menuPopupVBox.appendChild(menuPopup)
		return menuPopupVBox
	}

	/**
	 * Remove the context menu popup
	 */
	removeMenuPopup () {
		if (this.menuPopup) {
			this.menuPopup.removeEventListener('click', this.delPolygon)
			this.menuPopup.removeEventListener('click', this.delPoint)
			this.viewer.container.removeChild(this.menuPopup)
			this.menuPopup = null
		}
		this.delPolygonPoint = null
	}

	/**
	 * Handle left mouse button down event
	 * @param {Object} movement - Mouse movement event object
	 */
	handleLeftDown (movement) {
		if (!this.settingMode) return

		const pickedEntity = this.viewer.scene.pick(movement.position)?.id
		const isPoint = pickedEntity?.name === PolygonDrawer.ENTITY_NAMES.POINT

		if (pickedEntity && isPoint) {
			this.isDragging = true
			this.draggedEntity = pickedEntity
			this.currentDragPointPosition = this.curPolygon.positions[this.draggedEntity?.customData.ind]
			this.disableMapControl()
		}
	}

	/**
	 * Handle left mouse button up event
	 */
	handleLeftUp () {
		if (!(this.settingMode && this.curPolygon?.positions && this.draggedEntity)) return

		if (this.currentDragPointIsValid && this.isDragging) {
			this.draggedEntity.position = this.currentDragPointPosition
			this.curPolygon.positions[this.draggedEntity?.customData.ind] = this.currentDragPointPosition

			if (!this.curDragPointIsValid(this.curPolygon.positions)) {
				this.idShowWaringTip.value = true
				this.currentDragPointIsValid = true
				this.updatePolygonAppearance(PolygonDrawer.COLORS.ERROR_POLYGON, PolygonDrawer.COLORS.ERROR_LINE)
			} else {
				this.idShowWaringTip.value = false
				this.currentDragPointIsValid = false
				this.updatePolygonAppearance(PolygonDrawer.COLORS.DEFAULT_POLYGON, PolygonDrawer.COLORS.DEFAULT_LINE)
			}
		}

		if (this.isDragging) {
			this.updatePosition(this.curPolygon.positions)
			this.isDragging = false
			this.draggedEntity = null
			this.enableMapControl()
		}
	}

	/**
	 * Update polygon appearance
	 * @param {Cesium.Color} polygonColor - Color for the polygon
	 * @param {Cesium.Color} lineColor - Color for the outline
	 */
	updatePolygonAppearance (polygonColor, lineColor) {
		this.polygonEntity.polygon.material = polygonColor
		this.polygonEntity.polyline.material = lineColor
	}

	/**
	 * Handle left mouse click event
	 * @param {Object} click - Click event object
	 */
	handleLeftClick (click) {
		this.removeMenuPopup()

		const pickedAllEntity = this.viewer.scene.drillPick(click.position).filter(i => i.id)
		const isStartPoint = pickedAllEntity.find(i => i.id.name === '起飞点')
		const isPolygonPoint = pickedAllEntity.find(i => i.id.name === PolygonDrawer.ENTITY_NAMES.POINT)
		const isPolygon = pickedAllEntity.find(i => i.id.name === PolygonDrawer.ENTITY_NAMES.POLYGON)

		if (isStartPoint) return

		if (!this.drawingMode) {
			if (!isPolygon) {
				this.settingMode = false
				this.editPolygonPointDataSource.entities.show = false
				return
			}

			if (isPolygon) {
				this.settingMode = true
				this.editPolygonPointDataSource.entities.show = true
			}
			return
		}


		if (this.curPolygon.positions.length < 4 && isPolygonPoint) {
			return
		}

		if (this.curPolygon.positions.length >= 4 && isPolygonPoint) {
			if (!this.drawingMode) return

			this.finishDrawing()

			return
		}

		const cartesian = this.viewer.scene.pickPosition(click.position)
		if (!cartesian) return

		this.addPosition(cartesian)
	}

	/**
	 * Handle right mouse click event
	 * @param {Object} click - Click event object
	 */
	handleRightClick (click) {
		if (this.drawingMode) return

		this.removeMenuPopup()

		const pickedAllEntity = this.viewer.scene.drillPick(click.position).filter(i => i.id)
		const isPolygon = pickedAllEntity.find(i => i.id.name === PolygonDrawer.ENTITY_NAMES.POLYGON)
		const isEditPoint = pickedAllEntity.find(i => i.id.name === PolygonDrawer.ENTITY_NAMES.POINT)
		const { position: { x, y } } = click

		let pickedEntity, tooltipEvent, menuType

		if (isPolygon) {
			pickedEntity = isPolygon
			tooltipEvent = this.delPolygon
			menuType = 'polygon'
		} else if (isEditPoint) {
			pickedEntity = isEditPoint
			tooltipEvent = this.delPoint
			menuType = 'edit-point'
		}

		if (pickedEntity) {
			this.delPolygonPoint = pickedEntity.id
			this.menuPopup = this.createMenuPopup(menuType)
			this.menuPopup.style.transform = `translate3d(${x - 10}px, ${y - 10}px, 0)`
			this.viewer.container.appendChild(this.menuPopup)
			this.menuPopup.addEventListener('click', tooltipEvent)
		}
	}

	/**
	 * Handle mouse move event
	 * @param {Object} movement - Mouse movement event object
	 */
	handleMouseMove (movement) {
		if (!this.drawingMode && !this.settingMode) return

		const cartesian = this.viewer.scene.pickPosition(movement.endPosition)
		if (!cartesian) return

		if (this.settingMode && this.draggedEntity?.customData) {
			this.draggedEntity.position = cartesian
			this.curPolygon.positions[this.draggedEntity?.customData.ind] = cartesian
		}

		if (this.drawingMode && this.polygonEntity && this.curPolygon.positions.length >= 1) {
			this.curPolygon.positions.pop()
			this.curPolygon.positions.push(cartesian)
		}

		if ((this.settingMode && this.draggedEntity?.customData) || (this.drawingMode && this.polygonEntity && this.curPolygon.positions.length >= 3)) {
			if (!this.curDragPointIsValid(this.curPolygon.positions)) {
				this.idShowWaringTip.value = true
				this.currentDragPointIsValid = true
				this.updatePolygonAppearance(PolygonDrawer.COLORS.ERROR_POLYGON, PolygonDrawer.COLORS.ERROR_LINE)
			} else {
				this.idShowWaringTip.value = false
				this.currentDragPointIsValid = false
				this.updatePolygonAppearance(PolygonDrawer.COLORS.DEFAULT_POLYGON, PolygonDrawer.COLORS.DEFAULT_LINE)
			}
		}
	}

	/**
	 * Check if the current dragged point position is valid
	 * @param {Array} positions - Array of polygon positions
	 * @returns {Boolean} True if the polygon is valid (no self-intersections)
	 */
	curDragPointIsValid (positions) {
		if (positions.length < 3) return true

		const cartographics = Cesium.Ellipsoid.WGS84.cartesianArrayToCartographicArray(positions)
		const latLngPoints = cartographics.map(cartographic => [
			Cesium.Math.toDegrees(cartographic.longitude),
			Cesium.Math.toDegrees(cartographic.latitude)
		])


		const poly = turf.polygon([[...latLngPoints, latLngPoints[0]]])
		const intersections = turf.kinks(poly)

		return intersections.features.length === 0
	}

	/**
	 * Disable map controls during interaction
	 */
	disableMapControl () {
		const controller = this.viewer.scene.screenSpaceCameraController
		controller.enableRotate = false
		controller.enableTranslate = false
		controller.enableZoom = false
	}

	/**
	 * Enable map controls after interaction
	 */
	enableMapControl () {
		const controller = this.viewer.scene.screenSpaceCameraController
		controller.enableRotate = true
		controller.enableTranslate = true
		controller.enableZoom = true
	}

	/**
	 * Remove all entities
	 */
	removeEntities () {
		// Remove main polygon entities
		const entitiesIDs = this.viewer.entities.values.map(i => i.id)
		entitiesIDs.forEach(item => {
			if (item.includes('planar-route-')) {
				this.viewer.entities.removeById(item)
			}
		})

		this.settingMode = false

		this.polygonEntity = null
		this.curPolygon = null

		// Remove edit points
		if (this.editPolygonPointDataSource) {
			this.editPolygonPointDataSource.entities.removeAll()
			this.editPolygonPointDataSource = null
		}
	}

	/**
	 * Initialize event handlers
	 * @param {Cesium.Viewer} viewer - Cesium viewer instance
	 */
	initHandler (viewer) {
		this.viewer = viewer
		this.startDrawing()

		if (!this.handler) {
			this.handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas)

			// Set up event handlers
			const events = [
				[Cesium.ScreenSpaceEventType.LEFT_DOWN, this.handleLeftDown],
				[Cesium.ScreenSpaceEventType.LEFT_UP, this.handleLeftUp],
				[Cesium.ScreenSpaceEventType.MOUSE_MOVE, this.handleMouseMove],
				[Cesium.ScreenSpaceEventType.LEFT_CLICK, this.handleLeftClick],
				[Cesium.ScreenSpaceEventType.RIGHT_CLICK, this.handleRightClick]
			]

			events.forEach(([type, handler]) => {
				this.handler.setInputAction(handler, type)
			})
		}
	}

	/**
	 * Remove event handlers
	 */
	removeHandler () {
		if (this.handler) {
			const eventTypes = [
				Cesium.ScreenSpaceEventType.LEFT_DOWN,
				Cesium.ScreenSpaceEventType.LEFT_UP,
				Cesium.ScreenSpaceEventType.MOUSE_MOVE,
				Cesium.ScreenSpaceEventType.LEFT_CLICK,
				Cesium.ScreenSpaceEventType.RIGHT_CLICK
			]

			eventTypes.forEach(type => {
				this.handler.removeInputAction(type)
			})

			this.handler = null
		}
	}

	/**
	 * Clean up and destroy the instance
	 */
	destroy () {
		if (!this.viewer) return

		this.removeMenuPopup()
		this.removeEntities()
		this.removeHandler()
		this.enableMapControl()
	}
}

export function disposeData (curPolygonPosition, polylinePoints, rthAltitudePoint) {
	let data = [...curPolygonPosition]
	data.push(curPolygonPosition[0])

	let disposePolylinePoints = [...polylinePoints]

	if (polylinePoints.length === 1) {
		ElMessage.warning('当前高度过高，无法生成有效航线，请调整！')

		disposePolylinePoints = [...polylinePoints, ...polylinePoints]
	}

	const polygon = turf.polygon([data.map(item => [item.lng, item.lat])])

	const polygonArea = turf.area(polygon)


	var line = turf.lineString(disposePolylinePoints.map(item => [item.longitude, item.latitude]))
	var length = turf.length(line, { units: 'kilometers' })

	const newPolylinePoints = disposePolylinePoints.map((item, index) => {
		return Cesium.Cartesian3.fromDegrees(Number(item.longitude), Number(item.latitude), Number(item.height))
	})

	let polylineLength = 0

	newPolylinePoints.forEach((item, index) => {
		if (index == newPolylinePoints.length - 1) return

		let point1 = item
		let point2 = newPolylinePoints[index + 1]

		polylineLength += Cesium.Cartesian3.distance(point1, point2)
	})

	const newRthAltitudePoint = rthAltitudePoint.map((item, index) => {
		return Cesium.Cartesian3.fromDegrees(Number(item.longitude), Number(item.latitude), Number(item.height))
	})

	let rthLineLength = 0

	newRthAltitudePoint.forEach((item, index) => {
		if (index == newRthAltitudePoint.length - 1) return

		let point1 = item
		let point2 = newRthAltitudePoint[index + 1]

		rthLineLength += Cesium.Cartesian3.distance(point1, point2)
	})

	return {
		polygonArea,
		polylineLength,
		rthLineLength,
		photoNum: polylinePoints.length * 3
	}
}

export const getGsd = (globalSettings, gsdInfo) => {
	if (_.isEmpty(gsdInfo) || !gsdInfo.image_height) {
		ElMessage.warning('相机参数获取异常，请联系管理员！')
		return
	}

	let w = gsdW(
		globalSettings.relTerrainHeight,
		gsdInfo.sensor_width,
		gsdInfo.focal_length,
		gsdInfo.image_width
	)
	let h = gsdH(
		globalSettings.relTerrainHeight,
		gsdInfo.sensor_height,
		gsdInfo.focal_length,
		gsdInfo.image_height
	)

	return w > h ? w : h
}

export const getGsdByH = (globalSettings, gsdInfo) => {
	if (!gsdInfo && !gsdInfo.image_height) {
		ElMessage.warning('相机参数获取异常，请联系管理员！')
		return
	}

	let w = gsdW(
		globalSettings.relTerrainHeight,
		gsdInfo.sensor_width,
		gsdInfo.focal_length,
		gsdInfo.image_width
	)

	let h = gsdH(
		globalSettings.relTerrainHeight,
		gsdInfo.sensor_height,
		gsdInfo.focal_length,
		gsdInfo.image_height
	)

	if (w > h) {
		return getHbyHW(
			globalSettings.gsd,
			gsdInfo.sensor_width,
			gsdInfo.focal_length,
			gsdInfo.image_width
		)
	} else {
		return getHbyH(
			globalSettings.gsd,
			gsdInfo.sensor_height,
			gsdInfo.focal_length,
			gsdInfo.image_height
		)
	}
}

// 解析kmz文件的时候处理pointList 写在这里
export function handlePointListForKmz (placemark, templateType) {
	if (!placemark?.length) return []

	let list = []

	if (templateType === "mapping2d") {
		list = placemark.map(item => {
			const [longitude, latitude] = item.point.coordinates.trim().split(',')

			return {
				longitude: longitude,
				latitude: latitude,
				height: 0,

				speed: item.waypoint_speed
			}
		})
	} else {
		list = placemark.map(i => i.map(item => {
			const [longitude, latitude] = item.point.coordinates.trim().split(',')

			return {
				longitude: longitude,
				latitude: latitude,
				height: 0,

				speed: item.waypoint_speed
			}
		}))
	}

	return list
}

export async function analysisPlanarRouteKmz (kmzUrl) {
	const res = await analyzeKmzFile(`${kmzUrl}?_t=${new Date().getTime()}`)
	const templateXML = await res.fileInfoObj['wpmz/template.kml']
	const waylinesXML = await res.fileInfoObj['wpmz/waylines.wpml']
	const templateXMLJSON = XMLToJSON(templateXML)?.['Document']
	const waylinesXMLJSON = XMLToJSON(waylinesXML)?.['Document']
	const templateXMLObj = camelToSnake(removeTextKey(templateXMLJSON))
	const waylinesXMLObj = camelToSnake(removeTextKey(waylinesXMLJSON))

	const {
		folder: {
			auto_flight_speed,
			payload_param: {
				image_format
			} = {},
			placemark: {
				direction: waylineAngle,
				inclined_gimbal_pitch: inclined_gimbal_pitch = -45,
				overlap: {
					inclined_camera_overlap_h: inclined_camera_overlap_h,
					inclined_camera_overlap_w: inclined_camera_overlap_w,
					ortho_camera_overlap_w: side_ratio,
					ortho_camera_overlap_h: course_ratio,
				},
				polygon,
				margin: buffer_distance_meters = 0
			},
			template_type: templateType,

			wayline_coordinate_sys_param: {
				global_shoot_height
			}
		} = {},
		mission_config: {
			take_off_ref_point,  // 参考起飞点
			drone_info: { drone_enum_value, drone_sub_enum_value } = {},
			payload_info: { payload_position_index, payload_enum_value, payload_sub_enum_value }
		} = {},
	} = templateXMLObj

	const {
		mission_config:
		{
			// 安全起飞高
			take_off_security_height: rth_altitude
		} = {},
		folder: polygonPointFolder
	} = waylinesXMLObj

	let execute_height_mode = ''
	let pointPlacemark

	if (templateType === "mapping2d") {
		execute_height_mode = polygonPointFolder.execute_height_mode
		pointPlacemark = polygonPointFolder.placemark
	} else {
		execute_height_mode = polygonPointFolder[0].execute_height_mode
		pointPlacemark = polygonPointFolder.map(i => i.placemark)
	}

	const [latitude, longitude, height] = take_off_ref_point.split(',').map(item => _.round(item, 6))
	let startPoint = { latitude, longitude, height: Number.isNaN(height) ? 0 : height }

	// 取出点位
	const coordinates = polygon?.outer_boundary_is.linear_ring
		.coordinates?.split('\n') || []

	// 数组转换
	let polygonList = coordinates.map((coordinate) =>
		coordinate
			.replace(/\s+/g, '')
			.split(',')
			.map((v) => Number(v)),
	)

	polygonList.pop()

	let pointList = handlePointListForKmz(pointPlacemark, templateType)

	return {
		take_off_ref_point,

		startPoint,
		image_format,
		templateType,
		global_shoot_height,
		rth_altitude,
		auto_flight_speed,

		waylineAngle,

		side_ratio,
		course_ratio,

		inclined_camera_overlap_h,
		inclined_camera_overlap_w,

		inclined_gimbal_pitch,

		drone_enum_value,
		drone_sub_enum_value,

		payload_position_index,
		payload_enum_value,
		payload_sub_enum_value,

		execute_height_mode,

		pointList,
		polygonList,

		buffer_distance_meters
	}
}

// 计算gsd-H
function gsdH (height, ch, jj, ih) {
	let one = Number((height * ch).toFixed(2))
	let two = Number((jj * ih).toFixed(2))
	let three = Number((one / two).toFixed(5))
	let four = Number((three * 100).toFixed(2))
	return four
}

function gsdW (height, cw, jj, iw) {
	let one = Number((height * cw).toFixed(2))
	let two = Number((jj * iw).toFixed(2))
	let three = Number((one / two).toFixed(5))
	let four = Number((three * 100).toFixed(2))
	return four
}

// 计算gsd-H
function getHbyH (gsd, ch, jj, ih) {
	let one = Number((jj * ih).toFixed(2))
	let two = Number((gsd / 100).toFixed(4))
	let three = Number((two * one).toFixed(4))
	let four = Number((three / ch).toFixed(2))
	return four
}

function getHbyHW (gsd, cw, jj, iw) {
	let one = Number((jj * iw).toFixed(2))
	let two = Number((gsd / 100).toFixed(4))
	let three = Number((two * one).toFixed(4))
	let four = Number((three / cw).toFixed(2))
	return four
}

export function getNewPolygonData (data) {
	const polygonData = data.reduce((pre, cur) => {
		let arr = cur.data.map(i => {
			if ('point' in i) return i.point.coordinates.split(',')
			if ('Point' in i) {
				if (_.isObject(i.Point.coordinates) && '#text' in i.Point.coordinates) return i.Point.coordinates['#text'].split(',')
				return i.Point.coordinates.split(',')
			}
		}).map(i => turf.point([Number(i[0]), Number(i[1])]))

		return pre.push(...arr), pre
	}, [])

	const hull = turf.convex(turf.featureCollection(polygonData))

	return hull.geometry.coordinates[0]
}

export function getApiNewPolygonData (data) {
	const polygonData = data.reduce((pre, cur) => {
		let arr = cur.data.map(i => turf.point([Number(i.x), Number(i.y)]))

		return pre.push(...arr), pre
	}, [])

	const hull = turf.convex(turf.featureCollection(polygonData))

	return hull.geometry.coordinates[0]
}

export function getBufferPolygonData (data, meters = 0) {
	const turfPolygonData = data.map(i => [i.lng, i.lat])
	const polygon = turf.polygon([[...turfPolygonData, turfPolygonData[0]]])

	const buffered = turf.buffer(polygon, meters, {
		units: 'meters',
		steps: 16
	})

	return buffered.geometry.coordinates[0]
}