import { flow, getParent, getRoot, types } from "mobx-state-tree";
import * as CellViews from "../../components/CellViews";
import { normalizeCellAlias } from "../../components/CellViews";
import * as Filters from "../../components/Filters/types";
import { allowedFilterOperations } from "../../components/Filters/types/Utility";
import { debounce } from "../../utils/debounce";
import { isBlank, isDefined } from "../../utils/utils";
import { FilterValueRange, FilterValueType, TabFilterType } from "./tab_filter_type";

const operatorNames = Array.from(new Set([].concat(...Object.values(Filters).map((f) => f.map((op) => op.key)))));

const Operators = types.enumeration(operatorNames);

const getOperatorDefaultValue = (operator) => {
  if (!operatorNames.includes(operator)) {
    return null;
  }

  return operator === "empty" ? false : null;
};

export const TabFilter = types
  .model("TabFilter", {
    filter: types.reference(TabFilterType),
    operator: types.maybeNull(Operators),
    value: types.maybeNull(FilterValueType),

    child_filter: types.maybeNull(types.late(() => TabFilter)),
  })
  .views((self) => ({
    get field() {
      return self.filter.field;
    },

    get schema() {
      return self.filter.schema;
    },

    /** @returns {import("./tab").View} */
    get view() {
      // For child filters, we need to traverse up to find the tab
      let current = self;
      let parent = null;

      try {
        while (current) {
          parent = getParent(current);
          if (parent?.filters && Array.isArray(parent.filters)) {
            return parent;
          }
          current = parent;
        }
      } catch {
        return getParent(getParent(self));
      }

      return null;
    },

    get component() {
      const operationsList = Filters[self.filter.currentType] ?? Filters.String;

      return allowedFilterOperations(operationsList, getRoot(self)?.SDK?.type);
    },

    get componentValueType() {
      return self.component?.find(({ key }) => key === self.operator)?.valueType;
    },

    get target() {
      return self.filter.field.target;
    },

    get type() {
      return self.field.currentType;
    },

    get isValidFilter() {
      const { currentValue: value } = self;

      if (!isDefined(value) || isBlank(value)) {
        return false;
      }
      if (FilterValueRange.is(value)) {
        return isDefined(value.min) && isDefined(value.max);
      }

      return true;
    },

    get currentValue() {
      let resultValue;

      if (self.filter.schema === null) {
        resultValue = self.value;
      } else {
        resultValue = self.value?.value ?? self.value ?? null;
      }

      return resultValue;
    },

    get cellView() {
      const col = self.filter.field;

      return CellViews[col.type] ?? CellViews[normalizeCellAlias(col.alias)];
    },
  }))
  .volatile(() => ({
    wasValid: false,
    saved: false,
    saving: false,
  }))
  .actions((self) => ({
    afterAttach() {
      if (self.value === null) {
        self.setDefaultValue();
      }
      if (self.operator === null) {
        self.setOperator(self.component[0].key);
      }

      // If this filter's column has child_filter metadata and no child filter exists, create it
      // This ensures child filters are automatically recreated after navigation
      if (!self.child_filter && self.filter?.field?.child_filter) {
        self.view?.applyChildFilter(self);
      }
    },

    setFilter(value, save = true) {
      if (!isDefined(value)) return;

      self.view.clearChildFilter(self);

      const previousFilterType = self.filter.currentType;
      const previousFilter = self.filter;

      self.filter = value;

      const typeChanged = previousFilterType !== self.filter.currentType;
      const filterChanged = previousFilter !== self.filter;

      if (typeChanged || filterChanged) {
        self.view.applyChildFilter(self);

        self.markUnsaved();
      }

      if (typeChanged) {
        self.setDefaultValue();
        self.setOperator(self.component[0].key);
      }

      if (filterChanged) {
        self.setValue(null);
      }

      if (save) self.saved();
    },

    setFilterDelayed(value) {
      self.setFilter(value, false);
      self.saveDelayed();
    },

    setOperator(operator) {
      const previousValueType = self.componentValueType;

      if (self.operator !== operator) {
        self.markUnsaved();
        self.operator = operator;
      }

      if (previousValueType !== self.componentValueType) {
        self.setDefaultValue();
      }

      self.save();
    },

    setValue(newValue) {
      self.value = newValue;
    },

    delete() {
      self.view.deleteFilter(self);
    },

    save: flow(function* (force = false) {
      const isValid = self.isValidFilter;

      if (force !== true) {
        if (self.saved === true) return;
        if (isValid === false) return;
        if (self.wasValid === false && isValid === false) return;
      }

      if (self.saving) return;

      self.saving = true;
      self.wasValid = isValid;
      self.markSaved();
      getRoot(self)?.unsetSelection();
      self.view?.clearSelection();
      yield self.view?.save({ interaction: "filter" });
      self.saving = false;
    }),

    setDefaultValue() {
      self.setValue(getOperatorDefaultValue(self.operator) ?? self.filter.defaultValue);
    },

    setValueDelayed(value) {
      self.setValue(value);
      setTimeout(self.saveDelayed);
    },

    markSaved() {
      self.saved = true;
    },

    markUnsaved() {
      self.saved = false;
    },

    saveDelayed: debounce(() => {
      self.save();
    }, 300),
  }))
  .preProcessSnapshot((sn) => {
    if (!sn) return sn;
    return { ...sn, value: sn.value ?? null };
  });