import { Renderer } from '../../atomComponent';
import AxisOptionCollector from './axisOptionCollector';
import XAxis from './xAxis';
import YAxis from './yAxis';
import { getId } from '../../utils/signature';
import { AxisOptions, GeneralAxisOptions, SeriesOptions, DataItem } from '../../models'; // FlatDataItem
import { makeMap } from '../../utils/setMap';

type ProcessedData = {
  x: DataItem[];
  y: DataItem[][];
};

// type AxisDataTree = {
//   [key: number]: DataItem[];
// };
export default class Axis implements Renderer {
  public id: string;
  public name: string;
  private xAxis: XAxis;
  private yAxis: YAxis[];
  private xAxisOptions: AxisOptions;
  private yAxisOptions: AxisOptions[];
  private optionCollector: AxisOptionCollector | null = null;
  constructor(public chart, private axisOptions: GeneralAxisOptions) {
    this.id = getId();
    this.name = 'axis';
    this.xAxisOptions = axisOptions?.x;
    this.yAxisOptions = [...axisOptions?.y];

    this.init();
  }

  // options收集器
  public createOptionCollector() {
    if (!this.optionCollector) {
      this.optionCollector = new AxisOptionCollector();
    }
    return this.optionCollector;
  }

  /**
   * axis数据预整合
   */
  dataAdaptor(): ProcessedData {
    const { series, dataset } = this.chart;

    // 单series
    if (dataset.length === 1) {
      return {
        x: dataset[0],
        y: [dataset[0]],
      };
    }

    // 多series时，axis需要整合数据
    if (dataset.length > 1) {
      // x轴
      const xAxisLongestDataLength = Math.max(...dataset.map(item => item.length));
      const xAxisData: DataItem[] = dataset.filter(item => item.length === xAxisLongestDataLength)[0];
      // y轴
      let phantomSeries = series;

      // 堆叠图逻辑单元
      const hasStack = !!series.find(item => item?.stack);
      if (hasStack) {
        const mergedSeriesMap: Object = series
          .reduce((acc, cur) => {
            const { stack } = cur;
            if (stack) {
              return makeMap(acc, stack, cur);
            }
            return makeMap(acc, 'default', cur);
          }, {});
        const yAxisflatSeries: any[] = Object
          .entries(mergedSeriesMap)
          .map((mergedSeries) => {
            const [key, series] = mergedSeries;
            const datas = series.reduce((acc, cur) => [...acc, ...cur?.data], []);
            const { data, ...rest } = series[0];
            // 堆叠图
            const isStack = key !== 'default';
            if (isStack) {
              const mergedSerieMap = datas.reduce((acc, cur) => {
                const { name, ...rest } = cur;
                return makeMap(acc, name, rest);
              }, {});

              const mergedDatas = Object
                .entries(mergedSerieMap)
                .map((mergedSerie: any[]) => {
                  const [name, rests] = mergedSerie;
                  return {
                    name,
                    value: rests.map(item => item?.value).reduce((acc, cur) => acc + cur, 0),
                    isFake: rests[0]?.isFake, // 此处isFake保持结构即可，后续不会依赖
                  };
                });

              return {
                data: mergedDatas,
                ...rest,
              };
            }

            // 非堆叠图
            return series[0];
          }, {});
        phantomSeries = yAxisflatSeries;
      }


      // 多y轴逻辑单元.
      let yAxisDataTree: Object = {}; // AxisDataTree ||
      phantomSeries.forEach((item: SeriesOptions | any) => {
        const { data, yAxisIndex } = item;
        // 多轴数据整合
        if (yAxisIndex && yAxisIndex >= 0) {
          yAxisDataTree = makeMap(yAxisDataTree, yAxisIndex, data);
        } else {
          // 默认数据整合
          yAxisDataTree = makeMap(yAxisDataTree, 0, data);
        }
      });
      const yAxisDatas: DataItem[][] = Object.values(yAxisDataTree) || [];
      return {
        x: xAxisData,
        y: yAxisDatas,
      };
    }
  }

  init() {
    const { chart } = this;
    // 坐标轴data统一格式
    const { x: baseAxisData, y: valueAxisDatas } = this.dataAdaptor();
    const axisdata = {
      baseAxisData,
      valueAxisDatas,
    };

    // 坐标轴options统一格式
    this.optionCollector = this.createOptionCollector();
    this.optionCollector.setXAxisOptions(this.xAxisOptions).setYAxisOptions(this.yAxisOptions);

    this.xAxis = new XAxis(chart, axisdata, this.optionCollector.getXAixsOptions(), 0);
    // FIXME: why use axisCollector?
    // const yAxisOptions = this.optionCollector.getYAixsOptions();
    this.yAxis = this.yAxisOptions.map((item, index) => new YAxis(chart, axisdata, item, index));

    this.xAxisOptions = this.xAxis.options;
    this.yAxisOptions = this.yAxis.map(item => item?.options);
  }

  render() {
    this.xAxis.render();
    this.yAxis.forEach(item => item?.render());
  }
}