import { getParent, hasParent, types } from "mobx-state-tree";
import { FF_LSDV_4583, isFF } from "../utils/feature-flags";

/**
 * Looks for a given visibility parameter in the node or its parents.
 * For convenience users can specify visibility parameters in parent `View` tag up the tree.
 * @todo We should use it for all params but for now it's only used for `whenrole`.
 * @param {Object} node Control tag
 * @param {string} param Visibility parameter name (whenrole, whenlabelvalue, whenchoicevalue)
 * @returns {string|null}
 */
function findVisibilityParam(node, param) {
  while (node) {
    if (node[param]) {
      return node[param];
    }
    // all tags are sitting in `children` array of their parent,
    // so we need to go up 2 levels to get the parent
    if (!hasParent(node, 2)) break;
    node = getParent(node, 2);
  }
  return null;
}

const RequiredMixin = types
  .model({
    required: types.optional(types.boolean, false),
    requiredmessage: types.maybeNull(types.string),
  })
  .actions((self) => {
    const Super = {
      validate: self.validate,
    };

    return {
      validate() {
        if (!Super.validate()) return false;
        if (!self.required) return true;

        if (self.perregion) {
          // validating when choices labeling is done per region,
          // for example choice may be required to be selected for
          // every bbox
          const objectTag = self.toNameTag;

          // if regions don't meet visibility conditions skip validation
          for (const reg of objectTag.allRegs) {
            const s = reg.results.find((s) => s.from_name === self);

            if (self.visiblewhen === "region-selected") {
              if (self.whentagname) {
                const label = reg.labeling?.from_name?.name;

                if (label && label !== self.whentagname) continue;
              }
            }

            if (reg.role) {
              const whenRoles = findVisibilityParam(self, "whenrole")?.split(",") ?? null;
              if (whenRoles && !whenRoles.includes(reg.role)) continue;
            }

            if (self.whenlabelvalue && !reg.hasLabel(self.whenlabelvalue)) {
              continue;
            }

            if (!s?.hasValue) {
              self.annotation.selectArea(reg);
              self.requiredModal();

              return false;
            }
          }
        } else if (isFF(FF_LSDV_4583) && self.peritem) {
          // validating when choices labeling is done per item,
          const objectTag = self.toNameTag;
          const maxItemIndex = objectTag.maxItemIndex;
          const existingResultsIndexes = self.annotation.regions.reduce((existingResultsIndexes, reg) => {
            const result = reg.results.find((s) => s.from_name === self);

            if (result?.hasValue) {
              existingResultsIndexes.add(reg.item_index);
            }
            return existingResultsIndexes;
          }, new Set());

          for (let idx = 0; idx <= maxItemIndex; idx++) {
            if (!existingResultsIndexes.has(idx)) {
              objectTag.setCurrentItem(idx);
              self.requiredModal();
              return false;
            }
          }
        } else {
          // validation when its classifying the whole object
          // isVisible can be undefined (so comparison is true) or boolean (so check for visibility)
          if (!self.holdsState && self.isVisible !== false && getParent(self, 2)?.isVisible !== false) {
            self.requiredModal();
            return false;
          }
        }
        return true;
      },
    };
  });

export default RequiredMixin;