---

import { BehaviorSubject, combineLatest, map, Observable, Subscription } from 'rxjs';

import { ChartOptionsModel, ChartSeriesType, Intervals, TimeFormat } from '@src/types';

import { Defaults } from '@src/types/defaults';
import { Timeframes } from '@src/types/timeframes';
import { DateFormat, getTimeframeByInterval, shouldShowTime } from '@src/utils';

import { ChartSettings, ChartSettingsSource, parseChartSettings } from './ChartSettings';
import { UndoKey, UndoRedo } from './UndoRedo';

interface EventManagerParams {
  initialTimeframe: Timeframes;
  initialSeries: ChartSeriesType;
  initialSymbol: string;
  initialSymbolName?: string;
  initialSymbolTicker?: string;
  initialTimeFormat?: TimeFormat;
  initialDateFormat?: DateFormat;
  initialInterval?: Intervals | null;
}

interface SetWithHistoryOptions {
  history?: boolean;
}

/**
 * Менеджер (настроек)*, которые меняются во время использование
 * Отвечает за централизованное управление (настроек)
 * * имеются в виду настройки, которые пользователь применяет к графику
 */
export class EventManager {
  private timeframe$: BehaviorSubject<Timeframes>;
  private seriesSelected$: BehaviorSubject<ChartSeriesType>;
  private symbol$: BehaviorSubject<string>;
  private symbolName$: BehaviorSubject<string>;
  private symbolTicker$: BehaviorSubject<string>;
  private timeFormat$: BehaviorSubject<TimeFormat>;
  private dateFormat$: BehaviorSubject<DateFormat>;
  private interval$: BehaviorSubject<Intervals | null>;

  private controlBarVisible$ = new BehaviorSubject<boolean>(false); // todo: move to render

  private undoRedo: UndoRedo;

  constructor({
    initialTimeframe,
    initialSeries,
    initialSymbol,
    initialSymbolName,
    initialSymbolTicker,
    initialTimeFormat,
    initialDateFormat,
    initialInterval = null,
  }: EventManagerParams) {
    this.timeframe$ = new BehaviorSubject<Timeframes>(initialTimeframe);
    this.seriesSelected$ = new BehaviorSubject<ChartSeriesType>(initialSeries);
    this.symbol$ = new BehaviorSubject<string>(initialSymbol);
    this.symbolName$ = new BehaviorSubject<string>(initialSymbolName?.trim() || initialSymbol);
    this.symbolTicker$ = new BehaviorSubject<string>(initialSymbolTicker?.trim() || initialSymbol);
    this.timeFormat$ = new BehaviorSubject<TimeFormat>(initialTimeFormat ?? Defaults.timeFormat);
    this.dateFormat$ = new BehaviorSubject<DateFormat>(initialDateFormat ?? Defaults.dateFormat);
    this.interval$ = new BehaviorSubject<Intervals | null>(initialInterval);

    this.undoRedo = new UndoRedo({
      timeframe: (value) => this.timeframe$.next(value),
      seriesSelected: (value) => this.seriesSelected$.next(value),
      symbol: (value) => this.symbol$.next(value),
      symbolName: (value) => this.symbolName$.next(value),
      symbolTicker: (value) => this.symbolTicker$.next(value),
      timeFormat: (value) => this.timeFormat$.next(value),
      dateFormat: (value) => this.dateFormat$.next(value),
      interval: (value) => this.interval$.next(value),
    });
  }

  private setWithHistory<K extends UndoKey, V>(
    key: K,
    subject: BehaviorSubject<V>,
    next: V,
    options?: SetWithHistoryOptions,
  ): void {
    const prev = subject.getValue();

    if (Object.is(prev, next)) {
      return;
    }

    subject.next(next);

    const historyEnabled = options?.history ?? true;

    if (historyEnabled) {
      this.undoRedo.push(key, prev, next);
    }
  }

  public getUndoRedo(): UndoRedo {
    return this.undoRedo;
  }

  public getTimeframe(): Timeframes {
    return this.timeframe$.value;
  }

  public setInterval = (next: Intervals, options?: SetWithHistoryOptions) => {
    const timeframe = getTimeframeByInterval(next);

    this.undoRedo.group(() => {
      this.setWithHistory('timeframe', this.timeframe$, timeframe, options);
      this.setWithHistory('interval', this.interval$, next, options);
    });
  };

  public resetInterval = (options?: SetWithHistoryOptions) =>
    this.setWithHistory('interval', this.interval$, null, options);

  public getInterval(): Observable<Intervals | null> {
    return this.interval$.asObservable();
  }

  public setSymbol = (symbol: string, options?: SetWithHistoryOptions): void => {
    this.setWithHistory('symbol', this.symbol$, symbol, options);
  };

  public getSymbol(): Observable<string> {
    return this.symbol$.asObservable();
  }

  public setInstrument(
    symbol: string,
    symbolName: string,
    symbolTicker?: string,
    options?: SetWithHistoryOptions,
  ): void {
    const nextSymbolName = symbolName.trim() || symbol;
    const nextSymbolTicker = symbolTicker?.trim() || symbol;

    this.undoRedo.group(() => {
      this.setWithHistory('symbolName', this.symbolName$, nextSymbolName, options);
      this.setWithHistory('symbolTicker', this.symbolTicker$, nextSymbolTicker, options);
      this.setWithHistory('symbol', this.symbol$, symbol, options);
    });
  }

  public symbolName(): Observable<string> {
    return this.symbolName$.asObservable();
  }

  public getSymbolName(): string {
    return this.symbolName$.value;
  }

  public symbolTicker(): Observable<string> {
    return this.symbolTicker$.asObservable();
  }

  public getSymbolTicker(): string {
    return this.symbolTicker$.value;
  }

  public setTimeFormat = (next: TimeFormat, options?: SetWithHistoryOptions): void =>
    this.setWithHistory('timeFormat', this.timeFormat$, next, options);

  public setDateFormat = (next: DateFormat, options?: SetWithHistoryOptions): void =>
    this.setWithHistory('dateFormat', this.dateFormat$, next, options);

  public getChartOptionsModel(): Observable<ChartOptionsModel> {
    // todo: подумать - стоит ли унести это в чарт
    return combineLatest([this.timeFormat$, this.dateFormat$, this.timeframe$]).pipe(
      map(([timeFormat, dateFormat, timeframe]) => ({
        timeFormat,
        dateFormat,
        showTime: shouldShowTime(timeframe),
      })),
    );
  }

  public setTimeframe = (next: Timeframes, options?: SetWithHistoryOptions) =>
    this.undoRedo.group(() => {
      this.resetInterval(options);
      this.setWithHistory('timeframe', this.timeframe$, next, options);
    });

  public symbol(): Observable<string> {
    return this.symbol$.asObservable();
  }

  public timeframe(): Observable<Timeframes> {
    return this.timeframe$.asObservable();
  }

  public subscribeTimeframe(callback: (format: Timeframes) => void): Subscription {
    return this.timeframe$.subscribe(callback);
  }

  public getTimeframeObs(): Observable<Timeframes> {
    return this.timeframe$.asObservable();
  }

  public setSeriesSelected = (next: ChartSeriesType, options?: SetWithHistoryOptions) =>
    this.setWithHistory('seriesSelected', this.seriesSelected$, next, options);

  public getSelectedSeries(): Observable<ChartSeriesType> {
    return this.seriesSelected$.asObservable();
  }

  public subscribeSeriesSelected(callback: (next: ChartSeriesType) => void): Subscription {
    return this.seriesSelected$.subscribe(callback);
  }

  public setControlBarVisible(visible: boolean): void {
    this.controlBarVisible$.next(visible);
  }

  public getControlBarVisible(): Observable<boolean> {
    return this.controlBarVisible$.asObservable();
  }

  public exportChartSettings(): ChartSettings {
    return {
      timeframe: this.timeframe$.value,
      seriesSelected: this.seriesSelected$.value,
      symbol: this.symbol$.value,
      timeFormat: this.timeFormat$.value,
      dateFormat: this.dateFormat$.value,
      interval: this.interval$.value,
    };
  }

  public importChartSettings(settings: ChartSettingsSource): void {
    const { symbol, seriesSelected, timeframe, timeFormat, dateFormat, interval } = parseChartSettings(settings);
    const setOptions = { history: false };

    if (symbol) {
      this.setSymbol(symbol, setOptions);
    }

    if (seriesSelected) {
      this.setSeriesSelected(seriesSelected, setOptions);
    }

    if (timeFormat) {
      this.setTimeFormat(timeFormat, setOptions);
    }

    if (dateFormat) {
      this.setDateFormat(dateFormat, setOptions);
    }

    if (interval != null) {
      this.setInterval(interval, setOptions);
      return;
    }

    if (timeframe) {
      this.setTimeframe(timeframe, setOptions);
      return;
    }

    if (interval === null) {
      this.resetInterval(setOptions);
    }
  }

  public destroy(): void {
    this.timeFormat$.complete();
    this.dateFormat$.complete();
    this.timeframe$.complete();
    this.controlBarVisible$.complete();
    this.interval$.complete();
    this.symbol$.complete();
    this.symbolName$.complete();
    this.symbolTicker$.complete();
    this.seriesSelected$.complete();
  }
}