import { getParent, getType, isRoot, types } from "mobx-state-tree";

import Registry from "./Registry";
import { ConfigurationError } from "../utils/errors";

function _mixedArray(fn) {
  return (arr) => types.maybeNull(types.array(fn(arr)));
}

function _oneOf(lookup, err) {
  return (arr) =>
    types.union({
      dispatcher: (sn) => {
        if (arr.find((val) => sn.type === val)) {
          return lookup(sn.type);
        }
        throw new ConfigurationError(err + sn.type);
      },
    });
}

const oneOfTags = _oneOf(Registry.getModelByTag, "Not expecting tag: ");
const tagsArray = _mixedArray(oneOfTags);

function unionArray(arr) {
  const type = types.maybeNull(types.array(oneOfTags(arr)));

  type.value = arr;
  return type;
}

function unionTag(arr) {
  return types.maybeNull(types.enumeration("unionTag", arr));
}

function tagsTypes(arr) {
  const type = types.frozen(arr.map((val) => val.toLowerCase()));

  type.describe = () => `(${arr.join("|")})`;
  type.value = arr;
  return type;
}

function allModelsTypes() {
  const args = [
    {
      dispatcher: (sn) => {
        if (!sn) return types.literal(undefined);
        if (Registry.tags.includes(sn.type)) {
          return Registry.getModelByTag(sn.type);
        }
        throw new ConfigurationError(`Not expecting tag: ${sn.type}`);
      },
    },
    Registry.modelsArr(),
  ];

  const results = [].concat.apply([], args);

  return types.union.apply(null, results);
}

function isType(node, types) {
  const nt = getType(node);

  for (const t of types) if (nt === t) return true;

  return false;
}

function getParentOfTypeString(node, str) {
  if (isRoot(node)) return null;

  // same as getParentOfType but checks models .name instead of type
  let parent = getParent(node);

  if (!Array.isArray(str)) str = [str];

  while (parent) {
    const name = getType(parent).name;

    if (str.find((c) => c === name)) return parent;

    parent = isRoot(parent) ? null : getParent(parent);
  }

  return null;
}

function getParentTagOfTypeString(node, str) {
  // same as getParentOfType but checks models .name instead of type
  let parent = getParent(node);

  if (!Array.isArray(str)) str = [str];

  while (parent) {
    const parentType = parent.type;

    if (str.find((c) => c === parentType)) return parent;

    parent = isRoot(parent) ? null : getParent(parent);
  }

  return null;
}

const oneOfTools = _oneOf(Registry.getTool, "Not expecting tool: ");
const toolsArray = _mixedArray(oneOfTools);

const Types = {
  unionArray,
  allModelsTypes,
  unionTag,
  tagsTypes,
  isType,
  getParentOfTypeString,
  getParentTagOfTypeString,
  tagsArray,
  toolsArray,
};

export default Types;