const { Cartesian2, PostProcessStage, PostProcessStageComposite, PostProcessStageSampleMode } = Cesium;
export default {
    /**
     *
     * 地图参数
     *
     */
    mapOption: {},
    /**
     *
     * 初始化地图
     *
     */
    initMap() {
        let option = {
            url: SmartEarthRootUrl + "Workers/image/earth.jpg",
            fullscreenButton: true,
            contextOptions: {
                failIfMajorPerformanceCaveat: false,
                webgl: {
                    alpha: true,
                    preserveDrawingBuffer: true,
                },
            },
        };

        window.sgworld = new SmartEarth.SGWorld("sdkContainer", Cesium, option, null, function() {});
        var dx = {
            url: "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer",
            enablePickFeatures: false,
        };
        sgworld.Creator.createArcGisImageryLayer("ARCGIS", dx, "0", undefined, true, "");

        window.Viewer = sgworld._Viewer;
        Viewer.shadows = false;
        //fps
        Viewer.scene.debugShowFramesPerSecond = false;
    },
    /**
     *
     * 切换对象状态
     *
     */
    toggleObject(object) {},
    /**
     *
     * 隐藏对象
     *
     */
    hideObject() {},
    /**
     *
     * 显示对象
     *
     */
    showObject() {},
    /**
     *
     * 创建WMS
     *
     */
    createWMS() {},
    /**
     *
     * 创建WFS
     *
     */
    createWFS() {},
    parseDefines(shader) {
        let defines = [];
        for (const key in shader.defines) {
            if (shader.defines.hasOwnProperty(key)) {
                const val = shader.defines[key];
                defines.push("#define " + key + " " + val);
            }
        }
        defines = defines.join("\n") + "\n";
        if (shader.fragmentShader) {
            shader.fragmentShader = defines + shader.fragmentShader;
        }
        if (shader.vertexShader) {
            shader.vertexShader = defines + shader.vertexShader;
        }
        return shader;
    },
    kernelblur(name, sigma, radius, textureScale) {
        let kernelFShader = `varying vec2 v_textureCoordinates;
                            uniform sampler2D colorTexture;
                            uniform vec2 colorTextureDimensions;
                            uniform vec2 direction;

                            float gaussianPdf(in float x, in float sigma) {
                                return 0.39894 * exp( -0.5 * x * x/( sigma * sigma))/sigma;
                            }
                            void main() {
                                
                                vec2 invSize = 1.0 / colorTextureDimensions;
                                float fSigma = float(SIGMA);
                                float weightSum = gaussianPdf(0.0, fSigma);
                                vec3 diffuseSum = texture2D( colorTexture, v_textureCoordinates).rgb * weightSum;
                                for( int i = 1; i < KERNEL_RADIUS; i ++ ) {
                                    float x = float(i);
                                    float w = gaussianPdf(x, fSigma);
                                    vec2 uvOffset = direction * invSize * x;
                                    vec3 sample1 = texture2D( colorTexture, v_textureCoordinates + uvOffset).rgb;
                                    vec3 sample2 = texture2D( colorTexture, v_textureCoordinates - uvOffset).rgb;
                                    diffuseSum += (sample1 + sample2) * w;
                                    weightSum += 2.0 * w;
                                }
                                gl_FragColor = vec4(diffuseSum/weightSum, 1.0);
                            }`;

        let blurDirectionX = new Cartesian2(1.0, 0.0);
        let blurDirectionY = new Cartesian2(0.0, 1.0);

        let separableBlurShader = {
            defines: {
                KERNEL_RADIUS: radius,
                SIGMA: sigma,
            },
            fragmentShader: kernelFShader,
        };
        this.parseDefines(separableBlurShader);
        let blurX = new PostProcessStage({
            name: name + "X",
            textureScale: textureScale,
            fragmentShader: separableBlurShader.fragmentShader,
            forcePowerOfTwo: true,
            uniforms: {
                direction: blurDirectionX,
            },
            sampleMode: PostProcessStageSampleMode.LINEAR,
        });
        let blurY = new PostProcessStage({
            name: name + "Y",
            textureScale: textureScale,
            fragmentShader: separableBlurShader.fragmentShader,
            forcePowerOfTwo: true,
            uniforms: {
                direction: blurDirectionY,
            },
            sampleMode: PostProcessStageSampleMode.LINEAR,
        });
        let separableBlur = new PostProcessStageComposite({
            name: name,
            stages: [blurX, blurY],
            inputPreviousStageTexture: true,
        });
        return separableBlur;
    },
    loadHighlight() {
        let name = "light";
        let fShader = `uniform sampler2D colorTexture;
        uniform vec3 defaultColor;
        uniform float defaultOpacity;
        uniform float luminosityThreshold;
        uniform float smoothWidth;

        varying vec2 v_textureCoordinates;
        void main() {
            vec4 texel = texture2D(colorTexture, v_textureCoordinates);

            #ifdef CZM_SELECTED_FEATURE
                if(!czm_selected()) {
                    texel = vec4(0.);
                }
            #endif

            vec3 luma = vec3(0.299, 0.587, 0.114);
            float v = dot(texel.xyz, luma);
            vec4 outputColor = vec4(defaultColor.rgb, defaultOpacity);
            float alpha = smoothstep(luminosityThreshold, luminosityThreshold + smoothWidth, v);
            gl_FragColor = mix(outputColor, texel, alpha);
        }`;

        let highlight = new PostProcessStage({
            name: "highlight",
            fragmentShader: fShader,
            uniforms: {
                defaultColor: [0.3, 0.3, 0.3],
                luminosityThreshold: 0.6,
                defaultOpacity: 0.1,
                smoothWidth: 0.01,
            },
        });

        const blurStage1 = this.kernelblur(name + "Blur1", 3, 3, 1.0);
        const blurStage2 = this.kernelblur(name + "Blur2", 5, 5, 0.5);
        const blurStage3 = this.kernelblur(name + "Blur3", 7, 7, 0.25);
        const blurStage4 = this.kernelblur(name + "Blur4", 9, 9, 0.125);
        const blurStage5 = this.kernelblur(name + "Blur5", 11, 11, 0.0625);
        const blurCompositeStage = new PostProcessStageComposite({
            name: name + "BlurComposite",
            stages: [highlight, blurStage1, blurStage2, blurStage3, blurStage4, blurStage5],
            inputPreviousStageTexture: true,
        });

        let blendFShader = `varying vec2 v_textureCoordinates;
        uniform sampler2D blurTexture1;
        uniform sampler2D blurTexture2;
        uniform sampler2D blurTexture3;
        uniform sampler2D blurTexture4;
        uniform sampler2D blurTexture5;
        uniform sampler2D colorTexture;

        float lerpBloomFactor(const in float factor) {
            float mirrorFactor = 1.2 - factor;
            return mix(factor, mirrorFactor, 0.1);
        }

        void main() {

            vec4 color = texture2D(colorTexture, v_textureCoordinates);
            vec4 bloomTintColor = vec4(1.,1.,1.,1.);
            vec4 bloomColor = 1. * (
                lerpBloomFactor(1.0) * bloomTintColor * texture2D(blurTexture1, v_textureCoordinates) +
                lerpBloomFactor(0.8) * bloomTintColor * texture2D(blurTexture2, v_textureCoordinates) +
                lerpBloomFactor(0.6) * bloomTintColor * texture2D(blurTexture3, v_textureCoordinates) +
                lerpBloomFactor(0.4) * bloomTintColor * texture2D(blurTexture4, v_textureCoordinates) +
                lerpBloomFactor(0.2) * bloomTintColor * texture2D(blurTexture5, v_textureCoordinates)
            );

            gl_FragColor = bloomColor + color;
        }`;

        const addStage = new PostProcessStage({
            name: name + "Additive",
            uniforms: {
                blurTexture1: blurStage1.name,
                blurTexture2: blurStage2.name,
                blurTexture3: blurStage3.name,
                blurTexture4: blurStage4.name,
                blurTexture5: blurStage5.name,
            },
            fragmentShader: blendFShader,
        });
        const compositeStage = new PostProcessStageComposite({
            name: name + "Composite",
            stages: [blurCompositeStage, addStage],
            inputPreviousStageTexture: false,
        });
        return compositeStage;
    },
    /**
     *
     * 创建发光
     *
     */
    setLuminosity() {
        return this.loadHighlight();
        //window.sceneObj.highlight =

        //sgworld._Viewer.scene.postProcessStages.add(compositeStage);
    },
    /**
     *
     * 创建热力图
     *
     */
    createHeatMap(response, attr, nameAttr) {
        let that = this;

        let features = response.data.features;
        let heatmapData = [];
        for (let i = 0; i < features.length; i++) {
            let geom = features[i].geometry.coordinates;
            let pre = features[i].properties;
            //var position = { X: geom[0], Y: geom[1], Altitude: 100 };
            let value = pre[attr] ? pre[attr] : 1;
            value = Math.sqrt(value);
            // value = 1;
            heatmapData.push({
                x: geom[0],
                y: geom[1],
                value: value,
            });
        }
        let heatmapLayer = sgworld.Creator.addHeatMap("热力图1", {
            type: "Heatmap3D", // 热力图类型
            sourceData: heatmapData,
            radius: 100,
            minHeight: 0, // 底部高度
            TIN_X: 300,
            TIN_Y: 300,
            colorScale: 1, //色值转换高度的比例
            //showTIN: true, //显示三角网
            //tooltip: true // tooltip显示数值
        });
        return heatmapLayer;
    },
    /**
     *
     * 创建地图柱状图
     *
     */
    createMapBar(response, attr, nameAttr) {
        let features = response.data.features;
        let entityData = [];
        let groupId = sgworld.ProjectTree.createGroup("柱状图", true, 0);
        var StartColor = "#0088ff";
        var EndColor = "#a5dc00";
        //获取填充颜色
        var colorArr = sgworld.Core.gradientColor(StartColor, EndColor, 10);
        var maxVal = -99999;
        var minVal = 99999;
        for (let i = 0; i < features.length; i++) {
            let pre = features[i].properties;
            let value = pre[attr] ? pre[attr] : 1;
            if (value > maxVal) {
                maxVal = value;
            }
            if (value < minVal) {
                minVal = value;
            }
        }

        for (let i = 0; i < features.length; i++) {
            let geom = features[i].geometry.coordinates;
            let pre = features[i].properties;
            //var position = { X: geom[0], Y: geom[1], Altitude: 100 };
            let value = pre[attr] ? pre[attr] : 1;

            let labelVal = pre[attr] ? pre[attr] : 0;
            if (labelVal > 500) {
                let labelName = pre[nameAttr];
                var num = Math.floor(((value - minVal) / (maxVal - minVal)) * 10);
                var ysk = colorArr[num];

                let scale = 0.3;
                let Histogramwidth = 100;

                var position = sgworld.Creator.CreatePosition(geom[0], geom[1], (value * scale) / 2, 1, 0, 0, 0, 300);
                let cylinder = sgworld.Creator.CreateCylinder(position, Histogramwidth, value * scale, "", ysk, 100, groupId, "柱" + i);

                //let label = sgworld.Creator.CreateLabel(position,value,"",{},groupId, "文本" + i);
                let label = sgworld.Creator.addSimpleGraphic("label", {
                    position: Cesium.Cartesian3.fromDegrees(geom[0], geom[1], value * scale),
                    removeEdit: true,
                    text: labelName + "\n" + labelVal.toFixed(2) + " ",
                    heightReference: 0,
                    font: "42px 宋体",
                    outlineWidth: 2,
                    GroupID: groupId,
                });
            }
        }
        return groupId;
    },
    /**
     *
     * 创建模型
     *
     */
    createModel(url) {
        window.sceneObj.tiltLowModel = sgworld.Creator.create3DTilesets(
            "",
            url,
            {
                skipLevelOfDetail: true,
                preferLeaves: true,
            },
            {},
            0,
            true,
            (data) => {
                sgworld.Navigate.flyToObj(data);
            }
        );
    },
    /**
     *
     * 创建发光线
     *
     */
    createFlyLine() {},
    /**
     *
     * 创建扫描
     *
     */
    createScanLight() {},
    /**
     *
     * 创建圆形扫描
     *
     */
    createCircleLight() {},
};