/**
 * @fileoverview Rule to check for max length on a line.
 * @author Matt DuVall <http://www.mattduvall.com>
 * @deprecated in ESLint v8.53.0
 */

"use strict";

//------------------------------------------------------------------------------
// Constants
//------------------------------------------------------------------------------

const OPTIONS_SCHEMA = {
	type: "object",
	properties: {
		code: {
			type: "integer",
			minimum: 0,
		},
		comments: {
			type: "integer",
			minimum: 0,
		},
		tabWidth: {
			type: "integer",
			minimum: 0,
		},
		ignorePattern: {
			type: "string",
		},
		ignoreComments: {
			type: "boolean",
		},
		ignoreStrings: {
			type: "boolean",
		},
		ignoreUrls: {
			type: "boolean",
		},
		ignoreTemplateLiterals: {
			type: "boolean",
		},
		ignoreRegExpLiterals: {
			type: "boolean",
		},
		ignoreTrailingComments: {
			type: "boolean",
		},
	},
	additionalProperties: false,
};

const OPTIONS_OR_INTEGER_SCHEMA = {
	anyOf: [
		OPTIONS_SCHEMA,
		{
			type: "integer",
			minimum: 0,
		},
	],
};

//------------------------------------------------------------------------------
// 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: "max-len",
						url: "https://eslint.style/rules/js/max-len",
					},
				},
			],
		},
		type: "layout",

		docs: {
			description: "Enforce a maximum line length",
			recommended: false,
			url: "https://eslint.org/docs/latest/rules/max-len",
		},

		schema: [
			OPTIONS_OR_INTEGER_SCHEMA,
			OPTIONS_OR_INTEGER_SCHEMA,
			OPTIONS_SCHEMA,
		],
		messages: {
			max: "This line has a length of {{lineLength}}. Maximum allowed is {{maxLength}}.",
			maxComment:
				"This line has a comment length of {{lineLength}}. Maximum allowed is {{maxCommentLength}}.",
		},
	},

	create(context) {
		/*
		 * Inspired by http://tools.ietf.org/html/rfc3986#appendix-B, however:
		 * - They're matching an entire string that we know is a URI
		 * - We're matching part of a string where we think there *might* be a URL
		 * - We're only concerned about URLs, as picking out any URI would cause
		 *   too many false positives
		 * - We don't care about matching the entire URL, any small segment is fine
		 */
		const URL_REGEXP = /[^:/?#]:\/\/[^?#]/u;

		const sourceCode = context.sourceCode;

		/**
		 * Computes the length of a line that may contain tabs. The width of each
		 * tab will be the number of spaces to the next tab stop.
		 * @param {string} line The line.
		 * @param {number} tabWidth The width of each tab stop in spaces.
		 * @returns {number} The computed line length.
		 * @private
		 */
		function computeLineLength(line, tabWidth) {
			let extraCharacterCount = 0;

			line.replace(/\t/gu, (match, offset) => {
				const totalOffset = offset + extraCharacterCount,
					previousTabStopOffset = tabWidth
						? totalOffset % tabWidth
						: 0,
					spaceCount = tabWidth - previousTabStopOffset;

				extraCharacterCount += spaceCount - 1; // -1 for the replaced tab
			});
			return Array.from(line).length + extraCharacterCount;
		}

		// The options object must be the last option specified…
		const options = Object.assign({}, context.options.at(-1));

		// …but max code length…
		if (typeof context.options[0] === "number") {
			options.code = context.options[0];
		}

		// …and tabWidth can be optionally specified directly as integers.
		if (typeof context.options[1] === "number") {
			options.tabWidth = context.options[1];
		}

		const maxLength = typeof options.code === "number" ? options.code : 80,
			tabWidth =
				typeof options.tabWidth === "number" ? options.tabWidth : 4,
			ignoreComments = !!options.ignoreComments,
			ignoreStrings = !!options.ignoreStrings,
			ignoreTemplateLiterals = !!options.ignoreTemplateLiterals,
			ignoreRegExpLiterals = !!options.ignoreRegExpLiterals,
			ignoreTrailingComments =
				!!options.ignoreTrailingComments || !!options.ignoreComments,
			ignoreUrls = !!options.ignoreUrls,
			maxCommentLength = options.comments;
		let ignorePattern = options.ignorePattern || null;

		if (ignorePattern) {
			ignorePattern = new RegExp(ignorePattern, "u");
		}

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

		/**
		 * Tells if a given comment is trailing: it starts on the current line and
		 * extends to or past the end of the current line.
		 * @param {string} line The source line we want to check for a trailing comment on
		 * @param {number} lineNumber The one-indexed line number for line
		 * @param {ASTNode} comment The comment to inspect
		 * @returns {boolean} If the comment is trailing on the given line
		 */
		function isTrailingComment(line, lineNumber, comment) {
			return (
				comment &&
				comment.loc.start.line === lineNumber &&
				lineNumber <= comment.loc.end.line &&
				(comment.loc.end.line > lineNumber ||
					comment.loc.end.column === line.length)
			);
		}

		/**
		 * Tells if a comment encompasses the entire line.
		 * @param {string} line The source line with a trailing comment
		 * @param {number} lineNumber The one-indexed line number this is on
		 * @param {ASTNode} comment The comment to remove
		 * @returns {boolean} If the comment covers the entire line
		 */
		function isFullLineComment(line, lineNumber, comment) {
			const start = comment.loc.start,
				end = comment.loc.end,
				isFirstTokenOnLine = !line
					.slice(0, comment.loc.start.column)
					.trim();

			return (
				comment &&
				(start.line < lineNumber ||
					(start.line === lineNumber && isFirstTokenOnLine)) &&
				(end.line > lineNumber ||
					(end.line === lineNumber && end.column === line.length))
			);
		}

		/**
		 * Check if a node is a JSXEmptyExpression contained in a single line JSXExpressionContainer.
		 * @param {ASTNode} node A node to check.
		 * @returns {boolean} True if the node is a JSXEmptyExpression contained in a single line JSXExpressionContainer.
		 */
		function isJSXEmptyExpressionInSingleLineContainer(node) {
			if (
				!node ||
				!node.parent ||
				node.type !== "JSXEmptyExpression" ||
				node.parent.type !== "JSXExpressionContainer"
			) {
				return false;
			}

			const parent = node.parent;

			return parent.loc.start.line === parent.loc.end.line;
		}

		/**
		 * Gets the line after the comment and any remaining trailing whitespace is
		 * stripped.
		 * @param {string} line The source line with a trailing comment
		 * @param {ASTNode} comment The comment to remove
		 * @returns {string} Line without comment and trailing whitespace
		 */
		function stripTrailingComment(line, comment) {
			// loc.column is zero-indexed
			return line.slice(0, comment.loc.start.column).replace(/\s+$/u, "");
		}

		/**
		 * Ensure that an array exists at [key] on `object`, and add `value` to it.
		 * @param {Object} object the object to mutate
		 * @param {string} key the object's key
		 * @param {any} value the value to add
		 * @returns {void}
		 * @private
		 */
		function ensureArrayAndPush(object, key, value) {
			if (!Array.isArray(object[key])) {
				object[key] = [];
			}
			object[key].push(value);
		}

		/**
		 * Retrieves an array containing all strings (" or ') in the source code.
		 * @returns {ASTNode[]} An array of string nodes.
		 */
		function getAllStrings() {
			return sourceCode.ast.tokens.filter(
				token =>
					token.type === "String" ||
					(token.type === "JSXText" &&
						sourceCode.getNodeByRangeIndex(token.range[0] - 1)
							.type === "JSXAttribute"),
			);
		}

		/**
		 * Retrieves an array containing all template literals in the source code.
		 * @returns {ASTNode[]} An array of template literal nodes.
		 */
		function getAllTemplateLiterals() {
			return sourceCode.ast.tokens.filter(
				token => token.type === "Template",
			);
		}

		/**
		 * Retrieves an array containing all RegExp literals in the source code.
		 * @returns {ASTNode[]} An array of RegExp literal nodes.
		 */
		function getAllRegExpLiterals() {
			return sourceCode.ast.tokens.filter(
				token => token.type === "RegularExpression",
			);
		}

		/**
		 *
		 * reduce an array of AST nodes by line number, both start and end.
		 * @param {ASTNode[]} arr array of AST nodes
		 * @returns {Object} accululated AST nodes
		 */
		function groupArrayByLineNumber(arr) {
			const obj = {};

			for (let i = 0; i < arr.length; i++) {
				const node = arr[i];

				for (let j = node.loc.start.line; j <= node.loc.end.line; ++j) {
					ensureArrayAndPush(obj, j, node);
				}
			}
			return obj;
		}

		/**
		 * Returns an array of all comments in the source code.
		 * If the element in the array is a JSXEmptyExpression contained with a single line JSXExpressionContainer,
		 * the element is changed with JSXExpressionContainer node.
		 * @returns {ASTNode[]} An array of comment nodes
		 */
		function getAllComments() {
			const comments = [];

			sourceCode.getAllComments().forEach(commentNode => {
				const containingNode = sourceCode.getNodeByRangeIndex(
					commentNode.range[0],
				);

				if (isJSXEmptyExpressionInSingleLineContainer(containingNode)) {
					// push a unique node only
					if (comments.at(-1) !== containingNode.parent) {
						comments.push(containingNode.parent);
					}
				} else {
					comments.push(commentNode);
				}
			});

			return comments;
		}

		/**
		 * Check the program for max length
		 * @param {ASTNode} node Node to examine
		 * @returns {void}
		 * @private
		 */
		function checkProgramForMaxLength(node) {
			// split (honors line-ending)
			const lines = sourceCode.lines,
				// list of comments to ignore
				comments =
					ignoreComments || maxCommentLength || ignoreTrailingComments
						? getAllComments()
						: [];

			// we iterate over comments in parallel with the lines
			let commentsIndex = 0;

			const strings = getAllStrings();
			const stringsByLine = groupArrayByLineNumber(strings);

			const templateLiterals = getAllTemplateLiterals();
			const templateLiteralsByLine =
				groupArrayByLineNumber(templateLiterals);

			const regExpLiterals = getAllRegExpLiterals();
			const regExpLiteralsByLine = groupArrayByLineNumber(regExpLiterals);

			lines.forEach((line, i) => {
				// i is zero-indexed, line numbers are one-indexed
				const lineNumber = i + 1;

				/*
				 * if we're checking comment length; we need to know whether this
				 * line is a comment
				 */
				let lineIsComment = false;
				let textToMeasure;

				/*
				 * We can short-circuit the comment checks if we're already out of
				 * comments to check.
				 */
				if (commentsIndex < comments.length) {
					let comment;

					// iterate over comments until we find one past the current line
					do {
						comment = comments[++commentsIndex];
					} while (comment && comment.loc.start.line <= lineNumber);

					// and step back by one
					comment = comments[--commentsIndex];

					if (isFullLineComment(line, lineNumber, comment)) {
						lineIsComment = true;
						textToMeasure = line;
					} else if (
						ignoreTrailingComments &&
						isTrailingComment(line, lineNumber, comment)
					) {
						textToMeasure = stripTrailingComment(line, comment);

						// ignore multiple trailing comments in the same line
						let lastIndex = commentsIndex;

						while (
							isTrailingComment(
								textToMeasure,
								lineNumber,
								comments[--lastIndex],
							)
						) {
							textToMeasure = stripTrailingComment(
								textToMeasure,
								comments[lastIndex],
							);
						}
					} else {
						textToMeasure = line;
					}
				} else {
					textToMeasure = line;
				}
				if (
					(ignorePattern && ignorePattern.test(textToMeasure)) ||
					(ignoreUrls && URL_REGEXP.test(textToMeasure)) ||
					(ignoreStrings && stringsByLine[lineNumber]) ||
					(ignoreTemplateLiterals &&
						templateLiteralsByLine[lineNumber]) ||
					(ignoreRegExpLiterals && regExpLiteralsByLine[lineNumber])
				) {
					// ignore this line
					return;
				}

				const lineLength = computeLineLength(textToMeasure, tabWidth);
				const commentLengthApplies = lineIsComment && maxCommentLength;

				if (lineIsComment && ignoreComments) {
					return;
				}

				const loc = {
					start: {
						line: lineNumber,
						column: 0,
					},
					end: {
						line: lineNumber,
						column: textToMeasure.length,
					},
				};

				if (commentLengthApplies) {
					if (lineLength > maxCommentLength) {
						context.report({
							node,
							loc,
							messageId: "maxComment",
							data: {
								lineLength,
								maxCommentLength,
							},
						});
					}
				} else if (lineLength > maxLength) {
					context.report({
						node,
						loc,
						messageId: "max",
						data: {
							lineLength,
							maxLength,
						},
					});
				}
			});
		}

		//--------------------------------------------------------------------------
		// Public API
		//--------------------------------------------------------------------------

		return {
			Program: checkProgramForMaxLength,
		};
	},
};
