/* eslint-disable implicit-arrow-linebreak */
/* eslint-disable object-curly-newline */
/* eslint-disable import/no-cycle */
import type { Elements, ElementsTypes } from 'Components/Calculation/config/map-values';
import { getValueName } from 'Components/Calculation/config/map-values';
import defaultValues from 'config/default-values';
import { makeAutoObservable } from 'mobx';
import type RootStore from '../../root';
import Computed from './computed';
import type { CalculationValues, Values } from './types';

export default class ValuesStore {
  root: RootStore;
  values = defaultValues;
  $computed: Computed;

  constructor(rootStore: RootStore) {
    makeAutoObservable(this);
    this.root = rootStore;
    this.$computed = new Computed(rootStore);
  }

  hydrate = (initialValues: CalculationValues) => {
    this.values = initialValues;
  };

  getValue<V extends Values>(valueName: V) {
    return this.values[valueName];
  }

  getValueByElement<E extends Elements>(elementName: E) {
    const valueName = getValueName(elementName);

    return this.getValue(valueName) as ElementsTypes[E];
  }

  getValues<V extends Values>(valuesNames: readonly V[]) {
    return valuesNames.reduce((values, valueName) => {
      // eslint-disable-next-line no-param-reassign
      values[valueName] = this.getValue(valueName);

      return values;
    }, {} as Pick<CalculationValues, typeof valuesNames[number]>);
  }

  setValue = <V extends Values>(valueName: V, value: CalculationValues[V]) => {
    this.values[valueName] = value;
  };

  setValueOfElement = <E extends Elements>(elementName: E, value: ElementsTypes[E]) => {
    const valueName = getValueName(elementName);
    this.setValue(valueName, value);
  };

  resetValues = (valuesNames: readonly Values[]) => {
    valuesNames.forEach((valueName) => {
      this.setValue(valueName, defaultValues[valueName]);
    });
  };

  setValues = (
    values: Partial<CalculationValues>,
    settings?: { reset: boolean; exclude: Values[] }
  ) => {
    if (settings?.reset) {
      this.resetValues(
        (Object.keys(defaultValues) as Values[]).filter(
          (valueName) => !settings?.exclude.includes(valueName)
        )
      );
    }

    (Object.keys(values) as Values[]).forEach((valueName) => {
      this.setValue(valueName, values[valueName]!);
    });
  };

  clearValue = (valueName: Values) => {
    this.setValue(valueName, null);
  };

  clearValueOfElement = (elementName: Elements) => {
    const valueName = getValueName(elementName);
    this.clearValue(valueName);
  };
}