import { flushPromises, mount } from '@vue/test-utils';
import { VBtn } from 'vuetify/components';
import ViewerActionBar from '@/components/modal/app-bars/ViewerActionBar.vue';
import { defineComponent } from 'vue';
import { useViewer3cr } from '@/composables/useViewer3cr';
import { useDrawerStore } from '@/stores/drawer.store';
import { storeToRefs } from 'pinia';
import { useViewerStore } from '@/stores/viewer.store';
import ShareModal from '@/components/modal/modal/ShareModal.vue';
import { useDemoStore } from '@/stores/demo.store';
import { SaveState } from '@3cr/viewer-types-ts';
import { useSaveStore } from '@/stores/save.store';
import { MockInstance } from 'vitest';

const app = defineComponent({
  template: '<v-app><ViewerActionBar></ViewerActionBar></v-app>',
  components: { ViewerActionBar },
});

vi.mock('@/models/scanState', async (importOriginal) => ({
  ...(await importOriginal<typeof import('@/models/scanState')>()),
  isLayout2x2: { value: false },
  isLayout1x3: { value: false },
}));

describe('Viewer3cr tests', () => {
  const viewer3cr = useViewer3cr();

  let wrapper = mount(app);
  let customLayoutSpy: MockInstance;

  beforeEach(() => {
    wrapper = mount(app);
    customLayoutSpy = vi.spyOn(viewer3cr, 'customLayout').mockResolvedValue();
  });

  afterEach(() => {
    vi.clearAllMocks();
    wrapper.unmount();
    customLayoutSpy.mockRestore();
  });

  it('inflates', () => {
    expect(wrapper).toBeTruthy();
  });

  it('should set 2x2 view', async () => {
    await flushPromises();
    await wrapper.findComponentByTestId<VBtn>('layout-2x2').trigger('click');
    expect(customLayoutSpy).toHaveBeenCalled();
  });

  it('should show open scan', async () => {
    const { options } = storeToRefs(useViewerStore());
    options.value.disableLayouts = false;

    const { isOpen } = storeToRefs(useDrawerStore());
    vi.spyOn(isOpen, 'value', 'get').mockReturnValue(true);

    await flushPromises();
    await wrapper.findComponentByTestId<VBtn>('layout-2x2').trigger('click');
    expect(customLayoutSpy).toHaveBeenCalled();
  });

  it('should show all as open', async () => {
    const { options } = storeToRefs(useViewerStore());

    options.value.disableLayouts = true;
    options.value.disableReset = true;
    const { isOpen } = storeToRefs(useDrawerStore());
    vi.spyOn(isOpen, 'value', 'get').mockReturnValue(true);
    await flushPromises();
    expect(wrapper.findComponent(ShareModal).exists()).toBe(true);
  });

  it('should show all as open', async () => {
    const { options } = storeToRefs(useViewerStore());
    const { state } = storeToRefs(useSaveStore());
    state.value = SaveState.SAVING;
    options.value = useDemoStore().demoPatientOptions;
    const { isOpen } = storeToRefs(useDrawerStore());
    vi.spyOn(isOpen, 'value', 'get').mockReturnValue(true);
    await flushPromises();
    await wrapper.findComponentByTestId<VBtn>('share-btn').trigger('click');
    expect(wrapper.findComponent(ShareModal).exists()).toBe(true);
  });

  it('should show all as closed', async () => {
    const { options } = storeToRefs(useViewerStore());

    options.value = useDemoStore().demoPatientOptions;
    const { isOpen } = storeToRefs(useDrawerStore());
    vi.spyOn(isOpen, 'value', 'get').mockReturnValue(false);
    await flushPromises();
    await wrapper.findComponentByTestId<VBtn>('share-btn').trigger('click');
    expect(wrapper.findComponent(ShareModal).exists()).toBe(true);
    await wrapper.findComponent(ShareModal).setValue(false);
    expect(wrapper.findComponent(ShareModal).vm.modelValue).toBe(false);
  });

  it('should set 1x3 view', async () => {
    await flushPromises();
    await wrapper.findComponentByTestId('layout-1x3').trigger('click');
    expect(customLayoutSpy).toHaveBeenCalled();
  });

  it('should download scan', async () => {
    const testingFn = vi.fn();
    const { options } = storeToRefs(useViewerStore());

    options.value.onDownloadScan = testingFn;
    const { isOpen } = storeToRefs(useDrawerStore());
    vi.spyOn(isOpen, 'value', 'get').mockReturnValue(false);
    await flushPromises();
    await wrapper.findComponentByTestId<VBtn>('download-btn').trigger('click');

    expect(testingFn).toHaveBeenCalled();
  });

  it('should load scan', async () => {
    const testingFn = vi.fn();
    const { options } = storeToRefs(useViewerStore());

    options.value.onLoadScan = testingFn;
    const { isOpen } = storeToRefs(useDrawerStore());
    vi.spyOn(isOpen, 'value', 'get').mockReturnValue(false);
    await flushPromises();
    await wrapper.findComponentByTestId<VBtn>('load-btn').trigger('click');

    expect(testingFn).toHaveBeenCalled();
  });

  it('should cloud scan', async () => {
    const testingFn = vi.fn();
    const { options } = storeToRefs(useViewerStore());

    options.value.onCloudStorage = testingFn;
    const { isOpen } = storeToRefs(useDrawerStore());
    vi.spyOn(isOpen, 'value', 'get').mockReturnValue(false);
    await flushPromises();
    await wrapper.findComponentByTestId<VBtn>('cloud-btn').trigger('click');

    expect(testingFn).toHaveBeenCalled();
  });

  it('should reset scan', async () => {
    const resetSpy = vi.spyOn(viewer3cr, 'viewSelection').mockResolvedValue();
    const { isOpen } = storeToRefs(useDrawerStore());
    vi.spyOn(isOpen, 'value', 'get').mockReturnValue(false);
    await flushPromises();
    await wrapper.findComponentByTestId<VBtn>('reset-btn').trigger('click');

    expect(resetSpy).toHaveBeenCalledTimes(2);
  });

  it('should save scan', async () => {
    const testingFn = vi
      .fn()
      .mockImplementation((_s: any, _d: any, _m: any, ssFn: any) => {
        ssFn(SaveState.SAVED_CLOUD);
      });
    const { options } = storeToRefs(useViewerStore());

    options.value.onSaveSession = testingFn;
    const { isOpen } = storeToRefs(useDrawerStore());
    vi.spyOn(isOpen, 'value', 'get').mockReturnValue(false);
    await flushPromises();
    await wrapper.findComponentByTestId<VBtn>('save-btn').trigger('click');

    expect(testingFn).toHaveBeenCalled();
  });
});