/**
 * @fileoverview A rule to disallow unnecessary assignments`.
 * @author Yosuke Ota
 */

"use strict";

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

//------------------------------------------------------------------------------
// Types
//------------------------------------------------------------------------------

/** @typedef {import("estree").Node} ASTNode */
/** @typedef {import("estree").Pattern} Pattern */
/** @typedef {import("estree").Identifier} Identifier */
/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
/** @typedef {import("estree").UpdateExpression} UpdateExpression */
/** @typedef {import("estree").Expression} Expression */
/** @typedef {import("eslint-scope").Scope} Scope */
/** @typedef {import("eslint-scope").Variable} Variable */
/** @typedef {import("../linter/code-path-analysis/code-path")} CodePath */
/** @typedef {import("../linter/code-path-analysis/code-path-segment")} CodePathSegment */

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

/**
 * Extract identifier from the given pattern node used on the left-hand side of the assignment.
 * @param {Pattern} pattern The pattern node to extract identifier
 * @returns {Iterable<Identifier>} The extracted identifier
 */
function *extractIdentifiersFromPattern(pattern) {
    switch (pattern.type) {
        case "Identifier":
            yield pattern;
            return;
        case "ObjectPattern":
            for (const property of pattern.properties) {
                yield* extractIdentifiersFromPattern(property.type === "Property" ? property.value : property);
            }
            return;
        case "ArrayPattern":
            for (const element of pattern.elements) {
                if (!element) {
                    continue;
                }
                yield* extractIdentifiersFromPattern(element);
            }
            return;
        case "RestElement":
            yield* extractIdentifiersFromPattern(pattern.argument);
            return;
        case "AssignmentPattern":
            yield* extractIdentifiersFromPattern(pattern.left);

        // no default
    }
}


/**
 * Checks whether the given identifier node is evaluated after the assignment identifier.
 * @param {AssignmentInfo} assignment The assignment info.
 * @param {Identifier} identifier The identifier to check.
 * @returns {boolean} `true` if the given identifier node is evaluated after the assignment identifier.
 */
function isIdentifierEvaluatedAfterAssignment(assignment, identifier) {
    if (identifier.range[0] < assignment.identifier.range[1]) {
        return false;
    }
    if (
        assignment.expression &&
        assignment.expression.range[0] <= identifier.range[0] &&
        identifier.range[1] <= assignment.expression.range[1]
    ) {

        /*
         * The identifier node is in an expression that is evaluated before the assignment.
         * e.g. x = id;
         *          ^^ identifier to check
         *      ^      assignment identifier
         */
        return false;
    }

    /*
     * e.g.
     *      x = 42; id;
     *              ^^ identifier to check
     *      ^          assignment identifier
     *      let { x, y = id } = obj;
     *                   ^^  identifier to check
     *            ^          assignment identifier
     */
    return true;
}

/**
 * Checks whether the given identifier node is used between the assigned identifier and the equal sign.
 *
 * e.g. let { x, y = x } = obj;
 *                   ^   identifier to check
 *            ^          assigned identifier
 * @param {AssignmentInfo} assignment The assignment info.
 * @param {Identifier} identifier The identifier to check.
 * @returns {boolean} `true` if the given identifier node is used between the assigned identifier and the equal sign.
 */
function isIdentifierUsedBetweenAssignedAndEqualSign(assignment, identifier) {
    if (!assignment.expression) {
        return false;
    }
    return (
        assignment.identifier.range[1] <= identifier.range[0] &&
        identifier.range[1] <= assignment.expression.range[0]
    );
}

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

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

        docs: {
            description: "Disallow variable assignments when the value is not used",
            recommended: false,
            url: "https://eslint.org/docs/latest/rules/no-useless-assignment"
        },

        schema: [],

        messages: {
            unnecessaryAssignment: "This assigned value is not used in subsequent statements."
        }
    },

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

        /**
         * @typedef {Object} ScopeStack
         * @property {CodePath} codePath The code path of this scope stack.
         * @property {Scope} scope The scope of this scope stack.
         * @property {ScopeStack} upper The upper scope stack.
         * @property {Record<string, ScopeStackSegmentInfo>} segments The map of ScopeStackSegmentInfo.
         * @property {Set<CodePathSegment>} currentSegments The current CodePathSegments.
         * @property {Map<Variable, AssignmentInfo[]>} assignments The map of list of AssignmentInfo for each variable.
         */
        /**
         * @typedef {Object} ScopeStackSegmentInfo
         * @property {CodePathSegment} segment The code path segment.
         * @property {Identifier|null} first The first identifier that appears within the segment.
         * @property {Identifier|null} last The last identifier that appears within the segment.
         * `first` and `last` are used to determine whether an identifier exists within the segment position range.
         * Since it is used as a range of segments, we should originally hold all nodes, not just identifiers,
         * but since the only nodes to be judged are identifiers, it is sufficient to have a range of identifiers.
         */
        /**
         * @typedef {Object} AssignmentInfo
         * @property {Variable} variable The variable that is assigned.
         * @property {Identifier} identifier The identifier that is assigned.
         * @property {VariableDeclarator|AssignmentExpression|UpdateExpression} node The node where the variable was updated.
         * @property {Expression|null} expression The expression that is evaluated before the assignment.
         * @property {CodePathSegment[]} segments The code path segments where the assignment was made.
         */

        /** @type {ScopeStack} */
        let scopeStack = null;

        /** @type {Set<Scope>} */
        const codePathStartScopes = new Set();

        /**
         * Gets the scope of code path start from given scope
         * @param {Scope} scope The initial scope
         * @returns {Scope} The scope of code path start
         * @throws {Error} Unexpected error
         */
        function getCodePathStartScope(scope) {
            let target = scope;

            while (target) {
                if (codePathStartScopes.has(target)) {
                    return target;
                }
                target = target.upper;
            }

            // Should be unreachable
            return null;
        }

        /**
         * Verify the given scope stack.
         * @param {ScopeStack} target The scope stack to verify.
         * @returns {void}
         */
        function verify(target) {

            /**
             * Checks whether the given identifier is used in the segment.
             * @param {CodePathSegment} segment The code path segment.
             * @param {Identifier} identifier The identifier to check.
             * @returns {boolean} `true` if the identifier is used in the segment.
             */
            function isIdentifierUsedInSegment(segment, identifier) {
                const segmentInfo = target.segments[segment.id];

                return (
                    segmentInfo.first &&
                    segmentInfo.last &&
                    segmentInfo.first.range[0] <= identifier.range[0] &&
                    identifier.range[1] <= segmentInfo.last.range[1]
                );
            }

            /**
             * Verifies whether the given assignment info is an used assignment.
             * Report if it is an unused assignment.
             * @param {AssignmentInfo} targetAssignment The assignment info to verify.
             * @param {AssignmentInfo[]} allAssignments The list of all assignment info for variables.
             * @returns {void}
             */
            function verifyAssignmentIsUsed(targetAssignment, allAssignments) {

                /**
                 * @typedef {Object} SubsequentSegmentData
                 * @property {CodePathSegment} segment The code path segment
                 * @property {AssignmentInfo} [assignment] The first occurrence of the assignment within the segment.
                 * There is no need to check if the variable is used after this assignment,
                 * as the value it was assigned will be used.
                 */

                /**
                 * Information used in `getSubsequentSegments()`.
                 * To avoid unnecessary iterations, cache information that has already been iterated over,
                 * and if additional iterations are needed, start iterating from the retained position.
                 */
                const subsequentSegmentData = {

                    /**
                     * Cache of subsequent segment information list that have already been iterated.
                     * @type {SubsequentSegmentData[]}
                     */
                    results: [],

                    /**
                     * Subsequent segments that have already been iterated on. Used to avoid infinite loops.
                     * @type {Set<CodePathSegment>}
                     */
                    subsequentSegments: new Set(),

                    /**
                     * Unexplored code path segment.
                     * If additional iterations are needed, consume this information and iterate.
                     * @type {CodePathSegment[]}
                     */
                    queueSegments: targetAssignment.segments.flatMap(segment => segment.nextSegments)
                };


                /**
                 * Gets the subsequent segments from the segment of
                 * the assignment currently being validated (targetAssignment).
                 * @returns {Iterable<SubsequentSegmentData>} the subsequent segments
                 */
                function *getSubsequentSegments() {
                    yield* subsequentSegmentData.results;

                    while (subsequentSegmentData.queueSegments.length > 0) {
                        const nextSegment = subsequentSegmentData.queueSegments.shift();

                        if (subsequentSegmentData.subsequentSegments.has(nextSegment)) {
                            continue;
                        }
                        subsequentSegmentData.subsequentSegments.add(nextSegment);

                        const assignmentInSegment = allAssignments
                            .find(otherAssignment => (
                                otherAssignment.segments.includes(nextSegment) &&
                                !isIdentifierUsedBetweenAssignedAndEqualSign(otherAssignment, targetAssignment.identifier)
                            ));

                        if (!assignmentInSegment) {

                            /*
                             * Stores the next segment to explore.
                             * If `assignmentInSegment` exists,
                             * we are guarding it because we don't need to explore the next segment.
                             */
                            subsequentSegmentData.queueSegments.push(...nextSegment.nextSegments);
                        }

                        /** @type {SubsequentSegmentData} */
                        const result = {
                            segment: nextSegment,
                            assignment: assignmentInSegment
                        };

                        subsequentSegmentData.results.push(result);
                        yield result;
                    }
                }


                if (targetAssignment.variable.references.some(ref => ref.identifier.type !== "Identifier")) {

                    /**
                     * Skip checking for a variable that has at least one non-identifier reference.
                     * It's generated by plugins and cannot be handled reliably in the core rule.
                     */
                    return;
                }

                const readReferences = targetAssignment.variable.references.filter(reference => reference.isRead());

                if (!readReferences.length) {

                    /*
                     * It is not just an unnecessary assignment, but an unnecessary (unused) variable
                     * and thus should not be reported by this rule because it is reported by `no-unused-vars`.
                     */
                    return;
                }

                /**
                 * Other assignment on the current segment and after current assignment.
                 */
                const otherAssignmentAfterTargetAssignment = allAssignments
                    .find(assignment => {
                        if (
                            assignment === targetAssignment ||
                            assignment.segments.length && assignment.segments.every(segment => !targetAssignment.segments.includes(segment))
                        ) {
                            return false;
                        }
                        if (isIdentifierEvaluatedAfterAssignment(targetAssignment, assignment.identifier)) {
                            return true;
                        }
                        if (
                            assignment.expression &&
                            assignment.expression.range[0] <= targetAssignment.identifier.range[0] &&
                            targetAssignment.identifier.range[1] <= assignment.expression.range[1]
                        ) {

                            /*
                             * The target assignment is in an expression that is evaluated before the assignment.
                             * e.g. x=(x=1);
                             *         ^^^ targetAssignment
                             *      ^^^^^^^ assignment
                             */
                            return true;
                        }

                        return false;
                    });

                for (const reference of readReferences) {

                    /*
                     * If the scope of the reference is outside the current code path scope,
                     * we cannot track whether this assignment is not used.
                     * For example, it can also be called asynchronously.
                     */
                    if (target.scope !== getCodePathStartScope(reference.from)) {
                        return;
                    }

                    // Checks if it is used in the same segment as the target assignment.
                    if (
                        isIdentifierEvaluatedAfterAssignment(targetAssignment, reference.identifier) &&
                        (
                            isIdentifierUsedBetweenAssignedAndEqualSign(targetAssignment, reference.identifier) ||
                            targetAssignment.segments.some(segment => isIdentifierUsedInSegment(segment, reference.identifier))
                        )
                    ) {

                        if (
                            otherAssignmentAfterTargetAssignment &&
                            isIdentifierEvaluatedAfterAssignment(otherAssignmentAfterTargetAssignment, reference.identifier)
                        ) {

                            // There was another assignment before the reference. Therefore, it has not been used yet.
                            continue;
                        }

                        // Uses in statements after the written identifier.
                        return;
                    }

                    if (otherAssignmentAfterTargetAssignment) {

                        /*
                         * The assignment was followed by another assignment in the same segment.
                         * Therefore, there is no need to check the next segment.
                         */
                        continue;
                    }

                    // Check subsequent segments.
                    for (const subsequentSegment of getSubsequentSegments()) {
                        if (isIdentifierUsedInSegment(subsequentSegment.segment, reference.identifier)) {
                            if (
                                subsequentSegment.assignment &&
                                isIdentifierEvaluatedAfterAssignment(subsequentSegment.assignment, reference.identifier)
                            ) {

                                // There was another assignment before the reference. Therefore, it has not been used yet.
                                continue;
                            }

                            // It is used
                            return;
                        }
                    }
                }
                context.report({
                    node: targetAssignment.identifier,
                    messageId: "unnecessaryAssignment"
                });
            }

            // Verify that each assignment in the code path is used.
            for (const assignments of target.assignments.values()) {
                assignments.sort((a, b) => a.identifier.range[0] - b.identifier.range[0]);
                for (const assignment of assignments) {
                    verifyAssignmentIsUsed(assignment, assignments);
                }
            }
        }

        return {
            onCodePathStart(codePath, node) {
                const scope = sourceCode.getScope(node);

                scopeStack = {
                    upper: scopeStack,
                    codePath,
                    scope,
                    segments: Object.create(null),
                    currentSegments: new Set(),
                    assignments: new Map()
                };
                codePathStartScopes.add(scopeStack.scope);
            },
            onCodePathEnd() {
                verify(scopeStack);

                scopeStack = scopeStack.upper;
            },
            onCodePathSegmentStart(segment) {
                const segmentInfo = { segment, first: null, last: null };

                scopeStack.segments[segment.id] = segmentInfo;
                scopeStack.currentSegments.add(segment);
            },
            onCodePathSegmentEnd(segment) {
                scopeStack.currentSegments.delete(segment);
            },
            Identifier(node) {
                for (const segment of scopeStack.currentSegments) {
                    const segmentInfo = scopeStack.segments[segment.id];

                    if (!segmentInfo.first) {
                        segmentInfo.first = node;
                    }
                    segmentInfo.last = node;
                }
            },
            ":matches(VariableDeclarator[init!=null], AssignmentExpression, UpdateExpression):exit"(node) {
                if (scopeStack.currentSegments.size === 0) {

                    // Ignore unreachable segments
                    return;
                }

                const assignments = scopeStack.assignments;

                let pattern;
                let expression = null;

                if (node.type === "VariableDeclarator") {
                    pattern = node.id;
                    expression = node.init;
                } else if (node.type === "AssignmentExpression") {
                    pattern = node.left;
                    expression = node.right;
                } else { // UpdateExpression
                    pattern = node.argument;
                }

                for (const identifier of extractIdentifiersFromPattern(pattern)) {
                    const scope = sourceCode.getScope(identifier);

                    /** @type {Variable} */
                    const variable = findVariable(scope, identifier);

                    if (!variable) {
                        continue;
                    }

                    // We don't know where global variables are used.
                    if (variable.scope.type === "global" && variable.defs.length === 0) {
                        continue;
                    }

                    /*
                     * If the scope of the variable is outside the current code path scope,
                     * we cannot track whether this assignment is not used.
                     */
                    if (scopeStack.scope !== getCodePathStartScope(variable.scope)) {
                        continue;
                    }

                    // Variables marked by `markVariableAsUsed()` or
                    // exported by "exported" block comment.
                    if (variable.eslintUsed) {
                        continue;
                    }

                    // Variables exported by ESM export syntax
                    if (variable.scope.type === "module") {
                        if (
                            variable.defs
                                .some(def => (
                                    (def.type === "Variable" && def.parent.parent.type === "ExportNamedDeclaration") ||
                                    (
                                        def.type === "FunctionName" &&
                                        (
                                            def.node.parent.type === "ExportNamedDeclaration" ||
                                            def.node.parent.type === "ExportDefaultDeclaration"
                                        )
                                    ) ||
                                    (
                                        def.type === "ClassName" &&
                                        (
                                            def.node.parent.type === "ExportNamedDeclaration" ||
                                            def.node.parent.type === "ExportDefaultDeclaration"
                                        )
                                    )
                                ))
                        ) {
                            continue;
                        }
                        if (variable.references.some(reference => reference.identifier.parent.type === "ExportSpecifier")) {

                            // It have `export { ... }` reference.
                            continue;
                        }
                    }

                    let list = assignments.get(variable);

                    if (!list) {
                        list = [];
                        assignments.set(variable, list);
                    }
                    list.push({
                        variable,
                        identifier,
                        node,
                        expression,
                        segments: [...scopeStack.currentSegments]
                    });
                }
            }
        };
    }
};