/* @flow */
"use strict";

const _ = require("lodash");

const ignoredOptions = ["severity", "message"];

/**
 * Validate a rule's options.
 *
 * See existing rules for examples.
 *
 * @param {Result} result - postcss result
 * @param {string} ruleName
 * @param {...object} ...optionDescriptions - Each optionDescription can
 *   have the following properties:
 *   	- `actual` (required): the actual passed option value or object.
 *   	- `possible` (required): a schema representation of what values are
 *      valid for those options. `possible` should be an object if the
 *      options are an object, with corresponding keys; if the options are not an
 *      object, `possible` isn't, either. All `possible` value representations
 *      should be **arrays of either values or functions**. Values are === checked
 *      against `actual`. Functions are fed `actual` as an argument and their
 *      return value is interpreted: truthy = valid, falsy = invalid.
 *    - `optional` (optional): If this is `true`, `actual` can be undefined.
 * @return {boolean} Whether or not the options are valid (true = valid)
 */

module.exports = function(
  result /*: Object*/,
  ruleName /*: string*/
) /*: boolean*/ {
  let noErrors = true;

  const optionDescriptions = Array.from(arguments).slice(2);

  optionDescriptions.forEach(optionDescription => {
    validate(optionDescription, ruleName, complain);
  });

  function complain(message) {
    noErrors = false;
    result.warn(message, {
      stylelintType: "invalidOption"
    });
    _.set(result, "stylelint.stylelintError", true);
  }

  return noErrors;
};

function validate(
  opts /*: {possible: any, actual: any, optional: boolean} */,
  ruleName /*: string */,
  complain /*: Function */
) {
  const possible = opts.possible;
  const actual = opts.actual;
  const optional = opts.optional;

  if (actual === null || _.isEqual(actual, [null])) {
    return;
  }

  const nothingPossible =
    possible === undefined ||
    (Array.isArray(possible) && possible.length === 0);

  if (nothingPossible && actual === true) {
    return;
  }

  if (actual === undefined) {
    if (nothingPossible || optional) {
      return;
    }

    complain(`Expected option value for rule "${ruleName}"`);

    return;
  } else if (nothingPossible) {
    if (optional) {
      complain(
        `Incorrect configuration for rule "${ruleName}". Rule should have "possible" values for options validation`
      );

      return;
    }

    complain(
      `Unexpected option value "${String(actual)}" for rule "${ruleName}"`
    );

    return;
  }

  // If `possible` is a function ...
  if (_.isFunction(possible)) {
    if (!possible(actual)) {
      complain(
        `Invalid option "${JSON.stringify(actual)}" for rule ${ruleName}`
      );
    }

    return;
  }

  // If `possible` is an array instead of an object ...
  if (!_.isPlainObject(possible)) {
    [].concat(actual).forEach(a => {
      if (isValid(possible, a)) {
        return;
      }

      complain(`Invalid option value "${String(a)}" for rule "${ruleName}"`);
    });

    return;
  }

  // If actual is NOT an object ...
  if (typeof actual !== "object") {
    complain(
      `Invalid option value ${JSON.stringify(
        actual
      )} for rule "${ruleName}": ` + "should be an object"
    );

    return;
  }

  Object.keys(actual).forEach(optionName => {
    if (ignoredOptions.indexOf(optionName) !== -1) {
      return;
    }

    if (!possible[optionName]) {
      complain(`Invalid option name "${optionName}" for rule "${ruleName}"`);

      return;
    }

    const actualOptionValue = actual[optionName];

    [].concat(actualOptionValue).forEach(a => {
      if (isValid(possible[optionName], a)) {
        return;
      }

      complain(
        `Invalid value "${a}" for option "${optionName}" of rule "${ruleName}"`
      );
    });
  });
}

function isValid(possible, actual) {
  const possibleList = [].concat(possible);

  for (let i = 0, l = possibleList.length; i < l; i++) {
    const possibility = possibleList[i];

    if (typeof possibility === "function" && possibility(actual)) {
      return true;
    }

    if (actual === possibility) {
      return true;
    }
  }
}