/**
 * @fileoverview Rule to enforce line breaks between arguments of a function call
 * @author Alexey Gonchar <https://github.com/finico>
 * @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: "function-call-argument-newline",
						url: "https://eslint.style/rules/js/function-call-argument-newline",
					},
				},
			],
		},
		type: "layout",

		docs: {
			description:
				"Enforce line breaks between arguments of a function call",
			recommended: false,
			url: "https://eslint.org/docs/latest/rules/function-call-argument-newline",
		},

		fixable: "whitespace",

		schema: [
			{
				enum: ["always", "never", "consistent"],
			},
		],

		messages: {
			unexpectedLineBreak: "There should be no line break here.",
			missingLineBreak:
				"There should be a line break after this argument.",
		},
	},

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

		const checkers = {
			unexpected: {
				messageId: "unexpectedLineBreak",
				check: (prevToken, currentToken) =>
					prevToken.loc.end.line !== currentToken.loc.start.line,
				createFix: (token, tokenBefore) => fixer =>
					fixer.replaceTextRange(
						[tokenBefore.range[1], token.range[0]],
						" ",
					),
			},
			missing: {
				messageId: "missingLineBreak",
				check: (prevToken, currentToken) =>
					prevToken.loc.end.line === currentToken.loc.start.line,
				createFix: (token, tokenBefore) => fixer =>
					fixer.replaceTextRange(
						[tokenBefore.range[1], token.range[0]],
						"\n",
					),
			},
		};

		/**
		 * Check all arguments for line breaks in the CallExpression
		 * @param {CallExpression} node node to evaluate
		 * @param {{ messageId: string, check: Function }} checker selected checker
		 * @returns {void}
		 * @private
		 */
		function checkArguments(node, checker) {
			for (let i = 1; i < node.arguments.length; i++) {
				const prevArgToken = sourceCode.getLastToken(
					node.arguments[i - 1],
				);
				const currentArgToken = sourceCode.getFirstToken(
					node.arguments[i],
				);

				if (checker.check(prevArgToken, currentArgToken)) {
					const tokenBefore = sourceCode.getTokenBefore(
						currentArgToken,
						{ includeComments: true },
					);

					const hasLineCommentBefore = tokenBefore.type === "Line";

					context.report({
						node,
						loc: {
							start: tokenBefore.loc.end,
							end: currentArgToken.loc.start,
						},
						messageId: checker.messageId,
						fix: hasLineCommentBefore
							? null
							: checker.createFix(currentArgToken, tokenBefore),
					});
				}
			}
		}

		/**
		 * Check if open space is present in a function name
		 * @param {CallExpression} node node to evaluate
		 * @returns {void}
		 * @private
		 */
		function check(node) {
			if (node.arguments.length < 2) {
				return;
			}

			const option = context.options[0] || "always";

			if (option === "never") {
				checkArguments(node, checkers.unexpected);
			} else if (option === "always") {
				checkArguments(node, checkers.missing);
			} else if (option === "consistent") {
				const firstArgToken = sourceCode.getLastToken(
					node.arguments[0],
				);
				const secondArgToken = sourceCode.getFirstToken(
					node.arguments[1],
				);

				if (
					firstArgToken.loc.end.line === secondArgToken.loc.start.line
				) {
					checkArguments(node, checkers.unexpected);
				} else {
					checkArguments(node, checkers.missing);
				}
			}
		}

		return {
			CallExpression: check,
			NewExpression: check,
		};
	},
};