import type { Viewer } from 'cesium'
import {
    CallbackProperty, Cartesian3, Color, CylinderGeometry, EllipsoidSurfaceAppearance, GeometryInstance, Material,
    Primitive, Rectangle, RectangleGeometry, Transforms,
} from 'cesium'

const SCENE_SIM_OTHER: { [key: string]: any } = {
    FLOOD: { name: '水淹模拟', key: 'FLOOD' },
}

// 水淹参数接口
interface FloodIF {
    height: number
    isGlobe: boolean // 是否全球范围水淹
    animate: boolean // 是否采用动画形式
    center: Position
    radius: number
    targetHeight: number
    speed: number
}

/**
 * 淹没分析函数，通过拉伸面的高度来进行分析
 * @param {*} viewer
 * @param {*} targetWaterHeight ：目标水位高度
 * @param {*} positions ：研究区域底部坐标数组
 * @param {*} waterHeight ：当前水位高度
 */
export function induationAnalysis(viewer: Viewer, flood: FloodIF) {
    // 如果要实时更新水位高度用entity，primitives无法动态更新
    if (flood.animate) {
        let height = flood.height
        // 颜色模拟的水面效果
        const heightCallback = new CallbackProperty(() => {
            height += flood.speed
            if (height > flood.targetHeight)
                height = flood.targetHeight

            return height
        }, false)

        let entity
        if (flood.isGlobe)
            entity = viewer.entities.add({
                id: SCENE_SIM_OTHER.FLOOD.key,
                name: SCENE_SIM_OTHER.FLOOD.key,
                rectangle: {
                    coordinates: Rectangle.fromDegrees(-180.0, -90.0, 180.0, 90.0),
                    height: heightCallback,
                    material: Color.fromBytes(64, 157, 253, 150),
                },
            })

        else
            entity = viewer.entities.add({
                id: SCENE_SIM_OTHER.FLOOD.key,
                name: SCENE_SIM_OTHER.FLOOD.key,
                position: Cartesian3.fromDegrees(flood.center.lon, flood.center.lat),
                cylinder: {
                    length: heightCallback,
                    topRadius: flood.radius,
                    bottomRadius: flood.radius,
                    slices: 20, // 切片数，影响圆柱体的细节
                    material: Color.fromBytes(64, 157, 253, 150),
                },
            })

        return entity
    }
    else {
        let geometryInstances: GeometryInstance
        if (flood.isGlobe)
            geometryInstances = new GeometryInstance({
                geometry: new RectangleGeometry({
                    rectangle: Rectangle.fromDegrees(-180.0, -90.0, 180.0, 90.0),
                    extrudedHeight: flood.height,
                    vertexFormat: EllipsoidSurfaceAppearance.VERTEX_FORMAT,
                }),
            })

        else
            geometryInstances = new GeometryInstance({
                geometry: new CylinderGeometry({
                    length: flood.height, // 高度
                    topRadius: flood.radius, // 顶部半径
                    bottomRadius: flood.radius, // 底部半径
                    slices: 20, // 切片数，影响圆柱体的细节
                    vertexFormat: EllipsoidSurfaceAppearance.VERTEX_FORMAT,
                }),
                modelMatrix: Transforms.eastNorthUpToFixedFrame(Cartesian3.fromDegrees(flood.center.lon, flood.center.lat)), // 设置圆柱体位置
            })

        // 流动水面效果
        const polygonPrimitive = viewer?.scene.primitives.add(
            new Primitive({
                geometryInstances,
                appearance: new EllipsoidSurfaceAppearance({
                    aboveGround: false,
                    material: new Material({
                        fabric: {
                            type: 'Water',
                            uniforms: {
                                baseWaterColor: Color.fromBytes(64, 157, 253, 150),
                                normalMap: 'cesium/waterNormals.jpg',
                                frequency: 1000.0,
                                animationSpeed: 0.1,
                                amplitude: 10,
                                specularIntensity: 10,
                            },
                        },
                    }),
                }),
            }),
        )

        return polygonPrimitive // 利用这个清除水淹效果
    }
}

// 清除流动水淹
viewer.scene.primitives.remove(polygonPrimitive)
// 清除动态水淹
viewer.entities.remove(entity)