/**
 * @fileoverview Operator linebreak - enforces operator linebreak style of two types: after and before
 * @author Benoît Zugmeyer
 * @deprecated in ESLint v8.53.0
 */

'use strict';

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

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

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

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
  meta: {
    deprecated: {
      message: 'Formatting rules are being moved out of ESLint core.',
      url: 'https://eslint.org/blog/2023/10/deprecating-formatting-rules/',
      deprecatedSince: '8.53.0',
      availableUntil: '10.0.0',
      replacedBy: [
        {
          message:
            'ESLint Stylistic now maintains deprecated stylistic core rules.',
          url: 'https://eslint.style/guide/migration',
          plugin: {
            name: '@stylistic/eslint-plugin-js',
            url: 'https://eslint.style/packages/js',
          },
          rule: {
            name: 'operator-linebreak',
            url: 'https://eslint.style/rules/js/operator-linebreak',
          },
        },
      ],
    },
    type: 'layout',

    docs: {
      description: 'Enforce consistent linebreak style for operators',
      recommended: false,
      url: 'https://eslint.org/docs/latest/rules/operator-linebreak',
    },

    schema: [
      {
        enum: ['after', 'before', 'none', null],
      },
      {
        type: 'object',
        properties: {
          overrides: {
            type: 'object',
            additionalProperties: {
              enum: ['after', 'before', 'none', 'ignore'],
            },
          },
        },
        additionalProperties: false,
      },
    ],

    fixable: 'code',

    messages: {
      operatorAtBeginning:
        "'{{operator}}' should be placed at the beginning of the line.",
      operatorAtEnd: "'{{operator}}' should be placed at the end of the line.",
      badLinebreak: "Bad line breaking before and after '{{operator}}'.",
      noLinebreak:
        "There should be no line break before or after '{{operator}}'.",
    },
  },

  create(context) {
    const usedDefaultGlobal = !context.options[0];
    const globalStyle = context.options[0] || 'after';
    const options = context.options[1] || {};
    const styleOverrides =
      options.overrides ? Object.assign({}, options.overrides) : {};

    if (usedDefaultGlobal && !styleOverrides['?']) {
      styleOverrides['?'] = 'before';
    }

    if (usedDefaultGlobal && !styleOverrides[':']) {
      styleOverrides[':'] = 'before';
    }

    const sourceCode = context.sourceCode;

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

    /**
     * Gets a fixer function to fix rule issues
     * @param {Token} operatorToken The operator token of an expression
     * @param {string} desiredStyle The style for the rule. One of 'before', 'after', 'none'
     * @returns {Function} A fixer function
     */
    function getFixer(operatorToken, desiredStyle) {
      return (fixer) => {
        const tokenBefore = sourceCode.getTokenBefore(operatorToken);
        const tokenAfter = sourceCode.getTokenAfter(operatorToken);
        const textBefore = sourceCode.text.slice(
          tokenBefore.range[1],
          operatorToken.range[0]
        );
        const textAfter = sourceCode.text.slice(
          operatorToken.range[1],
          tokenAfter.range[0]
        );
        const hasLinebreakBefore = !astUtils.isTokenOnSameLine(
          tokenBefore,
          operatorToken
        );
        const hasLinebreakAfter = !astUtils.isTokenOnSameLine(
          operatorToken,
          tokenAfter
        );
        let newTextBefore, newTextAfter;

        if (
          hasLinebreakBefore !== hasLinebreakAfter &&
          desiredStyle !== 'none'
        ) {
          // If there is a comment before and after the operator, don't do a fix.
          if (
            sourceCode.getTokenBefore(operatorToken, {
              includeComments: true,
            }) !== tokenBefore &&
            sourceCode.getTokenAfter(operatorToken, {
              includeComments: true,
            }) !== tokenAfter
          ) {
            return null;
          }

          /*
           * If there is only one linebreak and it's on the wrong side of the operator, swap the text before and after the operator.
           * foo &&
           *           bar
           * would get fixed to
           * foo
           *        && bar
           */
          newTextBefore = textAfter;
          newTextAfter = textBefore;
        } else {
          const LINEBREAK_REGEX = astUtils.createGlobalLinebreakMatcher();

          // Otherwise, if no linebreak is desired and no comments interfere, replace the linebreaks with empty strings.
          newTextBefore =
            desiredStyle === 'before' || textBefore.trim() ?
              textBefore
            : textBefore.replace(LINEBREAK_REGEX, '');
          newTextAfter =
            desiredStyle === 'after' || textAfter.trim() ?
              textAfter
            : textAfter.replace(LINEBREAK_REGEX, '');

          // If there was no change (due to interfering comments), don't output a fix.
          if (newTextBefore === textBefore && newTextAfter === textAfter) {
            return null;
          }
        }

        if (
          newTextAfter === '' &&
          tokenAfter.type === 'Punctuator' &&
          '+-'.includes(operatorToken.value) &&
          tokenAfter.value === operatorToken.value
        ) {
          // To avoid accidentally creating a ++ or -- operator, insert a space if the operator is a +/- and the following token is a unary +/-.
          newTextAfter += ' ';
        }

        return fixer.replaceTextRange(
          [tokenBefore.range[1], tokenAfter.range[0]],
          newTextBefore + operatorToken.value + newTextAfter
        );
      };
    }

    /**
     * Checks the operator placement
     * @param {ASTNode} node The node to check
     * @param {ASTNode} rightSide The node that comes after the operator in `node`
     * @param {string} operator The operator
     * @private
     * @returns {void}
     */
    function validateNode(node, rightSide, operator) {
      /*
       * Find the operator token by searching from the right side, because between the left side and the operator
       * there could be additional tokens from type annotations. Search specifically for the token which
       * value equals the operator, in order to skip possible opening parentheses before the right side node.
       */
      const operatorToken = sourceCode.getTokenBefore(
        rightSide,
        (token) => token.value === operator
      );
      const leftToken = sourceCode.getTokenBefore(operatorToken);
      const rightToken = sourceCode.getTokenAfter(operatorToken);
      const operatorStyleOverride = styleOverrides[operator];
      const style = operatorStyleOverride || globalStyle;
      const fix = getFixer(operatorToken, style);

      // if single line
      if (
        astUtils.isTokenOnSameLine(leftToken, operatorToken) &&
        astUtils.isTokenOnSameLine(operatorToken, rightToken)
      ) {
        // do nothing.
      } else if (
        operatorStyleOverride !== 'ignore' &&
        !astUtils.isTokenOnSameLine(leftToken, operatorToken) &&
        !astUtils.isTokenOnSameLine(operatorToken, rightToken)
      ) {
        // lone operator
        context.report({
          node,
          loc: operatorToken.loc,
          messageId: 'badLinebreak',
          data: {
            operator,
          },
          fix,
        });
      } else if (
        style === 'before' &&
        astUtils.isTokenOnSameLine(leftToken, operatorToken)
      ) {
        context.report({
          node,
          loc: operatorToken.loc,
          messageId: 'operatorAtBeginning',
          data: {
            operator,
          },
          fix,
        });
      } else if (
        style === 'after' &&
        astUtils.isTokenOnSameLine(operatorToken, rightToken)
      ) {
        context.report({
          node,
          loc: operatorToken.loc,
          messageId: 'operatorAtEnd',
          data: {
            operator,
          },
          fix,
        });
      } else if (style === 'none') {
        context.report({
          node,
          loc: operatorToken.loc,
          messageId: 'noLinebreak',
          data: {
            operator,
          },
          fix,
        });
      }
    }

    /**
     * Validates a binary expression using `validateNode`
     * @param {BinaryExpression|LogicalExpression|AssignmentExpression} node node to be validated
     * @returns {void}
     */
    function validateBinaryExpression(node) {
      validateNode(node, node.right, node.operator);
    }

    //--------------------------------------------------------------------------
    // Public
    //--------------------------------------------------------------------------

    return {
      BinaryExpression: validateBinaryExpression,
      LogicalExpression: validateBinaryExpression,
      AssignmentExpression: validateBinaryExpression,
      VariableDeclarator(node) {
        if (node.init) {
          validateNode(node, node.init, '=');
        }
      },
      PropertyDefinition(node) {
        if (node.value) {
          validateNode(node, node.value, '=');
        }
      },
      ConditionalExpression(node) {
        validateNode(node, node.consequent, '?');
        validateNode(node, node.alternate, ':');
      },
    };
  },
};