import { useDemoStore } from '@/stores/demo.store';
import { useUploadStore } from '@/stores/upload.store';
import {
  CurrentDataOverlayState,
  CurrentMcadState,
  CurrentScanState,
} from '@3cr/types-ts';
import {
  DemoType,
  SaveState,
  ViewerOptions,
  ViewerPayload,
} from '@3cr/viewer-types-ts';
import { flushPromises } from '@vue/test-utils';
import { cloneDeep } from 'lodash';
import { createPinia, setActivePinia, storeToRefs } from 'pinia';

describe('demo store tests', () => {
  beforeEach(() => {
    setActivePinia(createPinia());
  });

  it('should call demo licence options', () => {
    const { demoLicenceOptions } = storeToRefs(useDemoStore());
    Object.keys(demoLicenceOptions.value).forEach((key) => {
      const k = key as keyof ViewerOptions;
      const fn = demoLicenceOptions.value[k];
      if (typeof fn === 'function') {
        if (k === 'onMCADUpload') {
          expect(() => (fn as any)([])).not.toThrow();
        } else if (k === 'onSaveSession') {
          expect(() => (fn as any)({}, {}, {}, () => {})).not.toThrow();
        } else {
          expect(fn).not.toThrow();
        }
      }
    });
  });

  it('should call basic demo patient options', () => {
    const { demoPatientOptions } = storeToRefs(useDemoStore());
    Object.keys(demoPatientOptions.value).forEach((key) => {
      const k = key as keyof ViewerOptions;
      const fn = demoPatientOptions.value[k];
      if (typeof fn === 'function') {
        if (k === 'onMCADUpload') {
          expect(() => (fn as any)([])).not.toThrow();
        } else if (k === 'onSaveSession') {
          expect(() => (fn as any)({}, {}, {}, () => {})).not.toThrow();
        } else {
          expect(fn).not.toThrow();
        }
      }
    });
  });

  it('should have demoType set to licence', async () => {
    const { demoType } = storeToRefs(useDemoStore());
    Object.defineProperty(window, 'location', {
      value: {
        search: '?demoType=licence',
      },
      writable: true, // possibility to override
    });
    await flushPromises();

    expect(demoType.value).toBe(DemoType.Licence);
  });

  it('should have demoType set to patient', async () => {
    const { demoType } = storeToRefs(useDemoStore());
    Object.defineProperty(window, 'location', {
      value: {
        search: '?demoType=patient',
      },
      writable: true, // possibility to override
    });
    await flushPromises();

    expect(demoType.value).toBe(DemoType.Patient);
  });

  it('should have demoOptions set to licence', async () => {
    const { demoOptions, demoLicenceOptions } = storeToRefs(useDemoStore());
    Object.defineProperty(window, 'location', {
      value: {
        search: '?demoType=licence',
      },
      writable: true, // possibility to override
    });
    await flushPromises();

    expect(demoOptions.value).toBe(demoLicenceOptions.value);
  });

  it('should have demoOptions set to patient', async () => {
    const { demoOptions, demoPatientOptions } = storeToRefs(useDemoStore());
    Object.defineProperty(window, 'location', {
      value: {
        search: '?demoType=patient',
      },
      writable: true, // possibility to override
    });
    await flushPromises();

    expect(demoOptions.value).toBe(demoPatientOptions.value);
  });

  it('should set demo to demo', async () => {
    const store = useDemoStore();
    const { isDemo } = storeToRefs(store);

    store.setIsDemo({
      Url: 'https://webgl-3dr.singular.health/demo',
    } as ViewerPayload);

    expect(isDemo.value).toBe(true);
  });

  it('should set demo to not demo', async () => {
    const store = useDemoStore();
    const { isDemo } = storeToRefs(store);

    store.setIsDemo({
      Url: 'https://singular.health',
    } as ViewerPayload);

    expect(isDemo.value).toBe(false);
  });

  it('should set patient onMCADUpload', async () => {
    vi.useFakeTimers();
    const store = useDemoStore();
    const { demoPatientOptions } = storeToRefs(store);
    const { uploads } = storeToRefs(useUploadStore());

    demoPatientOptions.value.onMCADUpload!([new File([''], 'test.html')]);

    expect(uploads.value.length).toBe(1);
    let tempUploads = cloneDeep(uploads.value);

    while (tempUploads[0].status !== 'completed') {
      tempUploads = cloneDeep(uploads.value);

      vi.advanceTimersByTime(100);

      expect(uploads.value).not.toBe(tempUploads);
    }

    expect(tempUploads[0].status).toBe('completed');
    expect(tempUploads[0].subtitle).toBe('Upload Complete');
  });

  it('should set patient onSaveSession', async () => {
    vi.useFakeTimers();
    const store = useDemoStore();
    const { demoPatientOptions, demoTitle } = storeToRefs(store);

    const updateStateCallback = vi.fn();
    demoPatientOptions.value.onSaveSession!(
      {} as CurrentScanState,
      {} as CurrentDataOverlayState,
      {} as CurrentMcadState,
      updateStateCallback,
    );

    expect(updateStateCallback).toHaveBeenCalledWith(SaveState.SAVING);
    vi.advanceTimersByTime(1000);
    expect(updateStateCallback).toHaveBeenCalledWith(SaveState.SAVED_TEMPORARY);
    vi.advanceTimersByTime(500);
    expect(demoTitle.value).toBe('texts.demo.patient.saveSession.title');
  });

  it('should set licence onSaveSession', async () => {
    vi.useFakeTimers();
    const store = useDemoStore();
    const { demoLicenceOptions, demoTitle } = storeToRefs(store);

    const updateStateCallback = vi.fn();
    demoLicenceOptions.value.onSaveSession!(
      {} as CurrentScanState,
      {} as CurrentDataOverlayState,
      {} as CurrentMcadState,
      updateStateCallback,
    );

    expect(updateStateCallback).toHaveBeenCalledWith(SaveState.SAVING);
    vi.advanceTimersByTime(1000);
    expect(updateStateCallback).toHaveBeenCalledWith(SaveState.SAVED_TEMPORARY);
    vi.advanceTimersByTime(500);
    expect(demoTitle.value).toBe('texts.demo.licence.saveSession.title');
  });
});