"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const regexpp_1 = require("@eslint-community/regexpp");
const utils_1 = require("../utils");
const mention_1 = require("../utils/mention");
const regex_syntax_1 = require("../utils/regex-syntax");
const validator = new regexpp_1.RegExpValidator({ strict: true, ecmaVersion: 2020 });
function validateRegExpPattern(pattern, flags) {
    try {
        validator.validatePattern(pattern, undefined, undefined, flags);
        return null;
    }
    catch (err) {
        return err instanceof Error ? err.message : null;
    }
}
const CHARACTER_CLASS_SYNTAX_CHARACTERS = new Set("\\/()[]{}^$.|-+*?".split(""));
const SYNTAX_CHARACTERS = new Set("\\/()[]{}^$.|+*?".split(""));
exports.default = (0, utils_1.createRule)("strict", {
    meta: {
        docs: {
            description: "disallow not strictly valid regular expressions",
            category: "Possible Errors",
            recommended: true,
        },
        fixable: "code",
        schema: [],
        messages: {
            invalidControlEscape: "Invalid or incomplete control escape sequence. Either use a valid control escape sequence or escaping the standalone backslash.",
            incompleteEscapeSequence: "Incomplete escape sequence {{expr}}. Either use a valid escape sequence or remove the useless escaping.",
            invalidPropertyEscape: "Invalid property escape sequence {{expr}}. Either use a valid property escape sequence or remove the useless escaping.",
            incompleteBackreference: "Incomplete backreference {{expr}}. Either use a valid backreference or remove the useless escaping.",
            unescapedSourceCharacter: "Unescaped source character {{expr}}.",
            octalEscape: "Invalid legacy octal escape sequence {{expr}}. Use a hexadecimal escape instead.",
            uselessEscape: "Useless identity escapes with non-syntax characters are forbidden.",
            invalidRange: "Invalid character class range. A character set cannot be the minimum or maximum of a character class range. Either escape the `-` or fix the character class range.",
            quantifiedAssertion: "Assertion are not allowed to be quantified directly.",
            regexMessage: "{{message}}.",
            hexEscapeSuggestion: "Replace the octal escape with a hexadecimal escape.",
        },
        type: "suggestion",
        hasSuggestions: true,
    },
    create(context) {
        function createVisitor(regexpContext) {
            const { node, flags, pattern, getRegexpLocation, fixReplaceNode } = regexpContext;
            if (flags.unicode || flags.unicodeSets) {
                return {};
            }
            let reported = false;
            let hasNamedBackreference = false;
            function report(messageId, element, fix) {
                reported = true;
                if (fix && typeof fix === "object") {
                    context.report({
                        node,
                        loc: getRegexpLocation(element),
                        messageId,
                        data: {
                            expr: (0, mention_1.mention)(element),
                        },
                        suggest: [
                            {
                                messageId: fix.messageId,
                                fix: fixReplaceNode(element, fix.fix),
                            },
                        ],
                    });
                }
                else {
                    context.report({
                        node,
                        loc: getRegexpLocation(element),
                        messageId,
                        data: {
                            expr: (0, mention_1.mention)(element),
                        },
                        fix: fix ? fixReplaceNode(element, fix) : null,
                    });
                }
            }
            return {
                onCharacterEnter(cNode) {
                    if (cNode.raw === "\\") {
                        report("invalidControlEscape", cNode);
                        return;
                    }
                    if (cNode.raw === "\\u" || cNode.raw === "\\x") {
                        report("incompleteEscapeSequence", cNode);
                        return;
                    }
                    if (cNode.raw === "\\p" || cNode.raw === "\\P") {
                        report("invalidPropertyEscape", cNode);
                        return;
                    }
                    if (cNode.value !== 0 && (0, regex_syntax_1.isOctalEscape)(cNode.raw)) {
                        report("octalEscape", cNode, {
                            fix: `\\x${cNode.value
                                .toString(16)
                                .padStart(2, "0")}`,
                            messageId: "hexEscapeSuggestion",
                        });
                        return;
                    }
                    const insideCharClass = cNode.parent.type === "CharacterClass" ||
                        cNode.parent.type === "CharacterClassRange";
                    if (!insideCharClass) {
                        if (cNode.raw === "\\k") {
                            report("incompleteBackreference", cNode);
                            return;
                        }
                        if (cNode.raw === "{" ||
                            cNode.raw === "}" ||
                            cNode.raw === "]") {
                            report("unescapedSourceCharacter", cNode, `\\${cNode.raw}`);
                            return;
                        }
                    }
                    if ((0, regex_syntax_1.isEscapeSequence)(cNode.raw)) {
                        return;
                    }
                    if (cNode.raw.startsWith("\\")) {
                        const identity = cNode.raw.slice(1);
                        const syntaxChars = insideCharClass
                            ? CHARACTER_CLASS_SYNTAX_CHARACTERS
                            : SYNTAX_CHARACTERS;
                        if (cNode.value === identity.charCodeAt(0) &&
                            !syntaxChars.has(identity)) {
                            report("uselessEscape", cNode, identity);
                        }
                    }
                },
                onCharacterClassEnter(ccNode) {
                    for (let i = 0; i < ccNode.elements.length; i++) {
                        const current = ccNode.elements[i];
                        if (current.type === "CharacterSet") {
                            const next = ccNode.elements[i + 1];
                            const nextNext = ccNode.elements[i + 2];
                            if (next && next.raw === "-" && nextNext) {
                                report("invalidRange", current);
                                return;
                            }
                            const prev = ccNode.elements[i - 1];
                            const prevPrev = ccNode.elements[i - 2];
                            if (prev &&
                                prev.raw === "-" &&
                                prevPrev &&
                                prevPrev.type !== "CharacterClassRange") {
                                report("invalidRange", current);
                                return;
                            }
                        }
                    }
                },
                onQuantifierEnter(qNode) {
                    if (qNode.element.type === "Assertion") {
                        report("quantifiedAssertion", qNode, `(?:${qNode.element.raw})${qNode.raw.slice(qNode.element.end - qNode.start)}`);
                    }
                },
                onBackreferenceEnter(bNode) {
                    if (typeof bNode.ref === "string") {
                        hasNamedBackreference = true;
                    }
                },
                onPatternLeave() {
                    if (hasNamedBackreference) {
                        return;
                    }
                    if (!reported) {
                        const message = validateRegExpPattern(pattern, flags);
                        if (message) {
                            context.report({
                                node,
                                messageId: "regexMessage",
                                data: {
                                    message,
                                },
                            });
                        }
                    }
                },
            };
        }
        return (0, utils_1.defineRegexpVisitor)(context, {
            createVisitor,
        });
    },
});