import { Feature } from "@turf/helpers";
import { Polygon } from "@turf/turf";

import HPaaSL7 from "../HPaaSL7";
import {
  ICommonOverlayDataOption,
  IOverlayOptions,
  PointOverlayDataWithValue,
  SegmentOverlayData,
} from "./overlay.types";
let overlayUid = 1;
export enum OverlayEventKeys {
  SHOW_TOOLTIP = "show-tooltip",
  HIDE_TOOLTIP = "hide-tooltip",
  CLICK = "CLICK",
}
import EventEmitter from "eventemitter3";
abstract class Overlay<T extends ICommonOverlayDataOption> extends EventEmitter<OverlayEventKeys> {
  // protected scene: Scene;
  protected hpaas: HPaaSL7;
  dataOption: T;
  uid = String(overlayUid++);
  isShow = true;
  commonData: any[] = [];
  constructor(hpaas: HPaaSL7, options: IOverlayOptions<T>) {
    super();
    options
      ? (this.dataOption = options.dataOption)
      : (this.dataOption = {
          name: "",
          color: "#aaa",
          key: "xx",
          filters: [],
          showInPanel: false,
          show: true,
          filterMultiSelect: false,
          type: "point",
          category: "",
          showImagePointText: false,
        } as any);
    this.hpaas = hpaas;
  }
  // 根据 dataoption 对数据进行过滤，用于 filterPanel 控制筛选
  abstract filterDataByDataOption(): void;
  // 渲染数据，供外部调用渲染数据
  abstract renderData(data: any): void;
  // 使用 feature 对数据进行过滤
  abstract filterByFeature(features: Feature<Polygon>[]): void;
  // 通用的数据渲染方法，主要是对数据key进行匹配
  updateCommonData(dataList: { [key: string]: any }[]) {
    const { filterKey, lngKey, latKey, segmentUidKey } = this.dataOption;

    if (
      ["point", "point-cluster", "image-point"].indexOf(this.dataOption.type) !== -1 &&
      lngKey &&
      latKey &&
      filterKey
    ) {
      const renderData: PointOverlayDataWithValue[] = [];
      dataList.forEach((d) => {
        renderData.push({
          lng: d[lngKey],
          lat: d[latKey],
          value: d[filterKey],
          extends: d,
        });
      });
      this.renderData(renderData);
    } else if (["segment-path", "segment"].indexOf(this.dataOption.type) !== -1 && segmentUidKey && filterKey) {
      const renderData: SegmentOverlayData[] = [];
      dataList.forEach((d) => {
        if (this.dataOption.segmentUidFlat) {
          d[segmentUidKey] &&
            d[segmentUidKey].split(",").forEach((element: string) => {
              renderData.push({
                segroad_uid: element,
                extends: d,
                filterValue: d[filterKey],
              });
            });
        } else {
          d[segmentUidKey] &&
            renderData.push({
              segroad_uid: d[segmentUidKey],
              extends: d,
              filterValue: d[filterKey],
            });
        }
      });
      this.renderData(renderData);
    } else if (["segment-od"].indexOf(this.dataOption.type) !== -1 && segmentUidKey && filterKey) {
      const renderData: SegmentOverlayData[][] = [];
      // if (this.dataOption.segmentUidFlat) {
      dataList.forEach((d) => {
        const track: SegmentOverlayData[] = [];

        d[segmentUidKey] &&
          d[segmentUidKey].split(",").forEach((element: string) => {
            track.push({
              segroad_uid: element,
              extends: d,
              filterValue: d[filterKey],
            });
          });
        renderData.push(track);
      });
      // }
      this.renderData(renderData);
    }
  }
  renderCommonData(dataList: any[]) {
    this.commonData = dataList;
    this.updateCommonData(dataList);
  }
}

export default Overlay;