import Registry from "../Registry";
import messages from "../../utils/messages";

export const errorBuilder = {
  /**
   * Occurrs when attribute is not provided at all
   */
  required(modelName, field) {
    return {
      modelName,
      field,
      error: "ERR_REQUIRED",
    };
  },

  /**
   * Occurrs when tag is not in our Registry
   */
  unknownTag(modelName, field, value) {
    return {
      modelName,
      field,
      value,
      error: "ERR_UNKNOWN_TAG",
    };
  },

  /**
   * Occurrs when tag is not on the tree
   */
  tagNotFound(modelName, field, value) {
    return {
      modelName,
      field,
      value,
      error: "ERR_TAG_NOT_FOUND",
    };
  },

  /**
   * Occurrs when referenced tag cannot be controlled by particular control tag
   */
  tagUnsupported(modelName, field, value, validType) {
    return {
      modelName,
      field,
      value,
      validType,
      error: "ERR_TAG_UNSUPPORTED",
    };
  },

  /**
   * Occurrs when tag has not expected parent tag at any level
   */
  parentTagUnexpected(modelName, field, value, validType) {
    return {
      modelName,
      field,
      value,
      validType,
      error: "ERR_PARENT_TAG_UNEXPECTED",
    };
  },

  /**
   * Occurrs when attribute value has wrong type
   */
  badAttributeValueType(modelName, field, value, validType) {
    return {
      modelName,
      field,
      value,
      validType,
      error: "ERR_BAD_TYPE",
    };
  },

  internalError(error) {
    return {
      error: "ERR_INTERNAL",
      value: String(error).substr(0, 1000),
      field: String(error.code),
      modelName: "",
    };
  },

  generalError(error) {
    return {
      error: "ERR_GENERAL",
      value: String(error).substr(0, 1000),
      field: String(error.code),
      modelName: "",
    };
  },

  loadingError(error, url, attrWithUrl, message = messages.ERR_LOADING_HTTP) {
    console.log("ERR", error, error.code);
    return {
      error: "ERR_GENERAL",
      value: message({ attr: attrWithUrl, error: String(error), url }),
      field: attrWithUrl,
      modelName: "",
    };
  },
};

/**
 * Transforms MST `describe()` to a human-readable value
 * @param {import("mobx-state-tree").IType} type
 * @param {boolean} withNullType
 */
const getTypeDescription = (type, withNullType = true) => {
  const description = type
    .describe()
    .match(/([a-z0-9?|]+)/gi)
    .join("")
    .split("|");

  // Remove optional null
  if (withNullType === false) {
    const index = description.indexOf("null?");

    if (index >= 0) description.splice(index, 1);
  }

  return description;
};

/**
 * Flatten config tree for faster iterations and searches
 * @param {object} tree
 * @param {string | null;;} parent
 * @param {string[]} parentParentTypes
 * @param {object[]} result
 * @returns {object[]}
 */
const flattenTree = (tree, parent = null, parentParentTypes = ["view"], result) => {
  if (!tree.children) return [];

  const children = tree.type === "pagedview" ? tree.children.slice(0, 1) : tree.children;

  for (const child of children) {
    /* Create a child without children and
    assign id of the parent for quick mathcing */
    const parentTypes = [...parentParentTypes, ...(parent?.type ? [parent?.type] : [])];
    const flatChild = { ...child, parent: parent?.id ?? null, parentTypes };

    delete flatChild.children;

    result.push(flatChild);

    if (Array.isArray(child.children)) {
      flattenTree(child, child, parentTypes, result);
    }
  }

  return result;
};

/**
 * Validates presence and format of the name attribute
 * @param {Object} child
 * @param {Object} model
 */
const validateNameTag = (child, model) => {
  const { name } = model.properties;

  // HyperText can be used for mark-up, without name, so name is optional type there
  if (name && !name.optionalValues && child.name === undefined) {
    return errorBuilder.required(model.name, "name");
  }

  return null;
};

/**
 * Validates toName attribute
 * Checks that connected tag is existing tag, it present in the tree
 * and can be controlled by current Object Tag
 * @param {Object} element
 * @param {Object} model
 * @param {Object[]} flatTree
 */
const validateToNameTag = (element, model, flatTree) => {
  const { controlledTags } = model.properties;

  if (!element.toname) return null;

  const names = element.toname.split(","); // for pairwise

  for (const name of names) {
    // Find referenced tag in the tree
    const controlledTag = flatTree.find((item) => item.name === name);

    if (controlledTag === undefined) {
      return errorBuilder.tagNotFound(model.name, "toname", name);
    }

    if (controlledTags && controlledTags.validate(controlledTag.tagName).length) {
      return errorBuilder.tagUnsupported(model.name, "toname", controlledTag.tagName, controlledTags);
    }
  }

  return null;
};

/**
 * Validates parent of tag
 * Checks that parent tag has the right type
 * @param {Object} element
 * @param {Object} model
 * @param {Object[]} flatTree
 */
const validateParentTag = (element, model) => {
  const parentTypes = model.properties.parentTypes?.value;

  if (
    !parentTypes ||
    element.parentTypes.find((elementParentType) =>
      parentTypes.find((type) => elementParentType === type.toLowerCase()),
    )
  ) {
    return null;
  }
  return errorBuilder.parentTagUnexpected(model.name, "parent", element.tagName, model.properties.parentTypes);
};

/**
 * Validates if visual tags have name attribute
 * @param {Object} element
 */
const validateVisualTags = (element) => {
  const visualTags = ["Collapse", "Filter", "Header", "Style", "View"];
  const { tagName } = element;

  if (visualTags.includes(tagName) && element.name) {
    return errorBuilder.generalError(`Attribute <b>name</b> is not allowed for tag <b>${tagName}</b>.`);
  }

  return null;
};

/**
 * Validate other tag attributes other than name and toName
 * @param {Object} child
 * @param {import("mobx-state-tree").IModelType} model
 * @param {string[]} fieldsToSkip
 */
const validateAttributes = (child, model, fieldsToSkip) => {
  const result = [];
  const properties = Object.keys(model.properties);

  for (const key of properties) {
    if (!{}.hasOwnProperty.call(child, key)) continue;
    if (fieldsToSkip.includes(key)) continue;
    const value = child[key];
    const modelProperty = model.properties[key.toLowerCase()];
    const mstValidationResult = modelProperty.validate(value, modelProperty);

    if (mstValidationResult.length === 0) continue;

    result.push(errorBuilder.badAttributeValueType(model.name, key, value, modelProperty));
  }

  return result;
};

/**
 * Validate perRegion restrictions
 * @param {Object} child
 */
const validatePerRegion = (child) => {
  const validationResult = [];

  // PerItem and PerRegion are incompatible but PerRegion is more prioritized mode
  if (child.perregion && child.peritem) {
    validationResult.push(
      errorBuilder.generalError(
        "Attribute <b>perItem</b> is incompatible with attribute <b>perRegion</b>. " +
          "They define two different modes. However <b>perRegion</b> works fine even with multi-item mode of object tags.",
      ),
    );
  }

  return validationResult;
};

/**
 * Convert MST type to a human-readable string
 * @param {import("mobx-state-tree").IType} type
 */
const humanizeTypeName = (type) => {
  return type ? getTypeDescription(type, false) : null;
};

export class ConfigValidator {
  /**
   * Validate node attributes and compatibility with other nodes
   * @param {*} node
   */
  static validate(root) {
    const flatTree = [];

    flattenTree(root, null, [], flatTree);
    const propertiesToSkip = ["id", "children", "name", "toname", "controlledTags", "parentTypes"];
    const validationResult = [];

    for (const child of flatTree) {
      try {
        const model = Registry.getModelByTag(child.type);
        // Validate name attribute
        const nameValidation = validateNameTag(child, model);

        if (nameValidation !== null) validationResult.push(nameValidation);

        // Validate toName attribute
        const toNameValidation = validateToNameTag(child, model, flatTree);

        if (toNameValidation !== null) validationResult.push(toNameValidation);

        // Validate by parentUnexpected parent tag
        const parentValidation = validateParentTag(child, model);

        if (parentValidation !== null) validationResult.push(parentValidation);

        validationResult.push(...validatePerRegion(child));

        validationResult.push(...validateAttributes(child, model, propertiesToSkip));
      } catch (e) {
        validationResult.push(errorBuilder.unknownTag(child.type, child.name, child.type));
      }
    }

    if (validationResult.length) {
      return validationResult.map((error) => ({
        ...error,
        validType: humanizeTypeName(error.validType),
      }));
    }

    return [];
  }
}