import AtomComponent from '../../atomComponent';
import { MarkLineOptions, MarkLineDataItem, FormattedLineData } from '../../models';
import { merge } from '../../utils';
import { SeriesCategory } from '../../constants';
import { GlobalData } from '@constants/globalData';

const name = 'markline';
export default class MarkLine extends AtomComponent {
  private static readonly defaultOptions: MarkLineOptions = {
    data: [],
  };
  protected seriesCategory = SeriesCategory.NONE;
  private marklineOptions: MarkLineOptions;

  constructor(chart, options: MarkLineOptions) {
    super({ name, chart });
    this.marklineOptions = this.processOptions(options, MarkLine.defaultOptions);
  }

  render() {
    const { marklineOptions } = this;
    if (!marklineOptions) return;

    this.drawMarkLine();
  }


  private drawMarkLine() {
    const {
      chart,
      canvas: { size },
      marklineOptions,
    } = this;

    // 格式化数据
    const { axisSourceData, axisType } = chart?.getGlobalData(GlobalData.BaseAxis4MarkLine); // baseAxis数据
    const markLineDatas = (marklineOptions?.data as MarkLineDataItem[]) || []; // markline数据

    // 对齐baseAxis坐标
    const formattedLineData = markLineDatas
      .map((markLineData) => {
        const { xAxis, yAxis, lineStyle } = markLineData;
        if (xAxis) {
          const hitData = axisSourceData.find((item) => {
            let isHit = false;

            switch (axisType) {
              case 'time':
              {
                // 时间轴(axis.type === time)模糊匹配
                const timestapmIn10 = Math.floor(+item.value / 1000);
                const timestapmIn10forMarkline = Math.floor(+markLineData.xAxis / 1000);
                isHit =  timestapmIn10 === timestapmIn10forMarkline;
                break;
              }
              case 'category':
                // 类型轴（axis.type === category）精确匹配
                isHit = item.value === markLineData.xAxis;
              default:
                break;
            }
            return isHit;
          });
          if (!hitData) return null;

          const { x } = hitData;
          return {
            x1: x,
            y1: 0,
            x2: x,
            y2: size.height,
            color: lineStyle.color,
          };
        }
        if (yAxis) {
          const hitData = axisSourceData.find(item => item.value === markLineData.yAxis);
          if (!hitData) return null;

          const { y } = hitData;
          return {
            x1: 0,
            y1: y,
            x2: size.width,
            y2: y,
            color: lineStyle.color,
          };
        }
        return null;
      })
      .filter(item => item);

    // 绘制线条
    formattedLineData.forEach((lineData: FormattedLineData) => {
      const { x1, y1, x2, y2, color } = lineData;

      this.painter.draw('Line', {
        x1,
        y1,
        x2,
        y2,
        strokeStyle: color,
        type: 'dashed',
      });
    });
  }

  private processOptions(userOptions, defaultOptions) {
    const options = merge(defaultOptions, userOptions);
    return options;
  }
}