import McadMenu from '@/components/navigation/mcad/McadMenu.vue';
import { useToolGroup } from '@/composables/useToolGroup';
import {
  defineHotkeys,
  HotkeyScope,
  resetScope,
} from '@/functions/HotkeyScope';
import { useToolStore } from '@/stores/tool.store';
import { useViewerStore } from '@/stores/viewer.store';
import { DataOverlayMcadFaker } from '@test/fakers/data-overlay-mcad.faker';
import { MockInstance } from '@vitest/spy';
import { flushPromises, mount } from '@vue/test-utils';
import { cloneDeep } from 'lodash';
import { storeToRefs } from 'pinia';
import { VDialog, VMenu } from 'vuetify/components';

vi.mock('@/composables/useToolGroup', async (importOriginal) => ({
  ...(await importOriginal<typeof import('@/composables/useToolGroup')>()),
  useToolGroup: vi.fn().mockReturnValue({
    toggleTool: vi.fn(),
  }),
}));

vi.mock('@/functions/HotkeyScope', async (importOriginal) => ({
  ...(await importOriginal<typeof import('@/functions/HotkeyScope')>()),
  defineHotkeys: vi.fn(),
  resetScope: vi.fn(),
}));

describe('McadMenu tests', () => {
  const mcad = DataOverlayMcadFaker.random();

  it('should mount', () => {
    const props = { mcad };
    const wrapper = mount(McadMenu, { props });
    expect(wrapper).toBeTruthy();
  });
  it('should trigger all clicks', async () => {
    const { mcadSelectTool } = useToolStore();
    const { options } = storeToRefs(useViewerStore());
    const props = { mcad };
    const wrapper = mount(McadMenu, { props });
    const menu = wrapper.findComponent(VMenu);

    await menu.setValue(true);

    options.value.onDownloadMcad = () => {};

    mcadSelectTool.selected.value = DataOverlayMcadFaker.random();

    for (const item of wrapper.vm.dropdownOptions) item.onClick();
    expect(wrapper).toBeTruthy();
  });
  it('should open update modal', async () => {
    const props = { mcad };
    const wrapper = mount(McadMenu, { props });
    const menu = wrapper.findComponent(VMenu);

    await menu.setValue(true);

    const dialogs = wrapper.findAllComponents(VDialog);

    await dialogs[0].setValue(true);

    expect(dialogs[0].isVisible()).toBe(true);
  });
  it('should open delete modal', async () => {
    const props = { mcad };
    const wrapper = mount(McadMenu, { props });
    const menu = wrapper.findComponent(VMenu);

    await menu.setValue(true);

    const dialogs = wrapper.findAllComponents(VDialog);

    await dialogs[1].setValue(true);
    expect(dialogs[1].isVisible()).toBe(true);
  });

  it('should close menu', async () => {
    const props = { mcad };
    const wrapper = mount(McadMenu, { props });
    const menu = wrapper.findComponent(VMenu);

    await menu.setValue(true);

    expect(wrapper.findComponentByTestId('lock').exists()).toBe(true);
    await menu.setValue(false);
  });

  it('should call rotate onClick', async () => {
    const { mcadRotateTool } = useToolStore();
    const { toggleTool } = useToolGroup();

    const props = { mcad };
    const wrapper = mount(McadMenu, { props });

    const item = findOption(wrapper.vm.dropdownOptions, 'rotate');

    item.onClick();

    await flushPromises();
    expect(toggleTool).toHaveBeenCalledWith(mcadRotateTool);
  });

  it('should call move onClick', async () => {
    const { mcadMoveTool } = useToolStore();
    const { toggleTool } = useToolGroup();

    const props = { mcad };
    const wrapper = mount(McadMenu, { props });

    const item = findOption(wrapper.vm.dropdownOptions, 'move');

    item.onClick();

    await flushPromises();
    expect(toggleTool).toHaveBeenCalledWith(mcadMoveTool);
  });

  it('should call download onClick', async () => {
    const { options } = storeToRefs(useViewerStore());
    const props = { mcad };
    const wrapper = mount(McadMenu, { props });

    options.value.onDownloadMcad = vi.fn();

    const item = findOption(wrapper.vm.dropdownOptions, 'download');

    item.onClick();

    expect(options.value.onDownloadMcad).toHaveBeenCalledWith(mcad.Key);
  });

  it('should call update onClick', async () => {
    const { options } = storeToRefs(useViewerStore());
    const props = { mcad };
    const wrapper = mount(McadMenu, { props });

    options.value.onDownloadMcad = vi.fn();

    const item = findOption(wrapper.vm.dropdownOptions, 'update');

    item.onClick();

    expect(wrapper.vm.m_update).toBe(true);
  });

  it('should call delete onClick', async () => {
    const { options } = storeToRefs(useViewerStore());
    const props = { mcad };
    const wrapper = mount(McadMenu, { props });

    options.value.onDownloadMcad = vi.fn();

    const item = findOption(wrapper.vm.dropdownOptions, 'delete');

    item.onClick();

    expect(wrapper.vm.m_delete).toBe(true);
  });

  it('should display hide', async () => {
    const { options } = storeToRefs(useViewerStore());
    const props = { mcad: cloneDeep(mcad) };
    props.mcad.Visibility = false;
    const wrapper = mount(McadMenu, { props });

    options.value.onDownloadMcad = vi.fn();

    const item = findOption(wrapper.vm.dropdownOptions, 'hide');

    expect(item.display).toBe(false);
  });

  it('should not display hide', async () => {
    const { options } = storeToRefs(useViewerStore());
    const props = { mcad: cloneDeep(mcad) };
    props.mcad.Visibility = true;
    const wrapper = mount(McadMenu, { props });

    options.value.onDownloadMcad = vi.fn();

    const item = findOption(wrapper.vm.dropdownOptions, 'hide');

    expect(item.display).toBe(true);
  });

  it('should not display lock', async () => {
    const { options } = storeToRefs(useViewerStore());
    const props = { mcad: cloneDeep(mcad) };
    props.mcad.Locked = true;
    const wrapper = mount(McadMenu, { props });

    options.value.onDownloadMcad = vi.fn();

    const item = findOption(wrapper.vm.dropdownOptions, 'lock');

    expect(item.display).toBe(false);
  });

  it('should display lock', async () => {
    const { options } = storeToRefs(useViewerStore());
    const props = { mcad: cloneDeep(mcad) };
    props.mcad.Locked = false;
    const wrapper = mount(McadMenu, { props });

    options.value.onDownloadMcad = vi.fn();

    const item = findOption(wrapper.vm.dropdownOptions, 'lock');

    expect(item.display).toBe(true);
  });

  it('should call all hotkey scopes', async () => {
    const defineHotkeysMock = defineHotkeys as unknown as MockInstance;

    defineHotkeysMock.mockImplementation(
      (_type: HotkeyScope, definition: any) => {
        for (const x of Object.keys(definition)) {
          definition[x]();
        }
      },
    );

    const props = { mcad };
    const wrapper = mount(McadMenu, { props });
    const menu = wrapper.findComponent(VMenu);

    await menu.setValue(true);
    expect(defineHotkeys).toHaveBeenCalledWith(
      HotkeyScope.MCAD_MENU,
      expect.anything(),
    );
    await menu.setValue(false);
    expect(resetScope).toHaveBeenCalledWith(HotkeyScope.MCAD_MENU);
  });
});

function findOption(options: Array<any>, dataTestId: string) {
  return options.find((x) => x.dataTestId === dataTestId);
}