/**
 * @fileoverview Rule to flag updates of imported bindings.
 * @author Toru Nagashima <https://github.com/mysticatea>
 */

"use strict";

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

const { findVariable } = require("@eslint-community/eslint-utils");
const astUtils = require("./utils/ast-utils");

const WellKnownMutationFunctions = {
	Object: /^(?:assign|definePropert(?:y|ies)|freeze|setPrototypeOf)$/u,
	Reflect: /^(?:(?:define|delete)Property|set(?:PrototypeOf)?)$/u,
};

/**
 * Check if a given node is LHS of an assignment node.
 * @param {ASTNode} node The node to check.
 * @returns {boolean} `true` if the node is LHS.
 */
function isAssignmentLeft(node) {
	const { parent } = node;

	return (
		(parent.type === "AssignmentExpression" && parent.left === node) ||
		// Destructuring assignments
		parent.type === "ArrayPattern" ||
		(parent.type === "Property" &&
			parent.value === node &&
			parent.parent.type === "ObjectPattern") ||
		parent.type === "RestElement" ||
		(parent.type === "AssignmentPattern" && parent.left === node)
	);
}

/**
 * Check if a given node is the operand of mutation unary operator.
 * @param {ASTNode} node The node to check.
 * @returns {boolean} `true` if the node is the operand of mutation unary operator.
 */
function isOperandOfMutationUnaryOperator(node) {
	const argumentNode =
		node.parent.type === "ChainExpression" ? node.parent : node;
	const { parent } = argumentNode;

	return (
		(parent.type === "UpdateExpression" &&
			parent.argument === argumentNode) ||
		(parent.type === "UnaryExpression" &&
			parent.operator === "delete" &&
			parent.argument === argumentNode)
	);
}

/**
 * Check if a given node is the iteration variable of `for-in`/`for-of` syntax.
 * @param {ASTNode} node The node to check.
 * @returns {boolean} `true` if the node is the iteration variable.
 */
function isIterationVariable(node) {
	const { parent } = node;

	return (
		(parent.type === "ForInStatement" && parent.left === node) ||
		(parent.type === "ForOfStatement" && parent.left === node)
	);
}

/**
 * Check if a given node is at the first argument of a well-known mutation function.
 * - `Object.assign`
 * - `Object.defineProperty`
 * - `Object.defineProperties`
 * - `Object.freeze`
 * - `Object.setPrototypeOf`
 * - `Reflect.defineProperty`
 * - `Reflect.deleteProperty`
 * - `Reflect.set`
 * - `Reflect.setPrototypeOf`
 * @param {ASTNode} node The node to check.
 * @param {Scope} scope A `escope.Scope` object to find variable (whichever).
 * @returns {boolean} `true` if the node is at the first argument of a well-known mutation function.
 */
function isArgumentOfWellKnownMutationFunction(node, scope) {
	const { parent } = node;

	if (parent.type !== "CallExpression" || parent.arguments[0] !== node) {
		return false;
	}
	const callee = astUtils.skipChainExpression(parent.callee);

	if (
		!astUtils.isSpecificMemberAccess(
			callee,
			"Object",
			WellKnownMutationFunctions.Object,
		) &&
		!astUtils.isSpecificMemberAccess(
			callee,
			"Reflect",
			WellKnownMutationFunctions.Reflect,
		)
	) {
		return false;
	}
	const variable = findVariable(scope, callee.object);

	return variable !== null && variable.scope.type === "global";
}

/**
 * Check if the identifier node is placed at to update members.
 * @param {ASTNode} id The Identifier node to check.
 * @param {Scope} scope A `escope.Scope` object to find variable (whichever).
 * @returns {boolean} `true` if the member of `id` was updated.
 */
function isMemberWrite(id, scope) {
	const { parent } = id;

	return (
		(parent.type === "MemberExpression" &&
			parent.object === id &&
			(isAssignmentLeft(parent) ||
				isOperandOfMutationUnaryOperator(parent) ||
				isIterationVariable(parent))) ||
		isArgumentOfWellKnownMutationFunction(id, scope)
	);
}

/**
 * Get the mutation node.
 * @param {ASTNode} id The Identifier node to get.
 * @returns {ASTNode} The mutation node.
 */
function getWriteNode(id) {
	let node = id.parent;

	while (
		node &&
		node.type !== "AssignmentExpression" &&
		node.type !== "UpdateExpression" &&
		node.type !== "UnaryExpression" &&
		node.type !== "CallExpression" &&
		node.type !== "ForInStatement" &&
		node.type !== "ForOfStatement"
	) {
		node = node.parent;
	}

	return node || id;
}

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

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

		docs: {
			description: "Disallow assigning to imported bindings",
			recommended: true,
			url: "https://eslint.org/docs/latest/rules/no-import-assign",
		},

		schema: [],

		messages: {
			readonly: "'{{name}}' is read-only.",
			readonlyMember: "The members of '{{name}}' are read-only.",
		},
	},

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

		return {
			ImportDeclaration(node) {
				const scope = sourceCode.getScope(node);

				for (const variable of sourceCode.getDeclaredVariables(node)) {
					const shouldCheckMembers = variable.defs.some(
						d => d.node.type === "ImportNamespaceSpecifier",
					);
					let prevIdNode = null;

					for (const reference of variable.references) {
						const idNode = reference.identifier;

						/*
						 * AssignmentPattern (e.g. `[a = 0] = b`) makes two write
						 * references for the same identifier. This should skip
						 * the one of the two in order to prevent redundant reports.
						 */
						if (idNode === prevIdNode) {
							continue;
						}
						prevIdNode = idNode;

						if (reference.isWrite()) {
							context.report({
								node: getWriteNode(idNode),
								messageId: "readonly",
								data: { name: idNode.name },
							});
						} else if (
							shouldCheckMembers &&
							isMemberWrite(idNode, scope)
						) {
							context.report({
								node: getWriteNode(idNode),
								messageId: "readonlyMember",
								data: { name: idNode.name },
							});
						}
					}
				}
			},
		};
	},
};