import { useDataOverlayStore } from '@/stores/data-overlay.store';
import { createPinia, setActivePinia, storeToRefs } from 'pinia';
import { inflateInitialDataOverlayState } from '@/functions/modelHelper';
import { DataOverlayDataFaker } from '@test/fakers/data-overlay-data.faker';
import { InteractionType } from '@3cr/types-ts';
import { parseDataOverlayData } from '@/functions/parsers/parseDataOverlayData';
import {
  DataOverlayAnnotation,
  DataOverlayMeasurement,
} from '@3cr/viewer-types-ts';

describe('data overlay store', () => {
  beforeEach(() => {
    setActivePinia(createPinia());
  });

  it('should have defaults', () => {
    const {
      state,
      event,
      annotations,
      annotationEvent,
      measurements,
      measurementEvent,
    } = storeToRefs(useDataOverlayStore());
    expect(state.value).toEqual(inflateInitialDataOverlayState());
    expect(event.value).toBe(null);
    expect(annotations.value).toEqual([]);
    expect(annotationEvent.value).toBe(null);
    expect(measurements.value).toEqual([]);
    expect(measurementEvent.value).toBe(null);
  });

  it('should handle annotation event', () => {
    const { event, annotationEvent, measurementEvent } = storeToRefs(
      useDataOverlayStore(),
    );
    event.value = DataOverlayDataFaker.annotationEventRaw(
      InteractionType.POINTER_UP,
    );
    expect(annotationEvent.value).not.toBe(null);
    expect(measurementEvent.value).toBe(null);
  });

  it('should handle measurement event', () => {
    const { event, annotationEvent, measurementEvent } = storeToRefs(
      useDataOverlayStore(),
    );
    event.value = DataOverlayDataFaker.lengthEventRaw(
      InteractionType.POINTER_UP,
    );
    expect(annotationEvent.value).toBe(null);
    expect(measurementEvent.value).not.toBe(null);
  });

  it('should set Initial MCAD state', async () => {
    const store = useDataOverlayStore();
    const { state } = storeToRefs(store);

    const stateString = JSON.stringify(state.value);

    state.value.Version = '9.9.9.9';
    store.setInitialDataOverlayState(stateString);
    expect(JSON.stringify(state.value)).toEqual(stateString);
  });

  it('should set MCAD state', async () => {
    const store = useDataOverlayStore();
    const { state } = storeToRefs(store);

    const stateString = JSON.stringify(state.value.DataOverlay);

    state.value.DataOverlay.Version = '9.9.9.9';
    store.setDataOverlayState(stateString);
    expect(JSON.stringify(state.value.DataOverlay)).toEqual(stateString);
  });

  it('should set MCAD Event', async () => {
    const store = useDataOverlayStore();
    const { event } = storeToRefs(store);

    expect(event.value).toEqual(null);

    const y = DataOverlayDataFaker.lengthEventRaw(InteractionType.NONE);

    store.setDataOverlayEvent(JSON.stringify(y));
    expect(event.value).toEqual(y);
  });

  it('should set annotations map', async () => {
    const store = useDataOverlayStore();
    const { state, annotations } = storeToRefs(store);

    const x = DataOverlayDataFaker.annotationRaw();
    state.value.DataOverlay.DataOverlay.push(x);

    expect(annotations.value).toStrictEqual([
      parseDataOverlayData<DataOverlayAnnotation>(x).Data,
    ]);
  });

  it('should set measurements map', async () => {
    const store = useDataOverlayStore();
    const { state, measurements } = storeToRefs(store);

    const x = DataOverlayDataFaker.lengthRaw();
    state.value.DataOverlay.DataOverlay.push(x);

    expect(measurements.value).toStrictEqual([
      parseDataOverlayData<DataOverlayMeasurement>(x).Data,
    ]);
  });
});