import MapInterFace from './interface/MapInterFace';
import MapToolInterface from './interface/MapToolInterface';
import LayerTool from './MapTools/LayerTool';
import MeasureTool from './MapTools/MeasureTool';
import OperationTool from './MapTools/OperationTool';
import SelectTool from './MapTools/SelectTool';
/**
 *
 *
 * @class ZOceanMap
 * @implements {Map}
 */
class ZOceanMap implements MapInterFace{
    [x: string]: any;
    public element: any;    //地图容器
    public mapConfig: any;  //地图配置

    public isMapReady: boolean; //地图是否初始化完成

    private instance: ZOceanMap;

    private mapTools : Array<MapToolInterface>; 

    public controllers: Array<any>;

    public constructor(element: any ,mapConfig: any){
        this.element = element;
        this.mapConfig = mapConfig;
        this.mapTools = [];
        this.loadScriptsAsync()
    }
    destroyMap() {
        if(this.isMapReady){
            this.instance.map.destroyMap()
        }
    }



    /**
     *初始化地图
     *
     * @return {*}  {ZOceanMap}
     * @memberof ZOceanMap
     */
    public initeMap():ZOceanMap {
        const { MapPlatForm , ZenMap} = window as any; 
        const MAP_CONFIG = new MapPlatForm.Base.MapConfig();
        if(!ZenMap){
            return;
        }
        const ResultJson = MAP_CONFIG.createMap(this.element, this.mapConfig);
        const mapTools = new MapPlatForm.Base.MapTools(ResultJson.map);
        const mapService = new MapPlatForm.Base.MapService(ResultJson.map);
        let map = {
            map: ResultJson.map,
            mapConfig: MAP_CONFIG,
            mapTools,
            mapService
        }
        map.map.load(() => {
            // 地图加载完成回调
            // this.initMapConfig(options);
        });

        this.isMapReady = true;
        this.instance = map as unknown as ZOceanMap;
        return this.instance;
    }
    
    /**
     *
     *同步加载地图脚本
     * @private
     * @memberof ZOceanMap
     */
    private async loadScriptsAsync() {
        const scriptUrls:string [] = [
            '/zenmap/ZenMapGL.js',
            '/zenmap/ZenMapGL_Extend.js'
        ]
        if (!(window as any)._ZVMap) {
            (window as any)._ZVMap = {};
            const length = scriptUrls.length;
            scriptUrls.forEach ((url)=>{
                this.loadScript(url);
            }) 
        }
    }

    /**
     *异步加载地图JS
     *
     * @private
     * @param {string} url
     * @return {*} 
     * @memberof ZOceanMap
     */
    private loadScript(url: string) {
        return new Promise((resolve, reject) => {
            const script = document.createElement('script');
            script.src = url;
            document.head.appendChild(script);
            script.addEventListener('load', () => {
                resolve(this);
                if((window as any).MapPlatForm){
                    this.initeMap();
                }
            });
            script.addEventListener('error', err => {
                (window as any)._ZVMap._isInit = false;
                reject(err);
            });
        });
    }


    //创建最基本的marker 
    public createMarker() {
        
    }
    public createInfoWindow() {
        // 
    }
    public createLayout() {
        // 
    }
    public trackAnalyze() {
        // 
    }
    public trackPlanning() {
        // 
    }
    public sprinklePoints() {
        // 
    }

    /**
     *设置地图控件
     *
     * @param {Array<string>} strArr
     * @return {*} 
     * @memberof ZOceanMap
     */
    public setControllers(strArr: Array<string>){
        const { ZenMap } = window as any;
        if(!ZenMap ||!strArr || !(strArr.length>0)){
            return;
        }
        strArr.forEach((item)=>{
            let controller;
            switch(item){
                case 'NavigationControl':
                    controller = new ZenMap.Controls.NavigationControl();
                    break;
                case 'ScaleControl':
                    controller = new ZenMap.Controls.ScaleControl();;
                    break;
                case 'CopyRightControl':
                    // controller = new ZenMap.Controls.CopyRightControl(options.copyRight);
                    break;
                case 'MousePositionControl':
                    controller = new ZenMap.Controls.MousePositionControl();
                    break;    
            }
            this.instance.map.addControl(controller);
        })
    }

    /**
     *移除地图控件
     *
     * @param {Array<string>} strArr
     * @return {*} 
     * @memberof ZOceanMap
     */
    public removeController(strArr: Array<string>){
        if(!strArr || !(strArr.length>0)){
            return;
        }
        strArr.forEach((str)=>{
          let controller =   this.instance.map._controls.find((item: { CLASS_NAME: any; }) => item.CLASS_NAME.indexOf(str)!== -1);
          this.instance.map.removeControl(controller);
        })
    }

    /**
     *
     *设置地图工具

     * @param {Array<String>} strArr
     * @return {*} 
     * @memberof ZOceanMap
     */
    public setMapTools(toolArr: Array<any>){
        if(!toolArr || !(toolArr.length>0)){
            return;
        }  
        toolArr.forEach((item)=>{
            let tool;
            switch(item.type){
                case 'select':
                    tool = new SelectTool();
                    break;
                case 'oprations':
                    tool = new OperationTool();
                    break;
                case 'measure':
                    tool = new MeasureTool(this.instance.mapTools, item.container);
                    break;
                case 'layer':
                    tool = new LayerTool();
                    break;
                default :
                    break;
            }
            this. mapTools.push(tool);
        })
    }


    public getMapTools(){
        return this.mapTools;
    }

    public getControllers(){
        return this.controllers;
    }

    
}

export default ZOceanMap;