/**
 * @fileoverview Rule to flag adding properties to native object's prototypes.
 * @author David Nelson
 */

"use strict";

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const astUtils = require("./utils/ast-utils");

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

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
	meta: {
		type: "suggestion",

		defaultOptions: [{ exceptions: [] }],

		docs: {
			description: "Disallow extending native types",
			recommended: false,
			url: "https://eslint.org/docs/latest/rules/no-extend-native",
		},

		schema: [
			{
				type: "object",
				properties: {
					exceptions: {
						type: "array",
						items: {
							type: "string",
						},
						uniqueItems: true,
					},
				},
				additionalProperties: false,
			},
		],

		messages: {
			unexpected:
				"{{builtin}} prototype is read only, properties should not be added.",
		},
	},

	create(context) {
		const sourceCode = context.sourceCode;
		const exceptions = new Set(context.options[0].exceptions);
		const modifiedBuiltins = new Set(
			Object.keys(astUtils.ECMASCRIPT_GLOBALS)
				.filter(builtin => builtin[0].toUpperCase() === builtin[0])
				.filter(builtin => !exceptions.has(builtin)),
		);

		/**
		 * Reports a lint error for the given node.
		 * @param {ASTNode} node The node to report.
		 * @param {string} builtin The name of the native builtin being extended.
		 * @returns {void}
		 */
		function reportNode(node, builtin) {
			context.report({
				node,
				messageId: "unexpected",
				data: {
					builtin,
				},
			});
		}

		/**
		 * Check to see if the `prototype` property of the given object
		 * identifier node is being accessed.
		 * @param {ASTNode} identifierNode The Identifier representing the object
		 * to check.
		 * @returns {boolean} True if the identifier is the object of a
		 * MemberExpression and its `prototype` property is being accessed,
		 * false otherwise.
		 */
		function isPrototypePropertyAccessed(identifierNode) {
			return Boolean(
				identifierNode &&
				identifierNode.parent &&
				identifierNode.parent.type === "MemberExpression" &&
				identifierNode.parent.object === identifierNode &&
				astUtils.getStaticPropertyName(identifierNode.parent) ===
					"prototype",
			);
		}

		/**
		 * Check if it's an assignment to the property of the given node.
		 * Example: `*.prop = 0` // the `*` is the given node.
		 * @param {ASTNode} node The node to check.
		 * @returns {boolean} True if an assignment to the property of the node.
		 */
		function isAssigningToPropertyOf(node) {
			return (
				node.parent.type === "MemberExpression" &&
				node.parent.object === node &&
				node.parent.parent.type === "AssignmentExpression" &&
				node.parent.parent.left === node.parent
			);
		}

		/**
		 * Checks if the given node is at the first argument of the method call of `Object.defineProperty()` or `Object.defineProperties()`.
		 * @param {ASTNode} node The node to check.
		 * @returns {boolean} True if the node is at the first argument of the method call of `Object.defineProperty()` or `Object.defineProperties()`.
		 */
		function isInDefinePropertyCall(node) {
			return (
				node.parent.type === "CallExpression" &&
				node.parent.arguments[0] === node &&
				astUtils.isSpecificMemberAccess(
					node.parent.callee,
					"Object",
					/^definePropert(?:y|ies)$/u,
				)
			);
		}

		/**
		 * Check to see if object prototype access is part of a prototype
		 * extension. There are three ways a prototype can be extended:
		 * 1. Assignment to prototype property (Object.prototype.foo = 1)
		 * 2. Object.defineProperty()/Object.defineProperties() on a prototype
		 * If prototype extension is detected, report the AssignmentExpression
		 * or CallExpression node.
		 * @param {ASTNode} identifierNode The Identifier representing the object
		 * which prototype is being accessed and possibly extended.
		 * @returns {void}
		 */
		function checkAndReportPrototypeExtension(identifierNode) {
			if (!isPrototypePropertyAccessed(identifierNode)) {
				return; // This is not `*.prototype` access.
			}

			/*
			 * `identifierNode.parent` is a MemberExpression `*.prototype`.
			 * If it's an optional member access, it may be wrapped by a `ChainExpression` node.
			 */
			const prototypeNode =
				identifierNode.parent.parent.type === "ChainExpression"
					? identifierNode.parent.parent
					: identifierNode.parent;

			if (isAssigningToPropertyOf(prototypeNode)) {
				// `*.prototype` -> MemberExpression -> AssignmentExpression
				reportNode(prototypeNode.parent.parent, identifierNode.name);
			} else if (isInDefinePropertyCall(prototypeNode)) {
				// `*.prototype` -> CallExpression
				reportNode(prototypeNode.parent, identifierNode.name);
			}
		}

		return {
			"Program:exit"(node) {
				const globalScope = sourceCode.getScope(node);

				modifiedBuiltins.forEach(builtin => {
					const builtinVar = globalScope.set.get(builtin);

					if (builtinVar && builtinVar.references) {
						builtinVar.references
							.map(ref => ref.identifier)
							.forEach(checkAndReportPrototypeExtension);
					}
				});
			},
		};
	},
};
