---

import { DataSource } from '@core/DataSource';
import { DrawingsManager, DrawingsManagerSnapshot } from '@core/DrawingsManager';
import { Pane, PaneParams } from '@core/Pane';
import { ISerializable, PaneSnapshot } from '@src/types/snapshot';

interface PaneManagerParams extends Omit<PaneParams, 'isMainPane' | 'id' | 'basedOn' | 'onDelete'> {
  panesSnapshot: PaneSnapshot[];
}

export class PaneManager implements ISerializable<PaneSnapshot[]> {
  private mainPane: Pane;
  private paneChartInheritedParams: PaneManagerParams & { isMainPane: boolean };
  private panesMap: Map<number, Pane> = new Map<number, Pane>();
  private panesIdIterator = 0;

  constructor(params: PaneManagerParams) {
    this.paneChartInheritedParams = { ...params, isMainPane: false };

    const mainSnapshot = params.panesSnapshot.find((pane) => pane.isMain) ?? params.panesSnapshot[0];

    this.mainPane = new Pane({
      ...params,
      isMainPane: true,
      id: 0,
      onDelete: () => {},
    });

    this.panesMap.set(0, this.mainPane);
    this.panesIdIterator = 1;

    if (mainSnapshot?.drawings) {
      this.mainPane.setDrawingsSnapshot(mainSnapshot.drawings);
    }

    params.panesSnapshot
      .filter((pane) => !pane.isMain)
      .forEach((paneSnapshot) => {
        const pane = this.addPane();

        pane.setDrawingsSnapshot(paneSnapshot.drawings);
      });

    this.updateLastPane();
  }

  public getPaneById(id: number): Pane | undefined {
    return this.panesMap.get(id);
  }

  public getDrawingsSnapshot(): DrawingsManagerSnapshot {
    return this.mainPane.getDrawingsSnapshot();
  }

  public setDrawingsSnapshot(snapshot: DrawingsManagerSnapshot): void {
    this.mainPane.setDrawingsSnapshot(snapshot);
  }

  public getPanes(): Map<number, Pane> {
    return this.panesMap;
  }

  public getMainPane(): Pane {
    return this.mainPane;
  }

  public addPane(dataSource?: DataSource): Pane {
    const id = this.panesIdIterator;

    this.panesIdIterator += 1;

    const pane = new Pane({
      ...this.paneChartInheritedParams,
      id,
      dataSource: dataSource ?? null,
      basedOn: dataSource ? undefined : this.mainPane,
      onDelete: () => {
        this.panesMap.delete(id);
        this.updateLastPane();
      },
    });

    this.panesMap.set(id, pane);
    this.updateLastPane();

    return pane;
  }

  public getDrawingsManager(): DrawingsManager {
    return this.mainPane.getDrawingManager();
  }

  public updateDrawings(): void {
    this.panesMap.forEach((pane) => {
      pane.updateDrawings();
    });
  }

  public getSnapshot(): PaneSnapshot[] {
    return Array.from(this.panesMap.values()).map((pane) => pane.getSnapshot());
  }

  private updateLastPane(): void {
    const panes = Array.from(this.panesMap.values());

    panes.forEach((pane) => pane.setIsLast(false));
    panes.at(-1)?.setIsLast(true);
  }
}