---

import { AxisLine } from '@src/core/Drawings/axisLine';
import { Diapson } from '@src/core/Drawings/diapson';
import { FibonacciRetracement } from '@src/core/Drawings/fibonacciRetracement';
import { LineDrawing } from '@src/core/Drawings/line';
import { ParallelChannel } from '@src/core/Drawings/parallelChannel';
import { Ray } from '@src/core/Drawings/ray';
import { Rectangle } from '@src/core/Drawings/rectangle';
import { RegressionTrend } from '@src/core/Drawings/regressionTrend';
import { Ruler } from '@src/core/Drawings/ruler';
import { SliderPosition } from '@src/core/Drawings/sliderPosition';
import { Text } from '@src/core/Drawings/text';
import { Traectory } from '@src/core/Drawings/traectory';
import { VolumeProfile } from '@src/core/Drawings/volumeProfile';
import { t } from '@src/translations';
import { DrawingConfig, DrawingParams, LineMarker } from '@src/types';

export enum DrawingsNames {
  'trendLine' = 'trendLine',
  'arrow' = 'arrow',
  'parallelChannel' = 'parallelChannel',
  'regressionTrend' = 'regressionTrend',
  'ray' = 'ray',
  'horizontalLine' = 'horizontalLine',
  'horizontalRay' = 'horizontalRay',
  'verticalLine' = 'verticalLine',
  'ruler' = 'ruler',

  'fibonacciRetracement' = 'fibonacciRetracement',

  'sliderLong' = 'sliderLong',
  'sliderShort' = 'sliderShort',
  'diapsonDates' = 'diapsonDates',
  'diapsonPrices' = 'diapsonPrices',
  'fixedRangeProfile' = 'fixedRangeProfile',
  'visibleRangeProfile' = 'visibleRangeProfile',

  'rectangle' = 'rectangle',
  'traectory' = 'traectory',

  'text' = 'text',
}

export const drawingLabelById = (): Record<DrawingsNames, string> => ({
  [DrawingsNames.trendLine]: t('Trend line'),
  [DrawingsNames.arrow]: t('Arrow'),
  [DrawingsNames.parallelChannel]: t('Parallel channel'),
  [DrawingsNames.regressionTrend]: t('Regression trend'),
  [DrawingsNames.ray]: t('Ray'),
  [DrawingsNames.horizontalLine]: t('Horizontal line'),
  [DrawingsNames.horizontalRay]: t('Horizontal ray'),
  [DrawingsNames.verticalLine]: t('Vertical line'),
  [DrawingsNames.fibonacciRetracement]: t('Fibonacci retracement'),
  [DrawingsNames.ruler]: t('Ruler'),
  [DrawingsNames.sliderLong]: t('Long position'),
  [DrawingsNames.sliderShort]: t('Short position'),
  [DrawingsNames.diapsonDates]: t('Dates range'),
  [DrawingsNames.diapsonPrices]: t('Prices range'),
  [DrawingsNames.fixedRangeProfile]: t('Fixed range volume profile'),
  [DrawingsNames.visibleRangeProfile]: t('Anchored volume profile'),
  [DrawingsNames.rectangle]: t('Rectangle'),
  [DrawingsNames.traectory]: t('Traectory'),
  [DrawingsNames.text]: t('Text'),
});

export const drawingsMap: Record<DrawingsNames, DrawingConfig> = {
  [DrawingsNames.trendLine]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new LineDrawing({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.arrow]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new LineDrawing({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
        defaultMarkers: {
          endMarker: LineMarker.arrow,
        },
      });
    },
  },
  [DrawingsNames.parallelChannel]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new ParallelChannel({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.regressionTrend]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new RegressionTrend({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.ray]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new Ray({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.horizontalLine]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new AxisLine({
        ...rest,
        direction: 'horizontal',
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.horizontalRay]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new LineDrawing({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
        defaultMarkers: {
          endMarker: LineMarker.arrow,
        },
      });
    },
  },
  [DrawingsNames.verticalLine]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new AxisLine({
        ...rest,
        direction: 'vertical',
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.sliderLong]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new SliderPosition({
        ...rest,
        side: 'long',
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.fibonacciRetracement]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new FibonacciRetracement({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.sliderShort]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new SliderPosition({
        ...rest,
        side: 'short',
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.diapsonDates]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new Diapson({
        ...rest,
        rangeMode: 'date',
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.diapsonPrices]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new Diapson({
        ...rest,
        rangeMode: 'price',
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.fixedRangeProfile]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new VolumeProfile({
        ...rest,
        profileKind: 'fixedRange',
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.visibleRangeProfile]: {
    singleInstance: true,
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new VolumeProfile({
        ...rest,
        profileKind: 'visibleRange',
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.rectangle]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new Rectangle({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.ruler]: {
    singleInstance: true,
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new Ruler({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
        resetTriggers: [eventManager.getTimeframeObs(), eventManager.getInterval()],
      });
    },
  },
  [DrawingsNames.traectory]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new Traectory({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
  [DrawingsNames.text]: {
    construct: (params: DrawingParams) => {
      const { eventManager, ...rest } = params;

      return new Text({
        ...rest,
        formatObservable: eventManager.getChartOptionsModel(),
      });
    },
  },
};