import DataUtils from '../utils/DataUtils';
import VerifyUtils from '../utils/VerifyUtils';
import LayerProvider from '../geog/LayerProvider';
import GeoJsonProvider from '../geog/GeoJsonProvider';

/**
 * 定义热力图图层
 * @alias HeatmapLayer
 *
 * @summary <用于热力图加载>
 */
 export default class HeatmapLayer {
  /**
   * 构造函数
   * @param {Object} options -图层选项
   */
  constructor(options) {
    // 默认数据源ID
    this._defaultSourceId = 'point_heatmap';
    // 数据源是否存在
    this._hasSource = true;

    /**
     * 地图对象
     * @type {Object}
     */
    this._map = options.map;

    /**
     * 最小缩放层级
     * @type {Number}
     */
    this._minzoom = DataUtils.default(options.minzoom, 10);

    /**
     * 过滤条件数组
     * @type {Array}
     */
    this._filter = DataUtils.default(options.filter, undefined);

    /**
     * 图层服务地址
     * @type {String}
     */
    this._dataUrl = DataUtils.default(options.dataUrl, undefined);

    /**
     * 数据源ID
     * @type {String}
     */
    this._sourceId = DataUtils.default(options.sourceId, this._defaultSourceId);

    /**
     * 图层ID
     * @type {String}
     */
    this._layerId = DataUtils.default(options.layerId, this._sourceId);

    // 数据源要素集
    this._fc = GeoJsonProvider.getEmptyFC();
  }

  /** 公有方法 **/
  /**
   * 设置数据
   * @param {Array|Object|String} data -点数据/图层地址
   */
  /**
   * 设置数据
   * @param {Object|String|Array} data -GeoJSON要素集/查询语句/过滤条件(点位)数组
   *
   * @summary <data参数：
   *   Object - GeoJson要素/要素集
   *   String - cql_filter查询语句
   *   Array - 图层过滤条件数组(如：['==', field, value]) or 点位数组(包含longitude, latitude字段)
   * >
   */
  setData(data) {
    // 加载图层
    if (!this.hasLayer()) {
      this.loadLayer();
    }
    // 隐藏图层
    this.showLayer(false);

    let fc = null;
    if (VerifyUtils.isGeoJsonFC(data)) {
      fc = data;
    } else if (VerifyUtils.isGeoJsonFeature(data)) {
      // GeoJSON要素
      fc = GeoJsonProvider.getEmptyFC();
      fc.features = [data];
    } else if (VerifyUtils.isString(data)) {
      // 图层url
      fc = data;
    } else if (VerifyUtils.isArray(data)) {
      if (data.length > 1 && VerifyUtils.isString(data[0])) {
        // 设置筛选器
        this._map.setFilter(this._layerId, data);
      } else {
        // 数组转GeoJSON对象
        fc = GeoJsonProvider.data2PointFC(data);
      }
    } else if (VerifyUtils.isString(data)) {
      // 查询语句
      if (this._hasSource) {
        const source = this._map.getSource(this._defaultSourceId);
        fc = source._data + (data ? "&cql_filter=" + data : '');
      }
    }

    this._fc.features = [];
    this._fc = fc || GeoJsonProvider.getEmptyFC();

    // 更新数据源
    this._map.getSource(this._sourceId).setData(this._fc);
    // 显示图层
    this.showLayer(true);
  }

  /**
   * 添加数据(只针对接口)
   * @param {Array|Object} data -点数组/GeoJSON要素集
   */
  appendData(data) {
    if (!data) return;

    if (!this._fc || VerifyUtils.isString(this._fc)) {
      this._fc = GeoJsonProvider.getEmptyFC();
    }

    // 要素集必须存在
    if (!VerifyUtils.isGeoJsonFC(this._fc)) return;

    // 要添加的数据必须是GeoJSON要素集、点数组
    if (!(VerifyUtils.isGeoJsonFC(data) || VerifyUtils.isArray(data))) return;

    let fc = null;
    if (VerifyUtils.isGeoJsonFC(data)) {
      fc = data;
    } else if (VerifyUtils.isArray(data)) {
      // 数组转GeoJSON对象
      fc = GeoJsonProvider.data2PointFC(data);
    }
    if (!fc) return;

    // 合并要素列表
    this._fc.features = this._fc.features.concat(fc.features);

    // 更新数据源
    this._map.getSource(this._sourceId).setData(this._fc);
  }

  /**
   * 设置筛选器
   * @param {Array} filter -筛选器
   */
  setFilter(filter) {
    if (!this.hasLayer()) return;

    // 空数组
    if (VerifyUtils.isArray(filter) && filter.length === 0) {
      filter = null;
    }

    let newFilter = null;
    if (this._filter) {
      newFilter = ['all', this._filter];
    }

    if (filter) {
      if (!newFilter) {
        newFilter = filter;
      } else {
        newFilter.push(filter);
      }
    }

    // 设置筛选器
    this._map.setFilter(this._layerId, newFilter);
  }

  /**
   * 加载图层
   */
  loadLayer() {
    if (this.hasLayer()) return;

    const map = this._map;
    const minZoom = this._minzoom;
    const maxZoom = map.getMaxZoom();

    const sourceId = this._sourceId;
    // 判断数据源是否存在
    this._hasSource = LayerProvider.hasSource(map, sourceId);
    if (!this._hasSource) {
      // 添加数据源
      map.addSource(sourceId, {
        type: "geojson",
        data: this._dataUrl || GeoJsonProvider.getEmptyFC()
      });
    }

    // 添加图层
    map.addLayer({
      type: "heatmap",
      id: this._layerId,
      source: sourceId,
      minzoom: minZoom,
      paint: {
        "heatmap-weight": 0.1,
        "heatmap-intensity": [
          "interpolate", ["linear"], ["zoom"],
          minZoom, 1,
          maxZoom, 5
        ],
        "heatmap-color": [
          "interpolate", ["linear"], ["heatmap-density"],
          0, "rgba(255,255,255,0)",
          0.2, "rgb(0,0,255)",
          0.4, "rgb(32,178,170)",
          0.6, "rgb(0,255,0)",
          0.8, "rgb(255,255,0)",
          1, "rgb(255,0,0)"
        ],
        // Adjust the heatmap radius by zoom level
        "heatmap-radius": [
          "interpolate", ["linear"], ["zoom"],
          minZoom, 5,
          maxZoom, 24
        ],
        // Transition from heatmap to circle layer by zoom level
        "heatmap-opacity": [
          "interpolate", ["linear"], ["zoom"],
          minZoom, 1,
          maxZoom, 0.5
        ]
      },
      layout: {
        visibility: "none"
      }
    }, map._build3dLayerId);

    // 筛选器
    if (this._filter) {
      map.setFilter(this._layerId, this._filter);
    }
  }

  /**
   * 显示/隐藏图层
   * @param {Boolean} isShow -是否显示图层
   */
  showLayer(isShow) {
    LayerProvider.showLayer(this._map, this._layerId, isShow);
  }

  /**
   * 判断图层是否已加载
   *
   * @returns {Boolean}
   */
  hasLayer() {
    return LayerProvider.hasLayer(this._map, this._layerId);
  }

  /**
   * 移除图层
   */
  removeLayer() {
    LayerProvider.removeLayer(map, this._layerId);
  }

  /**
   * 移除数据源
   */
  removeSource() {
    LayerProvider.removeSource(this._map, this._sourceId);
  }
}
