/**
 * @fileoverview Rule to check the spacing around the * in yield* expressions.
 * @author Bryan Smith
 * @deprecated in ESLint v8.53.0
 */

'use strict';

//------------------------------------------------------------------------------
// 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: 'yield-star-spacing',
            url: 'https://eslint.style/rules/js/yield-star-spacing',
          },
        },
      ],
    },
    type: 'layout',

    docs: {
      description:
        'Require or disallow spacing around the `*` in `yield*` expressions',
      recommended: false,
      url: 'https://eslint.org/docs/latest/rules/yield-star-spacing',
    },

    fixable: 'whitespace',

    schema: [
      {
        oneOf: [
          {
            enum: ['before', 'after', 'both', 'neither'],
          },
          {
            type: 'object',
            properties: {
              before: { type: 'boolean' },
              after: { type: 'boolean' },
            },
            additionalProperties: false,
          },
        ],
      },
    ],
    messages: {
      missingBefore: 'Missing space before *.',
      missingAfter: 'Missing space after *.',
      unexpectedBefore: 'Unexpected space before *.',
      unexpectedAfter: 'Unexpected space after *.',
    },
  },

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

    const mode = (function (option) {
      if (!option || typeof option === 'string') {
        return {
          before: { before: true, after: false },
          after: { before: false, after: true },
          both: { before: true, after: true },
          neither: { before: false, after: false },
        }[option || 'after'];
      }
      return option;
    })(context.options[0]);

    /**
     * Checks the spacing between two tokens before or after the star token.
     * @param {string} side Either "before" or "after".
     * @param {Token} leftToken `function` keyword token if side is "before", or
     *     star token if side is "after".
     * @param {Token} rightToken Star token if side is "before", or identifier
     *     token if side is "after".
     * @returns {void}
     */
    function checkSpacing(side, leftToken, rightToken) {
      if (
        sourceCode.isSpaceBetweenTokens(leftToken, rightToken) !== mode[side]
      ) {
        const after = leftToken.value === '*';
        const spaceRequired = mode[side];
        const node = after ? leftToken : rightToken;
        let messageId;

        if (spaceRequired) {
          messageId = side === 'before' ? 'missingBefore' : 'missingAfter';
        } else {
          messageId =
            side === 'before' ? 'unexpectedBefore' : 'unexpectedAfter';
        }

        context.report({
          node,
          messageId,
          fix(fixer) {
            if (spaceRequired) {
              if (after) {
                return fixer.insertTextAfter(node, ' ');
              }
              return fixer.insertTextBefore(node, ' ');
            }
            return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
          },
        });
      }
    }

    /**
     * Enforces the spacing around the star if node is a yield* expression.
     * @param {ASTNode} node A yield expression node.
     * @returns {void}
     */
    function checkExpression(node) {
      if (!node.delegate) {
        return;
      }

      const tokens = sourceCode.getFirstTokens(node, 3);
      const yieldToken = tokens[0];
      const starToken = tokens[1];
      const nextToken = tokens[2];

      checkSpacing('before', yieldToken, starToken);
      checkSpacing('after', starToken, nextToken);
    }

    return {
      YieldExpression: checkExpression,
    };
  },
};