import { actions, storeDate } from '../store/store.js'   //局部状态管理

// 添加s3m
function addS3mLayers(scps, callback) {  //scps:[{ url, options:{name}]}  无返回值
    let promiseArray = [];
    try {
        if (scps) {
            //加载scps
            scps.forEach(scp => {
                promiseArray.push(
                    viewer.scene.addS3MTilesLayerByScp(scp.url, scp.options)
                );
            });
        }
        promiseWhen(promiseArray, callback, 'S3M')
    } catch (e) {
        let widget = viewer.cesiumWidget;
        if (widget._showRenderLoopErrors) {
            let title = "渲染时发生错误，已停止渲染。";
            widget.showErrorPanel(title, undefined, e);
        }
    }
};


// 添加场景
function addScene(url, options, callback) {  //无返回值options:{SceneToken,autoSetView}
    if (options && options.SceneToken) {
        Cesium.Credential.CREDENTIAL = new Cesium.Credential(options.SceneToken);
    }
    let flag = true;
    if (options && options.autoSetView !== undefined) {
        flag = options.autoSetView
    }
    if (checkURL(url)) {
        try {
            let s = [viewer.scene.open(url, undefined, { 'autoSetView': flag })];
            promiseWhen(s, callback, 'SCENE');
        } catch (e) {
            let widget = viewer.cesiumWidget;
            if (widget._showRenderLoopErrors) {
                let title = "渲染时发生错误，已停止渲染。";
                widget.showErrorPanel(title, undefined, e);
            }
        }
    }
};

// 添加地形
function addTerrainLayer(LayerURL, isSct) {
    try {
        const terrainProvider = new Cesium.CesiumTerrainProvider({
            url: LayerURL,
            isSct: isSct, //地形服务源自SuperMap iServer发布时需设置isSct为true
        });
        viewer.terrainProvider = terrainProvider;
        return terrainProvider;
    } catch (e) {
        let widget = viewer.cesiumWidget;
        if (widget._showRenderLoopErrors) {
            let title = "渲染时发生错误，已停止渲染。";
            widget.showErrorPanel(title, undefined, e);
        }
        return null;
    }
};

// 添加影像
function addImageLayer(LayerURL) {    // 返回img图层layer
    try {
        let layer = viewer.imageryLayers.addImageryProvider(
            new Cesium.SuperMapImageryProvider({
                url: LayerURL,
            })
        );
        return layer
    } catch (e) {
        let widget = viewer.cesiumWidget;
        if (widget._showRenderLoopErrors) {
            let title = "渲染时发生错误，已停止渲染。";
            widget.showErrorPanel(title, undefined, e);
        }
    }

};

// 添加mvt
function addMvtLayer(LayerURL, name, callback) {    // 返回img图层layer
    try {
        let mvtMap = viewer.scene.addVectorTilesMap({
            url: LayerURL,
            canvasWidth: 512,
            name: name || 'mvt',
            viewer: viewer
        });
        Cesium.when(mvtMap.readyPromise, function (data) {
            var bounds = mvtMap.rectangle;
            viewer.scene.camera.flyTo({
                destination: new Cesium.Cartesian3.fromRadians(
                    (bounds.east + bounds.west) * 0.5,
                    (bounds.north + bounds.south) * 0.5,
                    10000
                ),
                duration:0,
                orientation: {
                    heading: 0,
                    roll: 0
                }
            });
            actions.setChangeLayers();
            callback(mvtMap)
        });
        return mvtMap
    } catch (e) {
        let widget = viewer.cesiumWidget;
        if (widget._showRenderLoopErrors) {
            let title = "渲染时发生错误，已停止渲染。";
            widget.showErrorPanel(title, undefined, e);
        }
    }

};

function addGeoJsonLayer(url, name, callback) {
    try {
        const loadPromise = Cesium.GeoJsonDataSource.load(url, {
            stroke: Cesium.Color.fromCssColorString('#00FF00').withAlpha(1),
            fill: Cesium.Color.fromCssColorString('#00FF00').withAlpha(0.3),
            strokeWidth: 3
        });
        
        Cesium.when(loadPromise, function(dataSource) {
            viewer.dataSources.add(dataSource);
            let entities = dataSource.entities.values;
            
            let boundingSphere = new Cesium.BoundingSphere();
            let entitiesLength = entities.length;
            
            for (let i = 0; i < entitiesLength; i++) {
                let entity = entities[i];
                entity.name = name || 'GeoJSON';
                
                if (entity.boundingSphere) {
                    if (i === 0) {
                        boundingSphere = entity.boundingSphere;
                    } else {
                        boundingSphere = Cesium.BoundingSphere.union(boundingSphere, entity.boundingSphere);
                    }
                }
            }
            
            viewer.flyTo(dataSource, { duration: 2 });
            
            actions.setChangeLayers();
            if (callback) callback(dataSource);
        }, function(error) {
            console.error("加载GeoJSON失败:", error);
            let widget = viewer.cesiumWidget;
            if (widget && widget._showRenderLoopErrors) {
                let title = "加载GeoJSON失败，请检查URL是否正确";
                widget.showErrorPanel(title, undefined, error);
            }
        });
    } catch (e) {
        console.error("加载GeoJSON异常:", e);
        let widget = viewer.cesiumWidget;
        if (widget && widget._showRenderLoopErrors) {
            let title = "渲染时发生错误，已停止渲染。";
            widget.showErrorPanel(title, undefined, e);
        }
    }
};

// 加载s3m和场景函数
function promiseWhen(promiseArray, callback, type) {
    Cesium.when.all(
        promiseArray,
        function (layers) {
            console.log("layers:",layers)
            storeDate.layers = viewer.scene.layers.layerQueue;
            actions.setChangeLayers();
            callback(layers, type);
            storeDate.layers.forEach((s3mlayer) => {
                if (!s3mlayer.visibleDistanceMax || s3mlayer.visibleDistanceMax > 12000) {
                    s3mlayer.visibleDistanceMax = 12000   //设置模型最可见距离
                }
            })
        },
        function (e) {
            let widget = viewer.cesiumWidget;
            if (widget._showRenderLoopErrors) {
                let title = '请检查url地址是否正确？';
                widget.showErrorPanel(title, undefined, e);
            }
        }
    );
};

//   检验url地址
function checkURL(url) {
    if (url === null || url === "") {
        return false;
    }
    if (url.charAt(0) == '"' || url.charAt(0) == "'") {
        let reg = /^['|"](.*)['|"]$/;
        url = url.replace(reg, "$1");
    }
    return true
};

//   删除图层
function layersDelete(type, id_name, callback) {
    switch (type) {
        case "SCENE":
            console.log('开始删除SCENE图层, id_name:', id_name);
            if (viewer.scene.layers && viewer.scene.layers.layerQueue) {
                const layers = viewer.scene.layers.layerQueue;
                console.log('场景中的图层数量:', layers.length);
                for (let i = layers.length - 1; i >= 0; i--) {
                    const layer = layers[i];
                    console.log('删除图层:', i, layer.name);
                    viewer.scene.layers.remove(layer);
                }
            }
            actions.setChangeLayers();
            if (callback) callback();
            break;
        case "S3M":
            viewer.scene.layers.remove(id_name);
            actions.setChangeLayers();
            if (callback) callback();
            break;
        case "IMG":
            let img_layer;
            if (typeof (id_name) === 'nunber') {
                img_layer = viewer.imageryLayers.get(id_name);
            } else {
                let img_layers = viewer.imageryLayers._layers
                for (let i = 0; i < img_layers.length; i++) {
                    if (img_layers[i].imageryProvider.tablename && img_layers[i].imageryProvider.tablename === id_name) {
                        img_layer = img_layers[i];
                    }
                };
            }
            if (img_layer) {
                viewer.imageryLayers.remove(img_layer);
                actions.setChangeLayers();
                if (callback) callback();
            }
            break;
        case "TERRAIN":
            viewer.terrainProvider = new Cesium.EllipsoidTerrainProvider();
            actions.setChangeLayers();
            if (callback) callback();
            break;
        case "MVT":
            viewer.scene.removeVectorTilesMap(id_name);
            actions.setChangeLayers();
            if (callback) callback();
            break;
        case "GEOJSON":
        case "SHP":
            if (viewer.dataSources) {
                const dataSources = viewer.dataSources._dataSources;
                for (let i = dataSources.length - 1; i >= 0; i--) {
                    const ds = dataSources[i];
                    if (ds.name === id_name || ds._name === id_name) {
                        viewer.dataSources.remove(ds);
                        break;
                    }
                }
            }
            actions.setChangeLayers();
            if (callback) callback();
            break;
        default:
            if (callback) callback();
    }
}



export default {
    addS3mLayers,
    addScene,
    addTerrainLayer,
    addImageLayer,
    layersDelete,
    addMvtLayer,
    addGeoJsonLayer
};
export {
    addS3mLayers,
    addScene,
    addTerrainLayer,
    addImageLayer,
    layersDelete,
    addMvtLayer,
    addGeoJsonLayer
};