csState.ts

import log from "loglevel";
import { MacroMap } from "../types/macros";
import { mergeDType, DType } from "../types/dtypes";
import { createSelector, createSlice, PayloadAction } from "@reduxjs/toolkit";
import { SubscriptionType } from "../connection";

export const initialCsState: CsState = {
  valueCache: {},
  globalMacros: { SUFFIX: "1" },
  effectivePvNameMap: {},
  subscriptions: {},
  deviceCache: {},
  pvwsSettings: {}
};

export interface PvState {
  value?: DType;
  connected: boolean;
  readonly: boolean;
}

export type PvDatum = PvState & {
  effectivePvName: string;
};

export type PvDataCollection = {
  pvData: PvDatum[];
};

export interface FullPvState extends PvState {
  initializingPvName: string;
}

export interface ValueCache {
  [pvName: string]: FullPvState;
}

export interface Subscriptions {
  [pvName: string]: string[];
}

export interface DeviceCache {
  [deviceName: string]: DType;
}

export interface PvwsSettings {
  pvwsHost?: string;
}

export interface PvArrayResults {
  [pvName: string]: [PvState, string];
}

/* The shape of the store for the entire application. */
export interface CsState {
  valueCache: ValueCache;
  effectivePvNameMap: { [pvName: string]: string };
  globalMacros: MacroMap;
  subscriptions: Subscriptions;
  deviceCache: DeviceCache;
  pvwsSettings: PvwsSettings;
}

type ValueChangedActionType = PayloadAction<{ pvName: string; value: DType }>;

/* Given a new object that is a shallow copy of the original
   valueCache, update with contents of a ValueChanged action. */
function updateValueCache(
  valueCache: ValueCache,
  action: ValueChangedActionType
): void {
  const { pvName, value } = action.payload;
  const mergedValue = mergeDType(valueCache[pvName]?.value, value);

  const existing = valueCache[pvName] ?? {
    connected: false,
    readonly: true,
    initializingPvName: pvName
  };

  valueCache[pvName] = { ...existing, value: mergedValue };
}

const csSlice = createSlice({
  name: "cs",
  initialState: initialCsState,
  reducers: {
    setPvwsSettings(state, action: PayloadAction<PvwsSettings>) {
      log.debug(action);
      state.pvwsSettings.pvwsHost = action.payload.pvwsHost;
    },
    valueChanged(state, action: ValueChangedActionType) {
      log.debug(action);
      updateValueCache(state.valueCache, action);
    },

    valuesChanged(state, action: PayloadAction<Array<ValueChangedActionType>>) {
      log.debug(action);
      for (const valueAction of action.payload) {
        updateValueCache(state.valueCache, valueAction);
      }
    },
    connectionClosed(
      state,
      action: PayloadAction<{
        pvName: string;
      }>
    ) {
      log.debug(action);
      const { pvName } = action.payload;
      if (pvName in state.valueCache) {
        delete state.valueCache[pvName];
      }
    },
    connectionChanged(
      state,
      action: PayloadAction<{
        pvName: string;
        value: { isConnected: boolean; isReadonly?: boolean };
      }>
    ) {
      log.debug(action);
      const { pvName, value } = action.payload;
      const existing = state.valueCache[pvName] ?? {
        connected: false,
        readonly: true,
        initializingPvName: pvName
      };
      state.valueCache[pvName] = {
        ...existing,
        connected: value.isConnected,
        readonly: value.isReadonly ?? existing.readonly
      };
    },

    subscribe(
      state,
      action: PayloadAction<{
        componentId: string;
        pvName: string;
        effectivePvName?: string;
        type: SubscriptionType;
      }>
    ) {
      // the connection middleware intercepts this action and injects the effectivePvName before forwarding it
      log.debug(action);
      const { componentId, pvName } = action.payload;
      const effectivePvName = action.payload?.effectivePvName || pvName;

      const list = state.subscriptions[effectivePvName] ?? [];
      if (!list.includes(componentId)) {
        list.push(componentId);
        state.subscriptions[effectivePvName] = list;
      }

      if (pvName !== effectivePvName) {
        state.effectivePvNameMap[pvName] = effectivePvName;
      }
    },

    unsubscribe(
      state,
      action: PayloadAction<{ componentId: string; pvName: string }>
    ) {
      log.debug(action);
      const { componentId, pvName } = action.payload;
      const effectivePvName = state.effectivePvNameMap[pvName] ?? pvName;

      const current = state.subscriptions[effectivePvName] ?? [];
      const next = current.filter(id => id !== componentId);
      if (next.length === 0) {
        delete state.subscriptions[effectivePvName];

        Object.keys(state.effectivePvNameMap).forEach((key: string) => {
          if (state.effectivePvNameMap[key] === effectivePvName) {
            delete state.effectivePvNameMap[key];
          }
        });
      } else {
        state.subscriptions[effectivePvName] = next;
      }
    },

    writePv(_state, _action: PayloadAction<{ pvName: string; value: DType }>) {
      // intentionally empty — handled by listener middleware
    },

    deviceQueried(
      state,
      action: PayloadAction<{ device: string; value: DType }>
    ) {
      log.debug(action);
      const { device, value } = action.payload;
      state.deviceCache[device] = value;
    },

    queryDevice(_state, _action: PayloadAction<{ device: string }>) {
      // intentionally empty — handled by listener middleware
    }
  },
  selectors: {
    selectDeviceCache: state => state.deviceCache,
    selectEffectivePvNameMap: state => state.effectivePvNameMap,
    selectValueCache: state => state.valueCache,
    selectGlobalMacros: state => state.globalMacros,
    selectSubscriptions: state => state.subscriptions
  }
});

export const {
  setPvwsSettings,
  valueChanged,
  valuesChanged,
  connectionClosed,
  connectionChanged,
  subscribe,
  unsubscribe,
  writePv,
  deviceQueried,
  queryDevice
} = csSlice.actions;
export default csSlice.reducer;
export const {
  selectDeviceCache,
  selectEffectivePvNameMap,
  selectValueCache,
  selectGlobalMacros,
  selectSubscriptions
} = csSlice.selectors;

export const selectEffectivePvName = createSelector(
  [selectEffectivePvNameMap, (_state, pvName: string) => pvName],
  (effectivePvNameMap, pvName) => effectivePvNameMap[pvName]
);

export const selectDevice = createSelector(
  [selectDeviceCache, (_state, deviceId: string) => deviceId],
  (deviceCache, deviceId) => deviceCache[deviceId]
);

export const selectPvStates = createSelector(
  [
    selectEffectivePvNameMap,
    selectValueCache,
    (_state, pvNames: string[]) => pvNames
  ],
  (pvNameMap, valueCache, pvNames) => {
    const results: {
      [pvName: string]: [PvState, string];
    } = {};
    for (const pvName of pvNames) {
      const effectivePvName = pvNameMap[pvName] || pvName;
      results[pvName] = [valueCache[effectivePvName], effectivePvName];
    }
    return results;
  }
);

/* Used for preventing re-rendering if the results are equivalent.
   Note that if the state for a particular PV hasn't changed, we will
   get back the same object as last time so we are safe to compare them.
   We need to be careful that we don't have a situation where we get back
   the same object with different properties and compare it as equal when
   in fact it has changed.
*/
export const pvStateComparator = (
  before: PvArrayResults,
  after: PvArrayResults
): boolean => {
  if (Object.keys(before).length !== Object.keys(after).length) {
    return false;
  }
  for (const [pvName, [beforeVal, beforeEffPvName]] of Object.entries(before)) {
    // If the PV name for a widget has changed the previous results may
    // not resemble the new results at all.
    if (!after.hasOwnProperty(pvName)) {
      return false;
    }
    const [afterVal, afterEffPvName] = after[pvName];
    // If the PV state hasn't changed in the store, we will receive the same
    // object when selecting that PV state.
    if (beforeVal !== afterVal || beforeEffPvName !== afterEffPvName) {
      return false;
    }
  }
  return true;
};

export const deviceComparator = (before: DType, after: DType): boolean => {
  if (!before || !after) {
    return false;
  }
  if (Object.keys(before).length !== Object.keys(after).length) {
    return false;
  }
  if (before.value.stringValue !== after.value.stringValue) {
    return false;
  }
  return true;
};