/**
 * @fileoverview Rule to enforce placing object properties on separate lines.
 * @author Vitor Balocco
 * @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: 'object-property-newline',
            url: 'https://eslint.style/rules/js/object-property-newline',
          },
        },
      ],
    },
    type: 'layout',

    docs: {
      description: 'Enforce placing object properties on separate lines',
      recommended: false,
      url: 'https://eslint.org/docs/latest/rules/object-property-newline',
    },

    schema: [
      {
        type: 'object',
        properties: {
          allowAllPropertiesOnSameLine: {
            type: 'boolean',
            default: false,
          },
          allowMultiplePropertiesPerLine: {
            // Deprecated
            type: 'boolean',
            default: false,
          },
        },
        additionalProperties: false,
      },
    ],

    fixable: 'whitespace',

    messages: {
      propertiesOnNewlineAll:
        "Object properties must go on a new line if they aren't all on the same line.",
      propertiesOnNewline: 'Object properties must go on a new line.',
    },
  },

  create(context) {
    const allowSameLine =
      context.options[0] &&
      (context.options[0].allowAllPropertiesOnSameLine ||
        context.options[0].allowMultiplePropertiesPerLine); /* Deprecated */
    const messageId =
      allowSameLine ? 'propertiesOnNewlineAll' : 'propertiesOnNewline';

    const sourceCode = context.sourceCode;

    return {
      ObjectExpression(node) {
        if (allowSameLine) {
          if (node.properties.length > 1) {
            const firstTokenOfFirstProperty = sourceCode.getFirstToken(
              node.properties[0]
            );
            const lastTokenOfLastProperty = sourceCode.getLastToken(
              node.properties.at(-1)
            );

            if (
              firstTokenOfFirstProperty.loc.end.line ===
              lastTokenOfLastProperty.loc.start.line
            ) {
              // All keys and values are on the same line
              return;
            }
          }
        }

        for (let i = 1; i < node.properties.length; i++) {
          const lastTokenOfPreviousProperty = sourceCode.getLastToken(
            node.properties[i - 1]
          );
          const firstTokenOfCurrentProperty = sourceCode.getFirstToken(
            node.properties[i]
          );

          if (
            lastTokenOfPreviousProperty.loc.end.line ===
            firstTokenOfCurrentProperty.loc.start.line
          ) {
            context.report({
              node,
              loc: firstTokenOfCurrentProperty.loc,
              messageId,
              fix(fixer) {
                const comma = sourceCode.getTokenBefore(
                  firstTokenOfCurrentProperty
                );
                const rangeAfterComma = [
                  comma.range[1],
                  firstTokenOfCurrentProperty.range[0],
                ];

                // Don't perform a fix if there are any comments between the comma and the next property.
                if (
                  sourceCode.text
                    .slice(rangeAfterComma[0], rangeAfterComma[1])
                    .trim()
                ) {
                  return null;
                }

                return fixer.replaceTextRange(rangeAfterComma, '\n');
              },
            });
          }
        }
      },
    };
  },
};