/**
 * @fileoverview Rule to flag unnecessary double negation in Boolean contexts
 * @author Brandon Mills
 */

'use strict';

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

const astUtils = require('./utils/ast-utils');
const eslintUtils = require('@eslint-community/eslint-utils');

const precedence = astUtils.getPrecedence;

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

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

    defaultOptions: [{}],

    docs: {
      description: 'Disallow unnecessary boolean casts',
      recommended: true,
      frozen: true,
      url: 'https://eslint.org/docs/latest/rules/no-extra-boolean-cast',
    },

    schema: [
      {
        anyOf: [
          {
            type: 'object',
            properties: {
              enforceForInnerExpressions: {
                type: 'boolean',
              },
            },
            additionalProperties: false,
          },

          // deprecated
          {
            type: 'object',
            properties: {
              enforceForLogicalOperands: {
                type: 'boolean',
              },
            },
            additionalProperties: false,
          },
        ],
      },
    ],
    fixable: 'code',

    messages: {
      unexpectedCall: 'Redundant Boolean call.',
      unexpectedNegation: 'Redundant double negation.',
    },
  },

  create(context) {
    const sourceCode = context.sourceCode;
    const [{ enforceForLogicalOperands, enforceForInnerExpressions }] =
      context.options;

    // Node types which have a test which will coerce values to booleans.
    const BOOLEAN_NODE_TYPES = new Set([
      'IfStatement',
      'DoWhileStatement',
      'WhileStatement',
      'ConditionalExpression',
      'ForStatement',
    ]);

    /**
     * Check if a node is a Boolean function or constructor.
     * @param {ASTNode} node the node
     * @returns {boolean} If the node is Boolean function or constructor
     */
    function isBooleanFunctionOrConstructorCall(node) {
      // Boolean(<bool>) and new Boolean(<bool>)
      return (
        (node.type === 'CallExpression' || node.type === 'NewExpression') &&
        node.callee.type === 'Identifier' &&
        node.callee.name === 'Boolean'
      );
    }

    /**
     * Check if a node is in a context where its value would be coerced to a boolean at runtime.
     * @param {ASTNode} node The node
     * @returns {boolean} If it is in a boolean context
     */
    function isInBooleanContext(node) {
      return (
        (isBooleanFunctionOrConstructorCall(node.parent) &&
          node === node.parent.arguments[0]) ||
        (BOOLEAN_NODE_TYPES.has(node.parent.type) &&
          node === node.parent.test) ||
        // !<bool>
        (node.parent.type === 'UnaryExpression' && node.parent.operator === '!')
      );
    }

    /**
     * Checks whether the node is a context that should report an error
     * Acts recursively if it is in a logical context
     * @param {ASTNode} node the node
     * @returns {boolean} If the node is in one of the flagged contexts
     */
    function isInFlaggedContext(node) {
      if (node.parent.type === 'ChainExpression') {
        return isInFlaggedContext(node.parent);
      }

      /*
       * legacy behavior - enforceForLogicalOperands will only recurse on
       * logical expressions, not on other contexts.
       * enforceForInnerExpressions will recurse on logical expressions
       * as well as the other recursive syntaxes.
       */

      if (enforceForLogicalOperands || enforceForInnerExpressions) {
        if (node.parent.type === 'LogicalExpression') {
          if (node.parent.operator === '||' || node.parent.operator === '&&') {
            return isInFlaggedContext(node.parent);
          }

          // Check the right hand side of a `??` operator.
          if (
            enforceForInnerExpressions &&
            node.parent.operator === '??' &&
            node.parent.right === node
          ) {
            return isInFlaggedContext(node.parent);
          }
        }
      }

      if (enforceForInnerExpressions) {
        if (
          node.parent.type === 'ConditionalExpression' &&
          (node.parent.consequent === node || node.parent.alternate === node)
        ) {
          return isInFlaggedContext(node.parent);
        }

        /*
         * Check last expression only in a sequence, i.e. if ((1, 2, Boolean(3))) {}, since
         * the others don't affect the result of the expression.
         */
        if (
          node.parent.type === 'SequenceExpression' &&
          node.parent.expressions.at(-1) === node
        ) {
          return isInFlaggedContext(node.parent);
        }
      }

      return isInBooleanContext(node);
    }

    /**
     * Check if a node has comments inside.
     * @param {ASTNode} node The node to check.
     * @returns {boolean} `true` if it has comments inside.
     */
    function hasCommentsInside(node) {
      return Boolean(sourceCode.getCommentsInside(node).length);
    }

    /**
     * Checks if the given node is wrapped in grouping parentheses. Parentheses for constructs such as if() don't count.
     * @param {ASTNode} node The node to check.
     * @returns {boolean} `true` if the node is parenthesized.
     * @private
     */
    function isParenthesized(node) {
      return eslintUtils.isParenthesized(1, node, sourceCode);
    }

    /**
     * Determines whether the given node needs to be parenthesized when replacing the previous node.
     * It assumes that `previousNode` is the node to be reported by this rule, so it has a limited list
     * of possible parent node types. By the same assumption, the node's role in a particular parent is already known.
     * @param {ASTNode} previousNode Previous node.
     * @param {ASTNode} node The node to check.
     * @throws {Error} (Unreachable.)
     * @returns {boolean} `true` if the node needs to be parenthesized.
     */
    function needsParens(previousNode, node) {
      if (previousNode.parent.type === 'ChainExpression') {
        return needsParens(previousNode.parent, node);
      }

      if (isParenthesized(previousNode)) {
        // parentheses around the previous node will stay, so there is no need for an additional pair
        return false;
      }

      // parent of the previous node will become parent of the replacement node
      const parent = previousNode.parent;

      switch (parent.type) {
        case 'CallExpression':
        case 'NewExpression':
          return node.type === 'SequenceExpression';
        case 'IfStatement':
        case 'DoWhileStatement':
        case 'WhileStatement':
        case 'ForStatement':
        case 'SequenceExpression':
          return false;
        case 'ConditionalExpression':
          if (previousNode === parent.test) {
            return precedence(node) <= precedence(parent);
          }
          if (
            previousNode === parent.consequent ||
            previousNode === parent.alternate
          ) {
            return (
              precedence(node) < precedence({ type: 'AssignmentExpression' })
            );
          }

          /* c8 ignore next */
          throw new Error(
            'Ternary child must be test, consequent, or alternate.'
          );
        case 'UnaryExpression':
          return precedence(node) < precedence(parent);
        case 'LogicalExpression':
          if (astUtils.isMixedLogicalAndCoalesceExpressions(node, parent)) {
            return true;
          }
          if (previousNode === parent.left) {
            return precedence(node) < precedence(parent);
          }
          return precedence(node) <= precedence(parent);

        /* c8 ignore next */
        default:
          throw new Error(`Unexpected parent type: ${parent.type}`);
      }
    }

    return {
      UnaryExpression(node) {
        const parent = node.parent;

        // Exit early if it's guaranteed not to match
        if (
          node.operator !== '!' ||
          parent.type !== 'UnaryExpression' ||
          parent.operator !== '!'
        ) {
          return;
        }

        if (isInFlaggedContext(parent)) {
          context.report({
            node: parent,
            messageId: 'unexpectedNegation',
            fix(fixer) {
              if (hasCommentsInside(parent)) {
                return null;
              }

              if (needsParens(parent, node.argument)) {
                return fixer.replaceText(
                  parent,
                  `(${sourceCode.getText(node.argument)})`
                );
              }

              let prefix = '';
              const tokenBefore = sourceCode.getTokenBefore(parent);
              const firstReplacementToken = sourceCode.getFirstToken(
                node.argument
              );

              if (
                tokenBefore &&
                tokenBefore.range[1] === parent.range[0] &&
                !astUtils.canTokensBeAdjacent(
                  tokenBefore,
                  firstReplacementToken
                )
              ) {
                prefix = ' ';
              }

              return fixer.replaceText(
                parent,
                prefix + sourceCode.getText(node.argument)
              );
            },
          });
        }
      },

      CallExpression(node) {
        if (
          node.callee.type !== 'Identifier' ||
          node.callee.name !== 'Boolean'
        ) {
          return;
        }

        if (isInFlaggedContext(node)) {
          context.report({
            node,
            messageId: 'unexpectedCall',
            fix(fixer) {
              const parent = node.parent;

              if (node.arguments.length === 0) {
                if (
                  parent.type === 'UnaryExpression' &&
                  parent.operator === '!'
                ) {
                  /*
                   * !Boolean() -> true
                   */

                  if (hasCommentsInside(parent)) {
                    return null;
                  }

                  const replacement = 'true';
                  let prefix = '';
                  const tokenBefore = sourceCode.getTokenBefore(parent);

                  if (
                    tokenBefore &&
                    tokenBefore.range[1] === parent.range[0] &&
                    !astUtils.canTokensBeAdjacent(tokenBefore, replacement)
                  ) {
                    prefix = ' ';
                  }

                  return fixer.replaceText(parent, prefix + replacement);
                }

                /*
                 * Boolean() -> false
                 */

                if (hasCommentsInside(node)) {
                  return null;
                }

                return fixer.replaceText(node, 'false');
              }

              if (node.arguments.length === 1) {
                const argument = node.arguments[0];

                if (
                  argument.type === 'SpreadElement' ||
                  hasCommentsInside(node)
                ) {
                  return null;
                }

                /*
                 * Boolean(expression) -> expression
                 */

                if (needsParens(node, argument)) {
                  return fixer.replaceText(
                    node,
                    `(${sourceCode.getText(argument)})`
                  );
                }

                return fixer.replaceText(node, sourceCode.getText(argument));
              }

              // two or more arguments
              return null;
            },
          });
        }
      },
    };
  },
};