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;
    },
    /**
     *
     * 创建发光
     *
     */
    setLuminosity() {
        const { Cartesian2, PostProcessStage, PostProcessStageComposite, PostProcessStageSampleMode } = Cesium;

        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.1, 0.1, 0.1],
                luminosityThreshold: 0.5,
                defaultOpacity: 0.5,
                smoothWidth: 0.01,
            },
        });

        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 separableBlurShader = {
            defines: {
                KERNEL_RADIUS: 11,
                SIGMA: 1,
            },
            fragmentShader: kernelFShader,
        };
        this.parseDefines(separableBlurShader);

        let kernel1 = new PostProcessStage({
            name: "kernel1",

            fragmentShader: separableBlurShader.fragmentShader,
            uniforms: {
                direction: blurDirectionX,
            },
        });

        // const blurCompositeStage = new PostProcessStageComposite({
        //     name: "BlurComposite",
        //     stages: [highlight, blurStage1, blurStage2],
        //     inputPreviousStageTexture: true
        // })

        sgworld._Viewer.scene.postProcessStages.add(kernel1);
    },
    /**
     *
     * 创建热力图
     *
     */
    createHeatMap(response, attr) {
        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) {
        let features = response.data.features;
        let entityData = [];
        let groupId = sgworld.ProjectTree.createGroup("柱状图", true, 0);
        var StartColor = "#2222c6";
        var EndColor = "#a5dc0e";
        //获取填充颜色
        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;
            var num = Math.floor(((value - minVal) / (maxVal - minVal)) * 10);
            var ysk = colorArr[num];

            let scale = 10;
            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: 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() {},
};