/**
 * @fileoverview enforce the location of single-line statements
 * @author Teddy Katz
 * @deprecated in ESLint v8.53.0
 */
'use strict';

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

const POSITION_SCHEMA = { enum: ['beside', 'below', 'any'] };

/** @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: 'nonblock-statement-body-position',
            url: 'https://eslint.style/rules/js/nonblock-statement-body-position',
          },
        },
      ],
    },
    type: 'layout',

    docs: {
      description: 'Enforce the location of single-line statements',
      recommended: false,
      url: 'https://eslint.org/docs/latest/rules/nonblock-statement-body-position',
    },

    fixable: 'whitespace',

    schema: [
      POSITION_SCHEMA,
      {
        properties: {
          overrides: {
            properties: {
              if: POSITION_SCHEMA,
              else: POSITION_SCHEMA,
              while: POSITION_SCHEMA,
              do: POSITION_SCHEMA,
              for: POSITION_SCHEMA,
            },
            additionalProperties: false,
          },
        },
        additionalProperties: false,
      },
    ],

    messages: {
      expectNoLinebreak: 'Expected no linebreak before this statement.',
      expectLinebreak: 'Expected a linebreak before this statement.',
    },
  },

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

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

    /**
     * Gets the applicable preference for a particular keyword
     * @param {string} keywordName The name of a keyword, e.g. 'if'
     * @returns {string} The applicable option for the keyword, e.g. 'beside'
     */
    function getOption(keywordName) {
      return (
        (context.options[1] &&
          context.options[1].overrides &&
          context.options[1].overrides[keywordName]) ||
        context.options[0] ||
        'beside'
      );
    }

    /**
     * Validates the location of a single-line statement
     * @param {ASTNode} node The single-line statement
     * @param {string} keywordName The applicable keyword name for the single-line statement
     * @returns {void}
     */
    function validateStatement(node, keywordName) {
      const option = getOption(keywordName);

      if (node.type === 'BlockStatement' || option === 'any') {
        return;
      }

      const tokenBefore = sourceCode.getTokenBefore(node);

      if (
        tokenBefore.loc.end.line === node.loc.start.line &&
        option === 'below'
      ) {
        context.report({
          node,
          messageId: 'expectLinebreak',
          fix: (fixer) => fixer.insertTextBefore(node, '\n'),
        });
      } else if (
        tokenBefore.loc.end.line !== node.loc.start.line &&
        option === 'beside'
      ) {
        context.report({
          node,
          messageId: 'expectNoLinebreak',
          fix(fixer) {
            if (
              sourceCode
                .getText()
                .slice(tokenBefore.range[1], node.range[0])
                .trim()
            ) {
              return null;
            }
            return fixer.replaceTextRange(
              [tokenBefore.range[1], node.range[0]],
              ' '
            );
          },
        });
      }
    }

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

    return {
      IfStatement(node) {
        validateStatement(node.consequent, 'if');

        // Check the `else` node, but don't check 'else if' statements.
        if (node.alternate && node.alternate.type !== 'IfStatement') {
          validateStatement(node.alternate, 'else');
        }
      },
      WhileStatement: (node) => validateStatement(node.body, 'while'),
      DoWhileStatement: (node) => validateStatement(node.body, 'do'),
      ForStatement: (node) => validateStatement(node.body, 'for'),
      ForInStatement: (node) => validateStatement(node.body, 'for'),
      ForOfStatement: (node) => validateStatement(node.body, 'for'),
    };
  },
};