/**
 * @fileoverview Rule to replace assignment expressions with logical operator assignment
 * @author Daniel Martens
 */
'use strict';

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

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

const baseTypes = new Set(['Identifier', 'Super', 'ThisExpression']);

/**
 * Returns true iff either "undefined" or a void expression (eg. "void 0")
 * @param {ASTNode} expression Expression to check
 * @param {import('eslint-scope').Scope} scope Scope of the expression
 * @returns {boolean} True iff "undefined" or "void ..."
 */
function isUndefined(expression, scope) {
  if (expression.type === 'Identifier' && expression.name === 'undefined') {
    return astUtils.isReferenceToGlobalVariable(scope, expression);
  }

  return (
    expression.type === 'UnaryExpression' &&
    expression.operator === 'void' &&
    expression.argument.type === 'Literal' &&
    expression.argument.value === 0
  );
}

/**
 * Returns true iff the reference is either an identifier or member expression
 * @param {ASTNode} expression Expression to check
 * @returns {boolean} True for identifiers and member expressions
 */
function isReference(expression) {
  return (
    (expression.type === 'Identifier' && expression.name !== 'undefined') ||
    expression.type === 'MemberExpression'
  );
}

/**
 * Returns true iff the expression checks for nullish with loose equals.
 * Examples: value == null, value == void 0
 * @param {ASTNode} expression Test condition
 * @param {import('eslint-scope').Scope} scope Scope of the expression
 * @returns {boolean} True iff implicit nullish comparison
 */
function isImplicitNullishComparison(expression, scope) {
  if (expression.type !== 'BinaryExpression' || expression.operator !== '==') {
    return false;
  }

  const reference = isReference(expression.left) ? 'left' : 'right';
  const nullish = reference === 'left' ? 'right' : 'left';

  return (
    isReference(expression[reference]) &&
    (astUtils.isNullLiteral(expression[nullish]) ||
      isUndefined(expression[nullish], scope))
  );
}

/**
 * Condition with two equal comparisons.
 * @param {ASTNode} expression Condition
 * @returns {boolean} True iff matches ? === ? || ? === ?
 */
function isDoubleComparison(expression) {
  return (
    expression.type === 'LogicalExpression' &&
    expression.operator === '||' &&
    expression.left.type === 'BinaryExpression' &&
    expression.left.operator === '===' &&
    expression.right.type === 'BinaryExpression' &&
    expression.right.operator === '==='
  );
}

/**
 * Returns true iff the expression checks for undefined and null.
 * Example: value === null || value === undefined
 * @param {ASTNode} expression Test condition
 * @param {import('eslint-scope').Scope} scope Scope of the expression
 * @returns {boolean} True iff explicit nullish comparison
 */
function isExplicitNullishComparison(expression, scope) {
  if (!isDoubleComparison(expression)) {
    return false;
  }
  const leftReference = isReference(expression.left.left) ? 'left' : 'right';
  const leftNullish = leftReference === 'left' ? 'right' : 'left';
  const rightReference = isReference(expression.right.left) ? 'left' : 'right';
  const rightNullish = rightReference === 'left' ? 'right' : 'left';

  return (
    astUtils.isSameReference(
      expression.left[leftReference],
      expression.right[rightReference]
    ) &&
    ((astUtils.isNullLiteral(expression.left[leftNullish]) &&
      isUndefined(expression.right[rightNullish], scope)) ||
      (isUndefined(expression.left[leftNullish], scope) &&
        astUtils.isNullLiteral(expression.right[rightNullish])))
  );
}

/**
 * Returns true for Boolean(arg) calls
 * @param {ASTNode} expression Test condition
 * @param {import('eslint-scope').Scope} scope Scope of the expression
 * @returns {boolean} Whether the expression is a boolean cast
 */
function isBooleanCast(expression, scope) {
  return (
    expression.type === 'CallExpression' &&
    expression.callee.name === 'Boolean' &&
    expression.arguments.length === 1 &&
    astUtils.isReferenceToGlobalVariable(scope, expression.callee)
  );
}

/**
 * Returns true for:
 * truthiness checks:  value, Boolean(value), !!value
 * falsiness checks:   !value, !Boolean(value)
 * nullish checks:     value == null, value === undefined || value === null
 * @param {ASTNode} expression Test condition
 * @param {import('eslint-scope').Scope} scope Scope of the expression
 * @returns {?{ reference: ASTNode, operator: '??'|'||'|'&&'}} Null if not a known existence
 */
function getExistence(expression, scope) {
  const isNegated =
    expression.type === 'UnaryExpression' && expression.operator === '!';
  const base = isNegated ? expression.argument : expression;

  switch (true) {
    case isReference(base):
      return { reference: base, operator: isNegated ? '||' : '&&' };
    case base.type === 'UnaryExpression' &&
      base.operator === '!' &&
      isReference(base.argument):
      return { reference: base.argument, operator: '&&' };
    case isBooleanCast(base, scope) && isReference(base.arguments[0]):
      return {
        reference: base.arguments[0],
        operator: isNegated ? '||' : '&&',
      };
    case isImplicitNullishComparison(expression, scope):
      return {
        reference:
          isReference(expression.left) ? expression.left : expression.right,
        operator: '??',
      };
    case isExplicitNullishComparison(expression, scope):
      return {
        reference:
          isReference(expression.left.left) ?
            expression.left.left
          : expression.left.right,
        operator: '??',
      };
    default:
      return null;
  }
}

/**
 * Returns true iff the node is inside a with block
 * @param {ASTNode} node Node to check
 * @returns {boolean} True iff passed node is inside a with block
 */
function isInsideWithBlock(node) {
  if (node.type === 'Program') {
    return false;
  }

  return node.parent.type === 'WithStatement' && node.parent.body === node ?
      true
    : isInsideWithBlock(node.parent);
}

/**
 * Gets the leftmost operand of a consecutive logical expression.
 * @param {SourceCode} sourceCode The ESLint source code object
 * @param {LogicalExpression} node LogicalExpression
 * @returns {Expression} Leftmost operand
 */
function getLeftmostOperand(sourceCode, node) {
  let left = node.left;

  while (left.type === 'LogicalExpression' && left.operator === node.operator) {
    if (astUtils.isParenthesised(sourceCode, left)) {
      /*
       * It should have associativity,
       * but ignore it if use parentheses to make the evaluation order clear.
       */
      return left;
    }
    left = left.left;
  }
  return left;
}

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

    docs: {
      description: 'Require or disallow logical assignment operator shorthand',
      recommended: false,
      frozen: true,
      url: 'https://eslint.org/docs/latest/rules/logical-assignment-operators',
    },

    schema: {
      type: 'array',
      oneOf: [
        {
          items: [
            { const: 'always' },
            {
              type: 'object',
              properties: {
                enforceForIfStatements: {
                  type: 'boolean',
                },
              },
              additionalProperties: false,
            },
          ],
          minItems: 0, // 0 for allowing passing no options
          maxItems: 2,
        },
        {
          items: [{ const: 'never' }],
          minItems: 1,
          maxItems: 1,
        },
      ],
    },
    fixable: 'code',
    hasSuggestions: true,
    messages: {
      assignment:
        'Assignment (=) can be replaced with operator assignment ({{operator}}).',
      useLogicalOperator:
        'Convert this assignment to use the operator {{ operator }}.',
      logical:
        'Logical expression can be replaced with an assignment ({{ operator }}).',
      convertLogical:
        'Replace this logical expression with an assignment with the operator {{ operator }}.',
      if: "'if' statement can be replaced with a logical operator assignment with operator {{ operator }}.",
      convertIf:
        "Replace this 'if' statement with a logical assignment with operator {{ operator }}.",
      unexpected:
        'Unexpected logical operator assignment ({{operator}}) shorthand.',
      separate:
        'Separate the logical assignment into an assignment with a logical operator.',
    },
  },

  create(context) {
    const mode = context.options[0] === 'never' ? 'never' : 'always';
    const checkIf =
      mode === 'always' &&
      context.options.length > 1 &&
      context.options[1].enforceForIfStatements;
    const sourceCode = context.sourceCode;
    const isStrict = sourceCode.getScope(sourceCode.ast).isStrict;

    /**
     * Returns false if the access could be a getter
     * @param {ASTNode} node Assignment expression
     * @returns {boolean} True iff the fix is safe
     */
    function cannotBeGetter(node) {
      return (
        node.type === 'Identifier' && (isStrict || !isInsideWithBlock(node))
      );
    }

    /**
     * Check whether only a single property is accessed
     * @param {ASTNode} node reference
     * @returns {boolean} True iff a single property is accessed
     */
    function accessesSingleProperty(node) {
      if (!isStrict && isInsideWithBlock(node)) {
        return node.type === 'Identifier';
      }

      return (
        node.type === 'MemberExpression' &&
        baseTypes.has(node.object.type) &&
        (!node.computed ||
          (node.property.type !== 'MemberExpression' &&
            node.property.type !== 'ChainExpression'))
      );
    }

    /**
     * Adds a fixer or suggestion whether on the fix is safe.
     * @param {{ messageId: string, node: ASTNode }} descriptor Report descriptor without fix or suggest
     * @param {{ messageId: string, fix: Function }} suggestion Adds the fix or the whole suggestion as only element in "suggest" to suggestion
     * @param {boolean} shouldBeFixed Fix iff the condition is true
     * @returns {Object} Descriptor with either an added fix or suggestion
     */
    function createConditionalFixer(descriptor, suggestion, shouldBeFixed) {
      if (shouldBeFixed) {
        return {
          ...descriptor,
          fix: suggestion.fix,
        };
      }

      return {
        ...descriptor,
        suggest: [suggestion],
      };
    }

    /**
     * Returns the operator token for assignments and binary expressions
     * @param {ASTNode} node AssignmentExpression or BinaryExpression
     * @returns {import('eslint').AST.Token} Operator token between the left and right expression
     */
    function getOperatorToken(node) {
      return sourceCode.getFirstTokenBetween(
        node.left,
        node.right,
        (token) => token.value === node.operator
      );
    }

    if (mode === 'never') {
      return {
        // foo ||= bar
        AssignmentExpression(assignment) {
          if (!astUtils.isLogicalAssignmentOperator(assignment.operator)) {
            return;
          }

          const descriptor = {
            messageId: 'unexpected',
            node: assignment,
            data: { operator: assignment.operator },
          };
          const suggestion = {
            messageId: 'separate',
            *fix(ruleFixer) {
              if (sourceCode.getCommentsInside(assignment).length > 0) {
                return;
              }

              const operatorToken = getOperatorToken(assignment);

              // -> foo = bar
              yield ruleFixer.replaceText(operatorToken, '=');

              const assignmentText = sourceCode.getText(assignment.left);
              const operator = assignment.operator.slice(0, -1);

              // -> foo = foo || bar
              yield ruleFixer.insertTextAfter(
                operatorToken,
                ` ${assignmentText} ${operator}`
              );

              const precedence =
                astUtils.getPrecedence(assignment.right) <=
                astUtils.getPrecedence({
                  type: 'LogicalExpression',
                  operator,
                });

              // ?? and || / && cannot be mixed but have same precedence
              const mixed =
                assignment.operator === '??=' &&
                astUtils.isLogicalExpression(assignment.right);

              if (
                !astUtils.isParenthesised(sourceCode, assignment.right) &&
                (precedence || mixed)
              ) {
                // -> foo = foo || (bar)
                yield ruleFixer.insertTextBefore(assignment.right, '(');
                yield ruleFixer.insertTextAfter(assignment.right, ')');
              }
            },
          };

          context.report(
            createConditionalFixer(
              descriptor,
              suggestion,
              cannotBeGetter(assignment.left)
            )
          );
        },
      };
    }

    return {
      // foo = foo || bar
      "AssignmentExpression[operator='='][right.type='LogicalExpression']"(
        assignment
      ) {
        const leftOperand = getLeftmostOperand(sourceCode, assignment.right);

        if (!astUtils.isSameReference(assignment.left, leftOperand)) {
          return;
        }

        const descriptor = {
          messageId: 'assignment',
          node: assignment,
          data: { operator: `${assignment.right.operator}=` },
        };
        const suggestion = {
          messageId: 'useLogicalOperator',
          data: { operator: `${assignment.right.operator}=` },
          *fix(ruleFixer) {
            if (sourceCode.getCommentsInside(assignment).length > 0) {
              return;
            }

            // No need for parenthesis around the assignment based on precedence as the precedence stays the same even with changed operator
            const assignmentOperatorToken = getOperatorToken(assignment);

            // -> foo ||= foo || bar
            yield ruleFixer.insertTextBefore(
              assignmentOperatorToken,
              assignment.right.operator
            );

            // -> foo ||= bar
            const logicalOperatorToken = getOperatorToken(leftOperand.parent);
            const firstRightOperandToken =
              sourceCode.getTokenAfter(logicalOperatorToken);

            yield ruleFixer.removeRange([
              leftOperand.parent.range[0],
              firstRightOperandToken.range[0],
            ]);
          },
        };

        context.report(
          createConditionalFixer(
            descriptor,
            suggestion,
            cannotBeGetter(assignment.left)
          )
        );
      },

      // foo || (foo = bar)
      'LogicalExpression[right.type="AssignmentExpression"][right.operator="="]'(
        logical
      ) {
        // Right side has to be parenthesized, otherwise would be parsed as (foo || foo) = bar which is illegal
        if (
          isReference(logical.left) &&
          astUtils.isSameReference(logical.left, logical.right.left)
        ) {
          const descriptor = {
            messageId: 'logical',
            node: logical,
            data: { operator: `${logical.operator}=` },
          };
          const suggestion = {
            messageId: 'convertLogical',
            data: { operator: `${logical.operator}=` },
            *fix(ruleFixer) {
              if (sourceCode.getCommentsInside(logical).length > 0) {
                return;
              }

              const parentPrecedence = astUtils.getPrecedence(logical.parent);
              const requiresOuterParenthesis =
                logical.parent.type !== 'ExpressionStatement' &&
                (parentPrecedence === -1 ||
                  astUtils.getPrecedence({
                    type: 'AssignmentExpression',
                  }) < parentPrecedence);

              if (
                !astUtils.isParenthesised(sourceCode, logical) &&
                requiresOuterParenthesis
              ) {
                yield ruleFixer.insertTextBefore(logical, '(');
                yield ruleFixer.insertTextAfter(logical, ')');
              }

              // Also removes all opening parenthesis
              yield ruleFixer.removeRange([
                logical.range[0],
                logical.right.range[0],
              ]); // -> foo = bar)

              // Also removes all ending parenthesis
              yield ruleFixer.removeRange([
                logical.right.range[1],
                logical.range[1],
              ]); // -> foo = bar

              const operatorToken = getOperatorToken(logical.right);

              yield ruleFixer.insertTextBefore(operatorToken, logical.operator); // -> foo ||= bar
            },
          };
          const fix =
            cannotBeGetter(logical.left) ||
            accessesSingleProperty(logical.left);

          context.report(createConditionalFixer(descriptor, suggestion, fix));
        }
      },

      // if (foo) foo = bar
      'IfStatement[alternate=null]'(ifNode) {
        if (!checkIf) {
          return;
        }

        const hasBody = ifNode.consequent.type === 'BlockStatement';

        if (hasBody && ifNode.consequent.body.length !== 1) {
          return;
        }

        const body = hasBody ? ifNode.consequent.body[0] : ifNode.consequent;
        const scope = sourceCode.getScope(ifNode);
        const existence = getExistence(ifNode.test, scope);

        if (
          body.type === 'ExpressionStatement' &&
          body.expression.type === 'AssignmentExpression' &&
          body.expression.operator === '=' &&
          existence !== null &&
          astUtils.isSameReference(existence.reference, body.expression.left)
        ) {
          const descriptor = {
            messageId: 'if',
            node: ifNode,
            data: { operator: `${existence.operator}=` },
          };
          const suggestion = {
            messageId: 'convertIf',
            data: { operator: `${existence.operator}=` },
            *fix(ruleFixer) {
              if (sourceCode.getCommentsInside(ifNode).length > 0) {
                return;
              }

              const firstBodyToken = sourceCode.getFirstToken(body);
              const prevToken = sourceCode.getTokenBefore(ifNode);

              if (
                prevToken !== null &&
                prevToken.value !== ';' &&
                prevToken.value !== '{' &&
                firstBodyToken.type !== 'Identifier' &&
                firstBodyToken.type !== 'Keyword'
              ) {
                // Do not fix if the fixed statement could be part of the previous statement (eg. fn() if (a == null) (a) = b --> fn()(a) ??= b)
                return;
              }

              const operatorToken = getOperatorToken(body.expression);

              yield ruleFixer.insertTextBefore(
                operatorToken,
                existence.operator
              ); // -> if (foo) foo ||= bar

              yield ruleFixer.removeRange([ifNode.range[0], body.range[0]]); // -> foo ||= bar

              yield ruleFixer.removeRange([body.range[1], ifNode.range[1]]); // -> foo ||= bar, only present if "if" had a body

              const nextToken = sourceCode.getTokenAfter(body.expression);

              if (hasBody && nextToken !== null && nextToken.value !== ';') {
                yield ruleFixer.insertTextAfter(ifNode, ';');
              }
            },
          };
          const shouldBeFixed =
            cannotBeGetter(existence.reference) ||
            (ifNode.test.type !== 'LogicalExpression' &&
              accessesSingleProperty(existence.reference));

          context.report(
            createConditionalFixer(descriptor, suggestion, shouldBeFixed)
          );
        }
      },
    };
  },
};