---

import { IMoexChart, MoexChart } from '@core/MoexChart';

import type { ReactElement } from 'react';

describe('MoexChart', () => {
  it('должен очищать основной инструмент через EventManager', () => {
    const clearSymbol = jest.fn();
    const chart = Object.create(MoexChart.prototype) as MoexChart;

    (chart as unknown as { eventManager: { clearSymbol: () => void } }).eventManager = {
      clearSymbol,
    };

    chart.clearSymbol();

    expect(clearSymbol).toHaveBeenCalledTimes(1);
  });

  it('должен устанавливать основной инструмент через EventManager', () => {
    const setSymbol = jest.fn();
    const chart = Object.create(MoexChart.prototype) as MoexChart;

    (chart as unknown as { eventManager: { setSymbol: typeof setSymbol } }).eventManager = {
      setSymbol,
    };

    chart.setSymbol({
      symbolId: 'SBER',
      symbol: 'SBER',
      symbolName: 'Sberbank',
    });

    expect(setSymbol).toHaveBeenCalledWith({
      symbolId: 'SBER',
      symbol: 'SBER',
      symbolName: 'Sberbank',
    });
  });

  function renderHeader(showSnapshotButton?: boolean) {
    const copyImage = jest.fn().mockResolvedValue(undefined);
    const headerRenderer = { renderComponent: jest.fn() };
    const drawingToolbarRenderer = { renderComponent: jest.fn() };

    const drawingsCollectionManager = {
      selectedDrawing: jest.fn(),
      updateSelectedDrawingSettings: jest.fn(),
      toggleSelectedDrawingLock: jest.fn(),
      openSelectedDrawingSettings: jest.fn(),
      deleteSelectedDrawing: jest.fn(),
    };

    const chart = Object.create(MoexChart.prototype) as MoexChart;

    const internals = chart as unknown as {
      chart: {
        copyImage: () => Promise<void>;
        getDrawingsCollectionManager: () => typeof drawingsCollectionManager;
      };
      drawingToolbarRenderer: typeof drawingToolbarRenderer;
      headerRenderer: typeof headerRenderer;
      toolbarRenderer: undefined;
      controlBarRenderer: undefined;
      footerRenderer: undefined;
      eventManager: {
        getTimeframeObs: jest.Mock;
        setTimeframe: jest.Mock;
        getSelectedSeries: jest.Mock;
        setSeriesSelected: jest.Mock;
      };
      modalRenderer: object;
      fullscreen: object;
      renderAttachments: (config: IMoexChart, toggleToolbar: () => boolean) => void;
    };

    internals.chart = {
      copyImage,
      getDrawingsCollectionManager: () => drawingsCollectionManager,
    };

    internals.drawingToolbarRenderer = drawingToolbarRenderer;
    internals.headerRenderer = headerRenderer;
    internals.toolbarRenderer = undefined;
    internals.controlBarRenderer = undefined;
    internals.footerRenderer = undefined;
    internals.modalRenderer = {};
    internals.fullscreen = {};

    internals.eventManager = {
      getTimeframeObs: jest.fn(),
      setTimeframe: jest.fn(),
      getSelectedSeries: jest.fn(),
      setSeriesSelected: jest.fn(),
    };

    const config = {
      chartCollectionPreset: {
        supportedTimeframes: [],
        supportedChartSeriesTypes: [],
        showSettingsButton: false,
        showMenuButton: false,
        showFullscreenButton: false,
        undoRedoEnabled: false,
        showCompareButton: false,
        showSnapshotButton,
        openCompareModal: undefined,
        openSymbolSearchModal: undefined,
        theme: 'tr',
      },
    } as unknown as IMoexChart;

    internals.renderAttachments(config, jest.fn(() => false));

    const header = headerRenderer.renderComponent.mock.calls[0][0] as ReactElement<{
      copyImage?: () => Promise<void>;
    }>;

    return { header, copyImage };
  }

  it('должен передавать copyImage в Header, если снимок включён', async () => {
    const { header, copyImage } = renderHeader(true);

    expect(header.props.copyImage).toBeDefined();

    await header.props.copyImage!();

    expect(copyImage).toHaveBeenCalledTimes(1);
  });

  it('не должен передавать copyImage в Header, если настройка снимка не задана', () => {
    const { header, copyImage } = renderHeader();

    expect(header.props.copyImage).toBeUndefined();
    expect(copyImage).not.toHaveBeenCalled();
  });

  it('не должен передавать copyImage в Header, если снимок отключён', () => {
    const { header, copyImage } = renderHeader(false);

    expect(header.props.copyImage).toBeUndefined();
    expect(copyImage).not.toHaveBeenCalled();
  });
});