/**
 * @fileoverview Rule to disallow duplicate conditions in if-else-if chains
 * @author Milos Djermanovic
 */

'use strict';

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const astUtils = require('./utils/ast-utils');

//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------

/**
 * Determines whether the first given array is a subset of the second given array.
 * @param {Function} comparator A function to compare two elements, should return `true` if they are equal.
 * @param {Array} arrA The array to compare from.
 * @param {Array} arrB The array to compare against.
 * @returns {boolean} `true` if the array `arrA` is a subset of the array `arrB`.
 */
function isSubsetByComparator(comparator, arrA, arrB) {
  return arrA.every((a) => arrB.some((b) => comparator(a, b)));
}

/**
 * Splits the given node by the given logical operator.
 * @param {string} operator Logical operator `||` or `&&`.
 * @param {ASTNode} node The node to split.
 * @returns {ASTNode[]} Array of conditions that makes the node when joined by the operator.
 */
function splitByLogicalOperator(operator, node) {
  if (node.type === 'LogicalExpression' && node.operator === operator) {
    return [
      ...splitByLogicalOperator(operator, node.left),
      ...splitByLogicalOperator(operator, node.right),
    ];
  }
  return [node];
}

const splitByOr = splitByLogicalOperator.bind(null, '||');
const splitByAnd = splitByLogicalOperator.bind(null, '&&');

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
  meta: {
    type: 'problem',

    docs: {
      description: 'Disallow duplicate conditions in if-else-if chains',
      recommended: true,
      url: 'https://eslint.org/docs/latest/rules/no-dupe-else-if',
    },

    schema: [],

    messages: {
      unexpected:
        'This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain.',
    },
  },

  create(context) {
    const sourceCode = context.sourceCode;

    /**
     * Determines whether the two given nodes are considered to be equal. In particular, given that the nodes
     * represent expressions in a boolean context, `||` and `&&` can be considered as commutative operators.
     * @param {ASTNode} a First node.
     * @param {ASTNode} b Second node.
     * @returns {boolean} `true` if the nodes are considered to be equal.
     */
    function equal(a, b) {
      if (a.type !== b.type) {
        return false;
      }

      if (
        a.type === 'LogicalExpression' &&
        (a.operator === '||' || a.operator === '&&') &&
        a.operator === b.operator
      ) {
        return (
          (equal(a.left, b.left) && equal(a.right, b.right)) ||
          (equal(a.left, b.right) && equal(a.right, b.left))
        );
      }

      return astUtils.equalTokens(a, b, sourceCode);
    }

    const isSubset = isSubsetByComparator.bind(null, equal);

    return {
      IfStatement(node) {
        const test = node.test,
          conditionsToCheck =
            test.type === 'LogicalExpression' && test.operator === '&&' ?
              [test, ...splitByAnd(test)]
            : [test];
        let current = node,
          listToCheck = conditionsToCheck.map((c) =>
            splitByOr(c).map(splitByAnd)
          );

        while (
          current.parent &&
          current.parent.type === 'IfStatement' &&
          current.parent.alternate === current
        ) {
          current = current.parent;

          const currentOrOperands = splitByOr(current.test).map(splitByAnd);

          listToCheck = listToCheck.map((orOperands) =>
            orOperands.filter(
              (orOperand) =>
                !currentOrOperands.some((currentOrOperand) =>
                  isSubset(currentOrOperand, orOperand)
                )
            )
          );

          if (listToCheck.some((orOperands) => orOperands.length === 0)) {
            context.report({ node: test, messageId: 'unexpected' });
            break;
          }
        }
      },
    };
  },
};