import { defineStore } from 'pinia';
import { computed, ref } from 'vue';
import {
  CurrentDataOverlayState,
  DataOverlayType,
  InitialDataOverlayState,
} from '@3cr/types-ts';
import { inflateInitialDataOverlayState } from '@/functions/modelHelper';
import { parseDataOverlayData } from '@/functions/parsers/parseDataOverlayData';
import { parseDataOverlayEvent } from '@/functions/parsers/parseDataOverlayEvent';
import {
  DataOverlayAnnotation,
  DataOverlayDataRaw,
  DataOverlayEvent,
  DataOverlayData,
  DataOverlayMeasurement,
} from '@3cr/viewer-types-ts';

function isAnnotation(data: DataOverlayDataRaw): boolean {
  return data.DataType === DataOverlayType.Annotation;
}

function toAnnotation(
  data: DataOverlayDataRaw,
): DataOverlayData<DataOverlayAnnotation> {
  return parseDataOverlayData<DataOverlayAnnotation>(data);
}

function toAnnotationEvent(
  data: DataOverlayDataRaw,
): DataOverlayEvent<DataOverlayAnnotation> {
  return parseDataOverlayEvent<DataOverlayAnnotation>(data);
}

function isMeasurement(data: DataOverlayDataRaw): boolean {
  return (
    data.DataType === DataOverlayType.Length ||
    data.DataType === DataOverlayType.Polygon ||
    data.DataType === DataOverlayType.Angle
  );
}

function toMeasurement(
  data: DataOverlayDataRaw,
): DataOverlayData<DataOverlayMeasurement> {
  return parseDataOverlayData<DataOverlayMeasurement>(data);
}

function toMeasurementEvent(
  data: DataOverlayDataRaw,
): DataOverlayEvent<DataOverlayMeasurement> {
  return parseDataOverlayEvent<DataOverlayMeasurement>(data);
}

export const useDataOverlayStore = defineStore('data-overlay', () => {
  const state = ref<InitialDataOverlayState>(inflateInitialDataOverlayState());

  const event = ref<DataOverlayDataRaw | null>(null);

  const annotations = computed(() => {
    return state.value.DataOverlay.DataOverlay.filter(isAnnotation)
      .map(toAnnotation)
      .map((data) => data.Data);
  });

  const annotationEvent = computed(() => {
    const value = event.value;
    return value && isAnnotation(value) ? toAnnotationEvent(value) : null;
  });

  const measurements = computed(() => {
    return state.value.DataOverlay.DataOverlay.filter(isMeasurement)
      .map(toMeasurement)
      .map((data) => data.Data);
  });

  const measurementEvent = computed(() => {
    const value = event.value;
    return value && isMeasurement(value) ? toMeasurementEvent(value) : null;
  });

  function setInitialDataOverlayState(message: string): void {
    state.value = JSON.parse(message) as InitialDataOverlayState;
  }

  function setDataOverlayState(message: string): void {
    state.value = {
      Version: '1.1.0',
      DataOverlay: JSON.parse(message) as CurrentDataOverlayState,
    };
  }

  function setDataOverlayEvent(message: string): void {
    event.value = JSON.parse(message) as DataOverlayDataRaw;
  }

  return {
    state,
    event,
    annotations,
    annotationEvent,
    measurements,
    measurementEvent,
    setInitialDataOverlayState,
    setDataOverlayState,
    setDataOverlayEvent,
  };
});