    import { VectorTileLayer } from '../baseLayer'
    import { LayerEventType, LayerType, LoadStatus } from '../../../base/enum'
    import { Zondy } from '../../../base'
    import { defaultValue, defined, isNull, Log } from '../../../util'
    import { VectorTileServer } from '../../../service'
    import { Extent, Point, SpatialReference } from '../../../base/geometry'
    import IGSVectorTileSubLayer from './IGSVectorTileSubLayer'
    import { LayerViewUpdateEvent } from '../../../base/event'
    import TileInfoUtil from '../support/TileInfoUtil'

    /**
     * IGS矢量瓦片图层
     * 支持IGS1.0和2.0两个服务版本，目前二维和三维上支持4326(包括4490，4214以及4610)，3857，会自动读取元信息上的坐标系，不需要用户指定，
     * <br><br>[ES5引入方式]：<br/>
     * Zondy.Layer.IGSVectorTileLayer() <br/>
     * [ES6引入方式]：<br/>
     * import { IGSVectorTileLayer } from "@mapgis/webclient-common" <br/>
     * <br/>
     * 针对图层的操作请在图层加载完毕事件中进行<br/>
     * Layer.on('layerview-created', function (result) {<br/>
     *   console.log("加载完毕:", result.layer)<br/>
     * });<br/>
     * 如果不想在该事件中放入业务代码，则请确认图层资源以加载完毕后再进行操作<br/>
     * if(layer.loadStatus === 'loaded') {<br/>
     *   // 你的业务逻辑<br/>
     * }
     * <br/>
     * <br/>
     * 注意:三维上,不支持简单Marker样式设定;二维上,简单Marker的颜色,外边线样式,旋转角度无法在图层初始化和初始化后修改,须在制作数据时进行指定
     * @class IGSVectorTileLayer
     * @moduleEX LayerManagerModule
     * @classdesc IGS矢量瓦片图层
     * @extends VectorTileLayer
     * @fires Layer#图层加载完毕事件
     * @fires Layer#图层销毁完毕事件
     * @fires Layer#图层更新完毕事件
     * @fires Layer#图层显隐更新完毕事件
     * @fires Layer#图层透明度更新完毕事件
     * @param {Object} options 构造参数
     * @param {String} [options.url] 服务基地址,<br>
     * IGS1.0的服务为：http://{ip}:6163/igs/rest/mrms/tiles/{serviceName}，参考示例：<a href='#igs-1'>[IGS1.0的矢量瓦片示例]</a><br/>
     * IGS2.0的服务为：http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer，参考示例：<a href='#igs-2'>[IGS2.0的矢量瓦片示例]</a><br/>
     * 删除图层方法：<a href='#remove-layer'>[删除图层]</a>
     * @param {Number} [options.minScale = null] 最小比例尺，只有当地图视图的比例尺大于最小比例尺时显示矢量瓦片图层
     * @param {Number} [options.maxScale = null] 最大比例尺，只有当地图视图的比例尺小于最大比例尺时显示矢量瓦片图层
     * @param {Number} [options.opacity = 1] 图层透明度，0到1之间的值，0为完全透明，1为不透明，参考示例：<a href='#opacity'>[设置图层透明度]</a>
     * @param {String} [options.tokenKey = 'token'] token名
     * @param {String} [options.tokenValue] token值，只有当tokenValue存在时，才会绑定token
     * @param {Boolean} [options.visible = true] 图层显示或隐藏，true则显示，false则隐藏，参考示例：<a href='#visible'>[设置图层显隐]</a>
     * @param {Array<IGSVectorTileSubLayer>} [options.sublayers=[]] 子图层信息。指定的和服务器端获取图层的交集, 默认不设置,加载全部图层。可设置子图层的可见性，以及专题图参数。<br/>
     * @param {Object} [options.currentStyle] 矢量瓦片当前样式
     * @param {String} [option.labelsRenderMode = 'off-screen'] 指定矢量瓦片注记的渲染模式,仅在三维上有效。on-screen表示使用三维接口实时渲染注记；off-screen表示通过先将注记渲染到图片上，再通过三维接口渲染到屏幕。
     * 专题图参数仅支持IGS2.0服务，目前子图层支持的专题图如下：<br/>
     * [1、单值专题图]{@link UniqueValueRenderer}<br/>
     * [2、分段专题图]{@link ClassBreakRenderer}<br/>
     * [3、统一专题图]{@link SimpleRenderer}<br/>
     * 参考示例：<br/>
     * <a href='#showAllSubLayers'>[1、显示所有子图层]</a><br/>
     * <a href='#showSubLayersById'>[2、根据id显示子图层]</a><br/>
     * <a href='#showSubLayers-property'>[3、通过修改子图参数，设置子图层显隐]</a><br/>
     * <a href='#setLayerRenderer-unique'>[4、设置子图层专题图-单值专题图]</a><br/>
     * <a href='#setLayerRenderer-break'>[5、设置子图层专题图-分段专题图]</a><br/>
     * <a href='#setLayerRenderer-simple'>[6、设置子图层专题图-统一专题图]</a><br/>
     * <a href='#setLayerRenderer-property'>[7、通过修改子图参数，设置子图层专题图]</a><br/>
     *
     *@summary <h5>支持如下方法：</h5>
     * <a href='#findSublayerById'>[1、根据子图层id查询图层]</a><br/>
     * <a href='#loadStyle'>[2、获取矢量瓦片样式]</a><br/>
     * <a href='#fromJSON'>[3、通过传入的json构造并返回一个新的几何对象]</a><br/>
     * [4、导出为json对象]{@link OGCLayer#toJSON}<br/>
     * [5、克隆几何对象]{@link OGCLayer#clone}
     *
     * @example <caption><h7 id='igs-1'>IGS1.0的矢量瓦片示例</h7></caption>
     * //初始化地图管理容器
     * // ES5引入方式
     * const { IGSVectorTileLayer } = Zondy.Layer
     * const { Map,MapView } = Zondy
     * // ES6引入方式
     * import { IGSVectorTileLayer,Map,MapView } from "@mapgis/webclient-common"
     * const map = new Map();
     * //初始化地图引擎
     * const mapView = new MapView({
     *   //指定视图id
     *   viewId: "viewer-id",
     *   //绑定地图管理容器
     *   map: map
     * });
     * //添加矢量瓦片图层
     * const igsVectorTileLayer = new IGSVectorTileLayer({
     *   url: 'http://{ip}:6163/igs/rest/mrms/tiles/{serviceName}'
     * });
     * map.add(igsVectorTileLayer);
     *
     * @example <caption><h7 id='igs-2'>IGS2.0的矢量瓦片示例</h7></caption>
     *  // ES5引入方式
     * const { IGSVectorTileLayer } = Zondy.Layer
     * const { Map,MapView } = Zondy
     * // ES6引入方式
     * import { IGSVectorTileLayer } from "@mapgis/webclient-common"
     * //初始化地图管理容器
     * const map = new Map();
     * //初始化地图引擎
     * const mapView = new MapView({
     *   //指定视图id
     *   viewId: "viewer-id",
     *   //绑定地图管理容器
     *   map: map
     * });
     * //添加矢量瓦片图层
     * const igsVectorTileLayer = new IGSVectorTileLayer({
     *   url: 'http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer'
     * });
     * map.add(igsVectorTileLayer);
     *
     * @example <caption><h7 id='opacity'>设置图层透明度</h7></caption>
     * igsVectorTileLayer.opacity = 0.5
     *
     * @example <caption><h7 id='visible'>显示或隐藏图层</h7></caption>
     * igsVectorTileLayer.visible = !igsVectorTileLayer.visible
     *
     * @example <caption><h7 id='remove-layer'>删除图层</h7></caption>
     * map.remove(igsVectorTileLayer)
     *
     * @example <caption><h7 id='showAllSubLayers'>显示所有子图层</h7></caption>
     *  // ES5引入方式
     * const { IGSVectorTileLayer } = Zondy.Layer
     * // ES6引入方式
     * import { IGSVectorTileLayer } from "@mapgis/webclient-common"
     * // 添加图层
     * const igsVectorTileLayer = new IGSVectorTileLayer({
     *   // 服务基地址
     *   url: 'http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer',
     *   //默认不设置sublayers,加载全部图层
     * });
     * map.add(igsVectorTileLayer);
     *
     * @example <caption><h7 id='showSubLayersById'>根据id显示子图层</h7></caption>
     * // ES5引入方式
     * const { IGSVectorTileLayer } = Zondy.Layer
     * // ES6引入方式
     * import { IGSVectorTileLayer } from "@mapgis/webclient-common"
     * // 添加图层
     * const igsVectorTileLayer = new IGSVectorTileLayer({
     *   // 服务基地址
     *   url: 'http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer',
     *   // 根据id显示子图层
     *   sublayers: [
     *      {
     *        // 子图层id
     *        id: '子图层id',
     *        // 显示子图层
     *        visible: true
     *      }
     *    ]
     * });
     * map.add(igsVectorTileLayer);
     *
     * @example <caption><h7 id='showSubLayers-property'>通过修改子图参数，设置子图层显隐</h7></caption>
     * // ES5引入方式
     * const { IGSVectorTileLayer } = Zondy.Layer
     * // ES6引入方式
     * import { IGSVectorTileLayer } from "@mapgis/webclient-common"
     * // 添加图层
     * const igsVectorTileLayer = new IGSVectorTileLayer({
     *   // 服务基地址
     *   url: 'http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer'
     * });
     * map.add(igsVectorTileLayer);
     * igsVectorTileLayer.on('layerview-created', function (result) {
     *   console.log("加载完毕:", result.layer)
     *   // 根据id获取子图层
     *   const subLayer = igsVectorTileLayer.findSublayerById('图层id')
     *   // 设置子图层显隐
     *   subLayer.visible = false
     *   // 视点跳转
     *   sceneView.flyTo({
     *     extent: result.layer.extent
     *   })
     * })
     *
     * @example <caption><h7 id='setLayerRenderer-unique'>设置子图层专题图-单值专题图</h7></caption>
     * // ES5引入方式
     * const { IGSVectorTileLayer } = Zondy.Layer
     * const { UniqueValueRenderer } = Zondy.Renderer
     * const { SimpleFillSymbol,SimpleLineSymbol } = Zondy.Symbol
     * const { Color } = Zondy
     * // ES6引入方式
     * import { IGSVectorTileLayer,UniqueValueRenderer ,SimpleFillSymbol,SimpleLineSymbol,Color} from "@mapgis/webclient-common"
     * const igsVectorTileLayer = new IGSVectorTileLayer({
     *   // 服务基地址,当不指定图层名称时,默认查询第一个子图层
     *   url: 'http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer',
     *   // 设置子图层专题图
     *   sublayers: [
     *      {
     *        // 子图层id
     *        id: '子图层id',
     *        // 设置渲染样式-单值专题图
     *        renderer: new UniqueValueRenderer({
     *          //专题图过滤字段名
     *          field: '你的字段名',
     *          // 默认样式,当没有匹配到指定值时,会使用默认样式
     *          //因为该数据的几何类型为区,因此设置区样式
     *          defaultSymbol: new SimpleFillSymbol({
     *            // 填充颜色
     *            color: 'rgba(1,1,252,0)',
     *            // 外边线样式
     *            outline: new SimpleLineSymbol({
     *              //线颜色
     *              color: new Color(255, 1, 0, 1),
     *              //线宽
     *              width: 1
     *            })
     *          }),
     *          //单值专题图过滤调条件数组
     *          uniqueValueInfos: [{
     *            //指定字段值
     *            value: "指定的值",
     *            //匹配到该值后的样式
     *            //因为该数据的几何类型为区,因此设置区样式
     *            symbol: new SimpleFillSymbol({
     *              // 填充颜色
     *              color: 'rgba(1,1,252,1)',
     *              // 外边线样式
     *              outline: new SimpleLineSymbol({
     *                //线符号颜色
     *                color: new Color(255, 1, 0, 11),
     *                //线宽
     *                width: 1
     *                })
     *              })
     *            },{
     *              //指定字段值
     *              value: "指定的值",
     *              //匹配到该值后的样式
     *              //因为该数据的几何类型为区,因此设置区样式
     *              symbol: new SimpleFillSymbol({
     *                // 填充颜色
     *                color: new Color(211, 111, 11, 1)
     *              })
     *            }]
     *        })
     *      }
     *   ]
     * });
     * map.add(igsVectorTileLayer);
     *
     * @example <caption><h7 id='setLayerRenderer-break'>设置子图层专题图-分段专题图</h7></caption>
     * // ES5引入方式
     * const { IGSVectorTileLayer } = Zondy.Layer
     * const { ClassBreakRenderer } = Zondy.Renderer
     * const { SimpleFillSymbol,SimpleLineSymbol } = Zondy.Symbol
     * const { Color } = Zondy
     * // ES6引入方式
     * import { IGSVectorTileLayer,ClassBreakRenderer ,SimpleFillSymbol,SimpleLineSymbol,Color} from "@mapgis/webclient-commo
     * const igsVectorTileLayer = new IGSVectorTileLayer({
     *   // 服务基地址,当不指定图层名称时,默认查询第一个子图层
     *   url: 'http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer',
     *   // 设置子图层专题图
     *   sublayers: [
     *     {
     *      // 子图层id
     *      id: '子图层id',
     *      // 设置渲染样式-分段专题图
     *      renderer: new ClassBreakRenderer({
     *        //专题图过滤字段名
     *        field: '你的字段名',
     *        // 默认样式,当没有匹配到指定值时,会使用默认样式
     *        // 因为该数据的几何类型为区,因此设置区样式
     *        defaultSymbol:  new SimpleFillSymbol({
     *          // 填充颜色
     *          color: 'rgba(222,1,252,1)',
     *          // 线符号样式
     *          outline: new SimpleLineSymbol({
     *            //线符号颜色
     *            color: new Color(255, 1, 0, 1),
     *            //线宽
     *            width: 1
     *          })
     *        }),
     *        //分段专题图过滤条件数组
     *        classBreakInfos: [{
     *          // 最大过滤范围,field对应的值小于maxValue
     *          maxValue: "最大范围",
     *          // 最小过滤范围,field对应的值大于等于minValue
     *          minValue: "最小范围",
     *          // 匹配到该值后的样式
     *          // 因为该数据的几何类型为区,因此设置区样式
     *          symbol:  new SimpleFillSymbol({
     *            // 填充颜色
     *            color: 'rgba(1,1,252,1)',
     *            // 线符号样式
     *            outline: new SimpleLineSymbol({
     *              //线符号颜色
     *              color: new Color(255, 1, 0, 1),
     *              //线宽
     *              width: 1
     *            })
     *          })
     *        }]
     *      })
     *    }
     *  ]
     * });
     * map.add(igsVectorTileLayer);
     *
     * @example <caption><h7 id='setLayerRenderer-property'>通过修改子图参数，设置子图层专题图</h7></caption>
     * // ES5引入方式
     * const { IGSVectorTileLayer } = Zondy.Layer
     * const { ClassBreakRenderer } = Zondy.Renderer
     * const { SimpleFillSymbol,SimpleLineSymbol } = Zondy.Symbol
     * const { Color } = Zondy
     * // ES6引入方式
     * import { IGSVectorTileLayer,ClassBreakRenderer ,SimpleFillSymbol,SimpleLineSymbol,Color} from "@mapgis/webclient-commo
     * const igsVectorTileLayer = new IGSVectorTileLayer({
     *   // 服务基地址
     *   url: 'http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer'
     * });
     * map.add(igsVectorTileLayer);
     * // 根据id获取子图层
     * const subLayer = igsVectorTileLayer.findSublayerById('子图层id')
     * // 设置渲染样式-分段专题图
     * subLayer.renderer = new ClassBreakRenderer({
     *     // 专题图过滤字段名
     *     field: '你的字段名',
     *     // 默认样式,当没有匹配到指定值时,会使用默认样式
     *     // 因为该数据的几何类型为区,因此设置区样式
     *     defaultSymbol:  new SimpleFillSymbol({
     *       // 填充颜色
     *       color: 'rgba(222,1,252,1)',
     *       // 线符号样式
     *       outline: new SimpleLineSymbol({
     *         //线符号颜色
     *         color: new Color(255, 1, 0, 1),
     *         //线宽
     *         width: 1
     *       })
     *     }),
     *     //分段专题图过滤条件数组
     *     classBreakInfos: [{
     *       // 最大过滤范围,field对应的值小于maxValue
     *       maxValue: "最大范围",
     *       // 最小过滤范围,field对应的值大于等于minValue
     *       minValue: "最小范围",
     *       // 匹配到该值后的样式
     *       // 因为该数据的几何类型为区,因此设置区样式
     *       symbol:  new SimpleFillSymbol({
     *         // 填充颜色
     *         color: 'rgba(1,1,252,1)',
     *         // 线符号样式
     *         outline: new SimpleLineSymbol({
     *           //线符号颜色
     *           color: new Color(255, 1, 0, 1),
     *           //线宽
     *           width: 1
     *         })
     *       })
     *     }]
     *   })
     * @example <caption><h7 id='setLayerRenderer-simple'>统一专题图</h7></caption>
     * // ES5引入方式
     * const { IGSVectorTileLayer } = Zondy.Layer
     * const { SimpleRenderer } = Zondy.Renderer
     * const { SimpleFillSymbol,SimpleLineSymbol } = Zondy.Symbol
     * const { Color } = Zondy
     * // ES6引入方式
     * import { IGSVectorTileLayer,SimpleRenderer ,SimpleFillSymbol,SimpleLineSymbol,Color} from "@mapgis/webclient-commo
     * const igsVectorTileLayer = new IGSVectorTileLayer({
     *   // 服务基地址，当不指定图层名称时，默认查询第一个子图层
     *   url: 'http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer',
     *   // 设置渲染样式-统一专题图
     *   renderer: new SimpleRenderer({
     *     // 因为该数据的几何类型为区，因此设置区样式
     *     symbol: new SimpleFillSymbol({
     *       // 填充颜色
     *       color: new Zondy.Color(255, 0, 0),
     *       // 外边线样式
     *       outline: new SimpleLineSymbol({
     *         // 线颜色
     *         color: new Color(0, 0, 0),
     *         // 线宽度
     *         width: 1
     *       })
     *     })
     *   })
     * })
     */

    class IGSVectorTileLayer extends VectorTileLayer {
      constructor(options) {
        super(options)
        options = defaultValue(options, {})
        this.type = LayerType.igsVectorTile
        this.description = 'IGS矢量瓦片图层'
        this.vectorTileType = 'igs'
        /**
         * 矢量瓦片服务地址
         * @member {String} IGSVectorTileLayer.prototype.url
         */
        this.url = defaultValue(options.url, '')
        /**
         * 矢量瓦片当前样式
         * @member {Object} IGSVectorTileLayer.prototype.currentStyle
         */
        this.currentStyle = defaultValue(options.currentStyle, {})
        /**
         * 矢量瓦片样式列表
         * @member {Array<Object>} IGSVectorTileLayer.prototype.styleList
         */
        this.styleList = defaultValue(options.styleList, [])
        /**
         * 矢量瓦片子图层
         * @member {Array<IGSVectorTileSubLayer>} IGSVectorTileLayer.prototype.sublayers
         */
        this.sublayers = defaultValue(options.sublayers, [])
        /**
         * 服务支持的能力
         * @member {Array<String>} IGSVectorTileLayer.prototype.capabilities
         */
        this.capabilities = []

        /**
         * 图层加载状态
         * @readonly
         * @default not-loaded
         * @member {LoadStatus} IGSMapImageLayer.prototype.loadStatus
         */
        this.loadStatus = LoadStatus.notLoaded
        /**
         * 指定矢量瓦片注记的渲染模式(目前仅支持三维上矢量瓦片注记的渲染)
         * @member {String} IGSVectorTileLayer.prototype.labelsRenderMode
         */
        this.labelsRenderMode = defaultValue(options.labelsRenderMode, 'off-screen')
        // 测试接口
        this.labelingInfo = defaultValue(options.labelingInfo, [])
        // 矢量瓦片服务
        this._vectorTileServer = new VectorTileServer({
          url: this.url
        })
        // 所有图层
        this._allSublayers = []
      }

      load() {
        // 发起请求
        const self = this
        const promise = this._vectorTileServer.queryServerInfo()

        return promise
          .then((result) => {
            Log.info('矢量瓦片信息查询成功:', result)
            const data = result.data

            if (data.spatialReference && !self._spatialReference) {
              if (data.spatialReference.wkid) {
                self._spatialReference = new SpatialReference({
                  wkt: data.spatialReference.name,
                  wkid: parseInt(data.spatialReference.wkid)
                })
              } else {
                Log.error(
                  '矢量瓦片服务坐标系信息不存在，请检查igs返回的矢量瓦片服务元信息！'
                )
              }
            }

            // 获取瓦片信息
            self.tileInfo = TileInfoUtil.parseTileInfo2(data.tileInfo)
            // 解析TileInfo
            if (self.tileInfo) {
              if (
                !self._spatialReference &&
                data.tileInfo.spatialReference &&
                data.tileInfo.spatialReference.wkid
              ) {
                self._spatialReference = new SpatialReference({
                  wkt: data.tileInfo.spatialReference.name,
                  wkid: parseInt(data.tileInfo.spatialReference.wkid)
                })
              }
            }

            // 支持mapbox加载矢量瓦片
            if (self._spatialReference) {
              const tileSize = self.tileInfo.tileSize || 256
              const cols = self.tileInfo.cols || 256
              const rols = self.tileInfo.rols || 256
              self._spatialReference._mapboxTileSize = Math.max(
                tileSize,
                cols,
                rols
              )
            }

            if (isNull(self.extent) && data.extent) {
              self.extent = new Extent({
                xmin: data.extent.xmin,
                ymin: data.extent.ymin,
                xmax: data.extent.xmax,
                ymax: data.extent.ymax,
                spatialReference: self._spatialReference
              })
            }

            // 判断是否为地理坐标系
            if (
              self._spatialReference &&
              [4326, 4490, 4610, 4214].indexOf(self._spatialReference.wkid) > -1
            ) {
              self._spatialReference.extent = new Extent({
                xmin: -180,
                ymin: -90,
                xmax: 180,
                ymax: 90
              })
            }

            // 解析服务器提供的能力
            if (data.capabilities) {
              self.capabilities = Array.isArray(data.capabilities)
                ? data.capabilities
                : [data.capabilities]
            }

            return self._vectorTileServer
              .getStyle()
              .then((result) => {
                Log.info('矢量瓦片样式查询成功:', result)
                // 获取矢量瓦片样式信息
                self.currentStyle = result.data
                // 获取所有子图层
                const layers = self.currentStyle.layers
                const sublayers = []
                // 初始化图层
                if (Array.isArray(self.sublayers) && self.sublayers.length > 0) {
                  self.sublayers.forEach((sublayer) => {
                    for (let i = 0; i < layers.length; i++) {
                      const layerInfo = layers[i]
                      if (layerInfo.id === sublayer.id) {
                        const subLayer = new IGSVectorTileSubLayer(
                          // eslint-disable-next-line prefer-object-spread
                          Object.assign(
                            {
                              type: layerInfo.type,
                              id: layerInfo.id,
                              title: layerInfo.description,
                              style: layerInfo,
                              visible: undefined,
                              minZoom: layerInfo.minZoom,
                              maxZoom: layerInfo.maxZoom,
                              sublayers: [],
                              layer: self
                            },
                            sublayer
                          )
                        )
                        sublayers.push(subLayer)
                      }
                    }
                  })
                } else {
                  for (let i = 0; i < layers.length; i++) {
                    const layerInfo = layers[i]
                    const subLayer = new IGSVectorTileSubLayer({
                      type: layerInfo.type,
                      id: layerInfo.id,
                      title: layerInfo.description,
                      style: layerInfo,
                      visible: undefined,
                      minZoom: layerInfo.minZoom,
                      maxZoom: layerInfo.maxZoom,
                      sublayers: [],
                      layer: self
                    })
                    sublayers.push(subLayer)
                  }
                }

                self.sublayers = sublayers

                return new Promise((resolve) => {
                  self.loadStatus = LoadStatus.loaded
                  self.loaded = true
                  resolve(self)
                })
              })
              .catch((result) => {
                Log.error('矢量瓦片样式查询失败:', result)
              })
          })
          .catch((result) => {
            Log.error('矢量瓦片信息查询失败:', result)
          })
      }

      get allSublayers() {
        if (this._allSublayers.length === 0) {
          this.sublayers.forEach((element) => {
            this._getSubLayers(element, this._allSublayers)
          })
        }
        return this._allSublayers
      }

      get style() {
        const style = JSON.parse(JSON.stringify(this.currentStyle))
        // 设置图层样式
        style.layers = this.sublayers.map((v) =>
          JSON.parse(JSON.stringify(v.style))
        )
        return style
      }

      /**
       * 获取矢量瓦片子图层
       * @private
       * @param {IGSVectorTileSubLayer} subLayer 子图层
       * @param {Array<IGSVectorTileSubLayer>} 矢量瓦片子图层数组
       */
      _getSubLayers(subLayer, sublayers) {
        sublayers.push(subLayer)
        if (subLayer.sublayers && subLayer.sublayers.length > 0) {
          subLayer.sublayers.forEach((element) => {
            this._getSubLayers(element, sublayers)
          })
        }
      }

      /**
       * @description 根据子图层id查询图层
       * @param {String} sublayerID 图层ID
       * @return {IGSVectorTileSubLayer} 子图层
       * @example <caption><h7 id='findSublayerById'>根据子图层id查询图层</h7></caption>
       * // ES5引入方式
       * const { IGSVectorTileLayer } = Zondy.Layer
       * // ES6引入方式
       * import { IGSVectorTileLayer} from "@mapgis/webclient-common"
       * const igsVectorTileLayer = new IGSVectorTileLayer({
       *   // 服务基地址
       *   url: 'http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer'
       * });
       * map.add(igsVectorTileLayer);
       * // 根据id获取子图层
       * const subLayer = igsVectorTileLayer.findSublayerById('子图层id')
       */
      findSublayerById(sublayerID) {
        for (let i = 0; i < this.allSublayers.length; i++) {
          if (this.allSublayers[i].id === sublayerID) {
            return this.allSublayers[i]
          }
        }
        return null
      }

      /**
       * 发送图层更新事件
       * @private
       * @param {Array<LayerViewUpdateContent>} 更新内容
       * @fires IGSVectorTileLayer#图层样式更新事件
       */
      _fireLayerUpdateEvent(updateContent) {
        if (!this._map) return
        this._map.fire(
          LayerEventType.layerUpdate,
          new LayerViewUpdateEvent({
            type: LayerEventType.layerUpdate,
            target: this._map,
            layer: this,
            message: '',
            updateContent
          })
        )
      }

      /**
       * 设置图层最大最小层级
       * @private
       * @fires IGSVectorTileLayer#图层样式更新事件
       */
      setLayerZoomRange() {
        this._fireLayerUpdateEvent([
          {
            params: arguments,
            dataChanged: true,
            name: 'setLayerZoomRange',
            operationType: 'method'
          }
        ])
      }

      /**
       * 设置布局属性
       * @private
       * @fires IGSVectorTileLayer#图层样式更新事件
       */
      setLayoutProperty() {
        this._fireLayerUpdateEvent([
          {
            params: arguments,
            dataChanged: true,
            name: 'setLayoutProperty',
            operationType: 'method'
          }
        ])
      }

      /**
       * 设置画笔属性
       * @private
       * @fires IGSVectorTileLayer#图层样式更新事件
       */
      setPaintProperty() {
        this._fireLayerUpdateEvent([
          {
            params: arguments,
            dataChanged: true,
            name: 'setPaintProperty',
            operationType: 'method'
          }
        ])
      }

      /**
       * 设置画笔属性(对象形式)，考虑样式并行问题
       * @private
       * @fires IGSVectorTileLayer#图层样式更新事件
       */
      setPaintPropertys() {
        this._fireLayerUpdateEvent([
          {
            params: arguments,
            dataChanged: true,
            name: 'setPaintPropertys',
            operationType: 'method'
          }
        ])
      }

      /**
       * 设置布局属性(对象形式)，考虑样式并行问题
       * @private
       * @fires IGSVectorTileLayer#图层样式更新事件
       */
      setLayoutPropertys() {
        this._fireLayerUpdateEvent([
          {
            params: arguments,
            dataChanged: true,
            name: 'setLayoutPropertys',
            operationType: 'method'
          }
        ])
      }

      /**
       * 属性过滤
       * @private
       * @param {String} layerId 图层ID
       * @param {Array} filter 过滤条件数组
       */
      setFilter() {
        this._fireLayerUpdateEvent([
          {
            params: arguments,
            dataChanged: true,
            name: 'setFilter',
            operationType: 'method'
          }
        ])
      }

      destroy() {}

      /**
       * 获取矢量瓦片样式
       * @return {Promise<Object>} 返回mvtStyle
       * @example <caption><h7 id='loadStyle'>获取矢量瓦片样式</h7></caption>
       * // ES5引入方式
       * const { IGSVectorTileLayer } = Zondy.Layer
       * // ES6引入方式
       * import { IGSVectorTileLayer} from "@mapgis/webclient-common"
       * const igsVectorTileLayer = new IGSVectorTileLayer.({
       *   // 服务基地址
       *   url: 'http://{ip}:{port}/igs/rest/services/VectorTile/{serviceName}/VectorTileServer'
       * });
       * const style=igsVectorTileLayer.loadStyle()
       */
      loadStyle() {
        return this._vectorTileServer.getStyle().then((res) => res.data)
      }

      /**
       * 通过传入的json构造并返回一个新的几何对象<a id='fromJSON'></a>
       * @param {Object} [json] JSON对象
       * @example <caption><h7>通过传入的json构造并返回一个新的几何对象</h7></caption>
       * // ES5引入方式
       * const { IGSVectorTileLayer } = Zondy.Layer
       * // ES6引入方式
       * import { IGSVectorTileLayer } from "@mapgis/webclient-common"
       * const json = {
       *   // 服务基地址
       *   url: 'http://{ip}:{port}/igs/rest/services/Tile/{serviceName}/TileServer'
       * }
       * const igsVectorTileLayer = new IGSVectorTileLayer.fromJSON(json)
       */
      static fromJSON(json) {
        json = defaultValue(json, {})
        return new IGSVectorTileLayer(json)
      }
    }

    Zondy.Layer.IGSVectorTileLayer = IGSVectorTileLayer
    export default IGSVectorTileLayer