import CreateFrustum from '@/utils/cesium/frustum/CreateFrustum'

import arrow from '@/assets/gltf/arrow.gltf'
import * as Cesium from 'cesium'
import { Decimal } from 'decimal.js'
import _, { cloneDeep, throttle } from 'lodash'
import * as turf from '@turf/turf'
import { DRONE_LIST } from '@/const/device'
import { cameraModeList } from '@/const/drc'
import { getCameraInfoApi } from '@/api/payload'
import takeoffImg from '@/assets/images/routePlan/pointAirLine/takeoff.svg'
import { cartesian3Convert } from '@/utils/cesium/mapUtil'
import { analyzeKmzFile, removeTextKey, XMLToJSON } from '@/utils/cesium/kmz'
import { camelToSnake } from '@/utils/util'

let createFrustum = null
let editPoint = null
let startPointEntity = null

// 获取两点的角度
export function getAngle (start, end) {
	let point1 = turf.point([start.longitude, start.latitude])
	let point2 = turf.point([end.longitude, end.latitude])
	let attitude_head = turf.bearing(point2, point1)
	let flyRotateYaw = attitude_head >= 0 ? attitude_head - 180 : 180 + attitude_head
	return _.round(flyRotateYaw, 2)
}

// 创建或更新椎体
export const setFrustum = (params, viewer) => {
	function hasValue (variable) {
		return variable !== null && variable !== undefined && variable.toString().trim() !== ''
	}

	function transformValue (value, type = 1) {
		let curValue = Number(value)
		if (type === 1) {
			let diffValue = curValue === 2 ? 200 : curValue === 200 ? 2 : new Decimal(Number(200)).minus(Number(curValue))
			return new Decimal(Number(diffValue)).dividedBy(Number(10))
		}
		return new Decimal(Number(value)).dividedBy(Number(2)).dividedBy(Number(100))
	}

	const { longitude, latitude, height, fov = 19.5, heading = 0, pitch = 0 } = params
	if (hasValue(longitude) && hasValue(latitude) && hasValue(height) && hasValue(fov) && hasValue(heading) && hasValue(pitch)) {
		createFrustum?.clear()
		createFrustum = new CreateFrustum(viewer, {
			position: { longitude, latitude, altitude: height },
			width: 400,
			height: 300,
			near: 0.01,
			far: 200,
			fov: transformValue(fov || 19.5),
			roll: 0,
			pitch: pitch - 90,
			heading: heading - 90,
		})
	}
}

// 删除椎体
export const removeFrustum = () => {
	createFrustum?.clear()
	createFrustum = null
}

// 设置箭头
export function setArrowPoint (roamPoint, viewer) {
	if (!(roamPoint.longitude && roamPoint.latitude && roamPoint.height)) return
	const position = Cesium.Cartesian3.fromDegrees(roamPoint.longitude, roamPoint.latitude, roamPoint.height)
	const heading = roamPoint.arrowHeading || 0
	const convertHeading = heading >= 0 ? heading - 180 : heading + 180
	if (editPoint) {
		editPoint.position = position
		editPoint.orientation = Cesium.Transforms.headingPitchRollQuaternion(
			position,
			new Cesium.HeadingPitchRoll(
				Cesium.Math.toRadians(-90 + convertHeading), // 头朝向 (Heading) +90°
				0, // 俯仰角 (Pitch)
				0 // 横滚角 (Roll)
			)
		)
		return
	}

	editPoint = viewer.entities.add({
		id: 'edit-point',
		position,
		model: {
			uri: arrow,
			scale: 0.00001, // 放大模型
			minimumPixelSize: 50, // 让模型在屏幕上最小显示 40px
			color: Cesium.Color.CORNFLOWERBLUE,
			colorBlendMode: Cesium.ColorBlendMode.MIX,
			colorBlendAmount: 0.5,
		},
		orientation: Cesium.Transforms.headingPitchRollQuaternion(
			position,
			new Cesium.HeadingPitchRoll(
				Cesium.Math.toRadians(-90 + convertHeading), // 头朝向 (Heading) +90°
				0, // 俯仰角 (Pitch)
				0 // 横滚角 (Roll)
			)
		),
	})
}

// 删除箭头
export function removeArrowPoint (viewer) {
	if (editPoint) {
		viewer.entities.remove(editPoint)
		editPoint = null
	}
}

// 获取当前机型支持的摄像头
export async function getCameraInfoList (drone_info) {
	const res = await getCameraInfoApi(drone_info, 2)
	let list = []
	let zoomRang = { zoomMax: 56, zoomMin: 2 }
	res.data?.data?.forEach(item => {
		if (item.camera_mode === 2) {
			zoomRang.zoomMax = _.round(item.zoom_factor_max)
			zoomRang.zoomMin = _.round(item.zoom_factor_min)
		}
		if (item.is_storage === 1) {
			const find = cameraModeList.find(item1 => item1.camera_mode === item.camera_mode)
			find && list.push({ ...find, ...item })
		}
	})
	return { list, zoomRang }
}

/**
 * 判断action里面是否有key
 * @param action
 * @param key
 * @returns {{hasKey: boolean, val: *}|{hasKey: boolean, val: null}}
 */
export function actionHasKey (action, key) {
	const curActionParams = action?.action_actuator_func_param
	const val = curActionParams?.[key]
	if (val !== undefined) {
		return { hasKey: true, val }
	} else {
		return { hasKey: false, val: null }
	}
}


// 处理保存参数
export function handleSaveParams ({ pointList, startPoint, globalSettings }) {
	const isWGS84 = globalSettings.execute_height_mode === 'WGS84'
	let speak_file_ids = []
	const { longitude, latitude, height: startPointHeight } = startPoint
	let point_params = _.cloneDeep(pointList)
	point_params.shift()
	point_params = point_params.map(item => {
		if (!item?.action_modes?.length) item.action_modes = undefined
		item?.action_modes?.forEach(item1 => {
			// 如果是gimbalPitchRotate，需要修改为gimbalRotate
			if (item1.action_actuator_func === 'gimbalPitchRotate') {
				item1.action_actuator_func = 'gimbalRotate'
			}
			// 如果有喊话，需要收集它的id
			if (item1.action_actuator_func === 'megaphone') {
				if (item1.action_actuator_func_param.megaphone_operate_type === 0) {
					speak_file_ids.push(item1.action_actuator_func_param.speak_file_id)
				}
			}
			// 如果有变焦，需要 *24
			const { hasKey: has_focal_length, val: focal_length } = actionHasKey(item1, 'focal_length')
			if (has_focal_length && focal_length) {
				item1.action_actuator_func_param.focal_length = focal_length * 24
			}
		})
		return {
			...item,
			insert_waypoint: 0,
			click_tiles: 0,
			execute_height: isWGS84 ? item.height : item.height - startPointHeight,
		}
	})
	const payload_info = DRONE_LIST.flatMap(item => item.payloads).find(
		item => item.value === globalSettings.drone_info
	)?.payload_info

	const params = _.pick(globalSettings, [
		'execute_height_mode',
		'id',
		'wayline_name',
		'drone_info',
		'payload_info',
		'take_off_security_height',
		'take_off_ref_point',
		'auto_flight_speed',
		'wayline_type',
		'image_format',
	])
	return {
		...params,
		point_params,
		payload_info,
		speak_file_ids,
		global_height: isWGS84 ? globalSettings.absoluteHeight : globalSettings.relativeHeight,
		take_off_ref_point: `${latitude},${longitude},${startPointHeight}`,
		is_save: '1', //是否存航线库 0会立即飞
		rth_altitude: 120, //返航高度
		fly_to_wayline_mode: 'safely',
	}
}

// 解析kmz文件的时候处理pointList 写在这里
export function handlePointListForKmz ({ placemark, startPoint, execute_height_mode, auto_flight_speed }) {
	if (!placemark?.length) return []
	const isWGS84 = execute_height_mode === 'WGS84'
	const list = placemark.map(item => {
		const [longitude, latitude] = item.point.coordinates.trim().split(',').map(i => _.round(i, 6))
		const [latitude1, longitude1] = (item?.waypoint_heading_param?.waypoint_poi_point?.trim()?.split(',') || [])
			.map(i => _.round(i, 6))
		let action_modes = item?.action_group?.action || []
		action_modes = Array.isArray(action_modes) ? action_modes : [action_modes]
		const height = isWGS84 ? item.execute_height : item.execute_height + startPoint.height
		return {
			longitude,
			latitude,
			height: _.round(height,2),
			waypoint_speed: item.waypoint_speed,
			waypoint_poi_point: longitude1 ? { longitude: longitude1, latitude: latitude1 } : undefined,//兴趣点
			action_modes,
		}
	})
	const pointStart = {
		...startPoint,
		flyRotateYaw: 0,
		pointType: 'start',
		waypoint_speed: auto_flight_speed,
		heading: 0, // 椎体 heading
		arrowHeading: 0, // 飞行器 heading
		pitch: 0, //椎体俯仰角
		fov: 19.5, // 这个是椎体的展示截面大小
	}
	list.forEach(item => {
		item?.action_modes?.forEach(item1 => {
			let { hasKey: has_focal_length, val: focal_length } = actionHasKey(item1, 'focal_length')
			// 处理focalLength需要/24  focalLength可能是‘1,024’
			if (has_focal_length && focal_length) {
				focal_length = typeof focal_length === 'string' ? focal_length.replace(/,/g, '') : focal_length
				item1.action_actuator_func_param.focal_length = Number(focal_length) / 24
			}
		})
		item.arrowHeading = 0
	})
	return [pointStart, ...list]
}


export async function analysisPointLineKmz (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 {
		mission_config: {
			take_off_ref_point,
			drone_info: { drone_enum_value, drone_sub_enum_value } = {}
		} = {},
		folder: {
			payload_param: { image_format } = {},
			placemark: {
				polygon,
				margin: buffer_distance_meters = 0
			},
			global_height, auto_flight_speed,
			template_type: templateType
		} = {},
	} = templateXMLObj
	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 {
		mission_config: { take_off_security_height } = {},
		folder: polygonPointFolder
	} = waylinesXMLObj

	let execute_height_mode = '', pointPlacemark

	if (templateType === "mapping3d") {
		execute_height_mode = polygonPointFolder[0].execute_height_mode
		pointPlacemark = polygonPointFolder.map(i => i.placemark)
	} else {
		execute_height_mode = polygonPointFolder.execute_height_mode
		pointPlacemark = polygonPointFolder.placemark
	}
	// 取出点位
	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()
	const templatePlacemark = templateXMLObj.folder.placemark
	// 点航线list
	let pointList = handlePointListForKmz({
		placemark: polygonPointFolder.placemark,
		startPoint,
		execute_height_mode,
		auto_flight_speed
	}).map((i,index)=> {
		// 注入是否使用全局高度参数
		return {
			...i,
			use_global_height: index > 0 ? templatePlacemark[index-1]?.use_global_height : 0
		}
	})

	return {
		image_format,
		startPoint,
		global_height,
		auto_flight_speed,
		take_off_ref_point,
		drone_enum_value,
		drone_sub_enum_value,
		take_off_security_height,//起飞安全高度
		execute_height_mode,//执行高度模式
		pointList,//航点航线 点list
		templateType,
		pointPlacemark,
		polygonList,
		buffer_distance_meters
	}
}

// 生成起飞点
export function generateStartPoint (movement, viewer) {
	// 1. 获取笛卡尔坐标
	const cartesian = viewer.scene.pickPosition(movement.endPosition)
	if (!cartesian) return
	// 2. 笛卡尔转为弧度
	const cartographic = Cesium.Cartographic.fromCartesian(cartesian)
	const position = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude)
	// 4. 更新或创建点实体
	if (startPointEntity) {
		startPointEntity.position = position
		return
	}
	startPointEntity = viewer.entities.add({
		position,
		id: 'wayline-point-start-init',
		billboard: {
			image: takeoffImg,
			outlineWidth: 0,
			width: 36,
			height: 36,
			scale: 1.0,
			heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
		},
	})
}
// 获取起飞点位置
export function getStartPointLast (viewer) {
	const point = cartesian3Convert(startPointEntity.position.getValue(), viewer) //经纬度
	removeStartPoint(viewer)
	return point
}
export function removeStartPoint (viewer) {
	startPointEntity && viewer.entities.remove(startPointEntity)
	startPointEntity = null
}

// todo 获取新的云台偏航角(后续做更细致得控制）
export function getNewGimbalRollRotateAngle (list, index) {
	const flyRotateYaw = list[index].flyRotateYaw
	const actions = list[index].action_modes
	// 当前点击的点有云台偏航角
	const hasGimbalRollRotate = actions?.some(item => item?.action_actuator_func_param?.gimbal_yaw_rotate_enable === 1)
	let value = 0
	list.slice(0, index + 1).forEach(item => {
		item?.action_modes?.forEach(item1 => {
			const param = item1?.action_actuator_func_param
			const find = param?.gimbal_yaw_rotate_enable === 1
			if (find) {
				value = param?.gimbal_yaw_rotate_angle
			}
		})
	})
	return hasGimbalRollRotate ? value : value + flyRotateYaw
}

// 之前的俯仰角 value
export function getBeforeGimbalPitchRotateAngle (list, index) {
	let value = 0
	list.slice(0, index + 1).forEach(item => {
		item?.action_modes?.forEach(item1 => {
			const param = item1?.action_actuator_func_param
			const find = param?.gimbal_pitch_rotate_enable === 1
			if (find) {
				value = param?.gimbal_pitch_rotate_angle
			}
		})
	})
	return value
}


// 之前的变焦 value
export function getBeforeZoomValue (list, index) {
	let value = 5
	list.slice(0, index + 1).forEach(item => {
		item?.action_modes?.forEach(item1 => {
			const find = item1?.action_actuator_func === 'zoom'
			if (find) {
				value = item1?.action_actuator_func_param?.focal_length
			}
		})
	})
	return value
}

// 创建广告牌
export function createBillboard (title, fillColor, isHighlighted = false) {
	const billboard = document.createElement('canvas')
	billboard.width = 48
	billboard.height = 48
	const ctx = billboard.getContext('2d')

	// 如果选中，绘制阴影
	if (isHighlighted) {
		ctx.shadowColor = 'rgba(97, 211, 150, 0.9)' // 阴影颜色（#61d396半透明）
		ctx.shadowBlur = 12 // 阴影模糊程度
		ctx.shadowOffsetX = 0 // 阴影水平偏移
		ctx.shadowOffsetY = 0 // 阴影垂直偏移
	}

	// 绘制填充区域（三角形）
	ctx.beginPath()
	ctx.moveTo(6, 6)
	ctx.lineTo(42, 6)
	ctx.lineTo(24, 36)
	ctx.closePath()
	ctx.fillStyle = fillColor // 填充颜色
	ctx.fill()

	// 如果选中，绘制边框
	if (isHighlighted) {
		ctx.strokeStyle = 'white' // 边框颜色（#61d396）
		ctx.lineWidth = 2 // 边框宽度
		ctx.stroke()
	}

	// 绘制文字
	ctx.font = '14px serif'
	ctx.fillStyle = '#ffffff'
	ctx.fillText(title, 20, 20)

	return billboard.toDataURL() // 返回图片的DataURL
}

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

// 计算射线与固定高度平面的交点
export function findIntersectionWithHeight (viewer, ray, height, lastGoodPosition) {
	const globe = viewer.scene.globe

	// 创建一个函数来检查某点是否在目标高度
	const checkHeight = position => {
		const cartographic = Cesium.Cartographic.fromCartesian(position)
		return cartographic.height - height
	}

	// 如果有上一个有效位置，使用它来优化搜索范围
	let start = 0
	let end = 20000000 // 增加搜索范围

	if (lastGoodPosition) {
		// 计算射线原点到上一个位置的距离作为参考
		const distance = Cesium.Cartesian3.distance(ray.origin, lastGoodPosition)
		start = Math.max(0, distance * 0.5)
		end = distance * 1.5
	}

	let iterations = 0
	const maxIterations = 100 // 增加最大迭代次数

	let startPoint = Cesium.Cartesian3.fromElements(
		ray.origin.x + ray.direction.x * start,
		ray.origin.y + ray.direction.y * start,
		ray.origin.z + ray.direction.z * start
	)

	let endPoint = Cesium.Cartesian3.fromElements(
		ray.origin.x + ray.direction.x * end,
		ray.origin.y + ray.direction.y * end,
		ray.origin.z + ray.direction.z * end
	)

	let startHeight = checkHeight(startPoint)
	let endHeight = checkHeight(endPoint)

	// 如果起点和终点高度差异方向不对，调整搜索范围
	if (startHeight * endHeight > 0) {
		if (Math.abs(startHeight) < Math.abs(endHeight)) {
			end = start + (end - start) * 0.1
		} else {
			start = end - (end - start) * 0.1
		}
		startPoint = Cesium.Cartesian3.fromElements(
			ray.origin.x + ray.direction.x * start,
			ray.origin.y + ray.direction.y * start,
			ray.origin.z + ray.direction.z * start
		)
		endPoint = Cesium.Cartesian3.fromElements(
			ray.origin.x + ray.direction.x * end,
			ray.origin.y + ray.direction.y * end,
			ray.origin.z + ray.direction.z * end
		)
		startHeight = checkHeight(startPoint)
		endHeight = checkHeight(endPoint)
	}

	while (iterations < maxIterations) {
		const mid = (start + end) / 2
		const midPoint = Cesium.Cartesian3.fromElements(
			ray.origin.x + ray.direction.x * mid,
			ray.origin.y + ray.direction.y * mid,
			ray.origin.z + ray.direction.z * mid
		)

		const midHeight = checkHeight(midPoint)

		if (Math.abs(midHeight) < 1.0) {
			// 增加容差
			return midPoint
		}

		if (midHeight * startHeight < 0) {
			end = mid
			endPoint = midPoint
			endHeight = midHeight
		} else {
			start = mid
			startPoint = midPoint
			startHeight = midHeight
		}

		iterations++
	}

	// 如果二分法失败，返回最接近目标高度的点
	if (Math.abs(startHeight) < Math.abs(endHeight)) {
		return startPoint
	} else {
		return endPoint
	}
}

// 获取连接地面线
export function getPolyLine (viewer, pointList, index) {
	return {
		positions: new Cesium.CallbackProperty(() => {
			const point = pointList.value[index]
			const pointPosition = Cesium.Cartesian3.fromDegrees(point.longitude, point.latitude, point.height)
			if (!pointPosition) return []
			// 获取点的位置
			const cartographic = Cesium.Cartographic.fromCartesian(pointPosition)
			// 获取地形高度
			const terrainHeight = viewer.scene.globe.getHeight(cartographic) || 0
			// 创建地面点位置
			const groundPosition = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, terrainHeight)

			return [pointPosition, groundPosition]
		}, false),
		width: 0.5,
		material: Cesium.Color.WHITE,
	}
}