"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.CodeErrorProvider = void 0;
const vscode = __importStar(require("vscode"));
// 代码错误检测提供者类
class CodeErrorProvider {
    // 提供代码诊断信息
    static async provideDiagnostics(document, diagnostics) {
        const diagnosticList = [];
        let isInBlockComment = false; // 文档级别的块注释状态
        // 全文档检查，支持多行结构
        const documentText = document.getText();
        const lines = documentText.split('\n');
        // 检查未闭合的字符串（支持多行）
        diagnosticList.push(...this.checkForUnclosedStrings(document));
        // 检查未闭合的括号（支持多行）
        diagnosticList.push(...this.checkForUnclosedBrackets(document));
        // 逐行检查其他错误，传递块注释状态
        for (let i = 0; i < document.lineCount; i++) {
            const line = document.lineAt(i);
            const result = this.checkLineForErrors(line, i, isInBlockComment);
            diagnosticList.push(...result.diagnostics);
            isInBlockComment = result.isInBlockComment; // 更新块注释状态
        }
        // 发布诊断信息
        diagnostics.set(document.uri, diagnosticList);
    }
    // 检查单行代码错误，支持块注释状态跟踪
    static checkLineForErrors(line, lineIndex, isInBlockComment) {
        const diagnostics = [];
        const lineText = line.text;
        // 处理行注释和块注释状态
        const commentInfo = this.processCommentsAndGetValidText(lineText, isInBlockComment);
        // 如果整行都在注释中，直接返回
        if (commentInfo.skipEntireLine) {
            return { diagnostics, isInBlockComment: commentInfo.newBlockCommentState };
        }
        // 只对非注释部分进行错误检测
        if (commentInfo.validText.trim().length > 0) {
            // 检查常见的语法错误
            diagnostics.push(...this.checkForCommonSyntaxErrorsWithValidText(lineText, commentInfo.validText, commentInfo.validRange, lineIndex));
            // 检查可能的拼写错误
            diagnostics.push(...this.checkForPossibleTyposWithValidText(lineText, commentInfo.validText, commentInfo.validRange, lineIndex));
        }
        return {
            diagnostics,
            isInBlockComment: commentInfo.newBlockCommentState
        };
    }
    // 处理注释并获取有效的代码文本
    static processCommentsAndGetValidText(lineText, isInBlockComment) {
        let currentBlockCommentState = isInBlockComment;
        // 如果整行都在块注释中，先检查是否有结束标记
        if (currentBlockCommentState) {
            const blockCommentEnd = lineText.indexOf('*/');
            if (blockCommentEnd !== -1) {
                // 找到块注释结束，从结束位置后开始处理
                currentBlockCommentState = false;
                const remainingLine = lineText.substring(blockCommentEnd + 2);
                // 递归处理剩余部分
                const remainingResult = this.processCommentsAndGetValidText(remainingLine, false);
                return {
                    validText: remainingResult.validText,
                    validRange: {
                        start: blockCommentEnd + 2 + remainingResult.validRange.start,
                        end: blockCommentEnd + 2 + remainingResult.validRange.end
                    },
                    skipEntireLine: remainingResult.skipEntireLine,
                    newBlockCommentState: remainingResult.newBlockCommentState
                };
            }
            else {
                // 整行都在块注释中
                return {
                    validText: '',
                    validRange: { start: 0, end: 0 },
                    skipEntireLine: true,
                    newBlockCommentState: true
                };
            }
        }
        // 现在处理这一行，移除所有注释，只保留有效代码部分
        let result = '';
        let validRanges = [];
        let inString = false;
        let stringChar = '';
        let escaped = false;
        let i = 0;
        let currentValidStart = 0;
        while (i < lineText.length) {
            const char = lineText[i];
            const nextChar = i < lineText.length - 1 ? lineText[i + 1] : '';
            // 处理字符串状态
            if (!inString) {
                if (char === '"' || char === "'") {
                    inString = true;
                    stringChar = char;
                    escaped = false;
                }
            }
            else {
                if (escaped) {
                    escaped = false;
                    i++;
                    continue;
                }
                if (char === '\\') {
                    escaped = true;
                    i++;
                    continue;
                }
                if (char === stringChar) {
                    inString = false;
                    stringChar = '';
                    i++;
                    continue;
                }
                i++;
                continue;
            }
            // 只有在非字符串状态下才检查注释
            if (!inString) {
                // 检查行注释 // (优先级最高)
                if (char === '/' && nextChar === '/') {
                    // 遇到行注释，保存当前有效部分，后续全部跳过
                    if (i > currentValidStart) {
                        validRanges.push({ start: currentValidStart, end: i });
                        result += lineText.substring(currentValidStart, i);
                    }
                    break; // 行注释后面的内容全部跳过
                }
                // 检查块注释开始 /*
                if (char === '/' && nextChar === '*') {
                    // 保存块注释前的有效部分
                    if (i > currentValidStart) {
                        validRanges.push({ start: currentValidStart, end: i });
                        result += lineText.substring(currentValidStart, i);
                    }
                    // 寻找块注释结束
                    const blockCommentEnd = lineText.indexOf('*/', i + 2);
                    if (blockCommentEnd !== -1) {
                        // 同行找到块注释结束，跳过整个块注释
                        i = blockCommentEnd + 2;
                        currentValidStart = i;
                        continue;
                    }
                    else {
                        // 没有找到结束标记，块注释延续到下一行
                        currentBlockCommentState = true;
                        break;
                    }
                }
            }
            i++;
        }
        // 添加最后的有效部分
        if (!currentBlockCommentState && currentValidStart < lineText.length) {
            validRanges.push({ start: currentValidStart, end: lineText.length });
            result += lineText.substring(currentValidStart);
        }
        // 如果没有有效内容，返回空
        if (validRanges.length === 0) {
            return {
                validText: '',
                validRange: { start: 0, end: 0 },
                skipEntireLine: true,
                newBlockCommentState: currentBlockCommentState
            };
        }
        // 返回第一个有效范围（简化处理，实际使用时会在所有有效范围中检查）
        return {
            validText: result,
            validRange: { start: validRanges[0].start, end: validRanges[validRanges.length - 1].end },
            skipEntireLine: result.trim().length === 0,
            newBlockCommentState: currentBlockCommentState
        };
    }
    // 检查指定位置是否在字符串中
    static isInString(line, position) {
        let inString = false;
        let stringChar = '';
        let escaped = false;
        for (let i = 0; i < position && i < line.length; i++) {
            const char = line[i];
            if (!inString) {
                if (char === '"' || char === "'") {
                    inString = true;
                    stringChar = char;
                    escaped = false;
                }
            }
            else {
                if (escaped) {
                    escaped = false;
                    continue;
                }
                if (char === '\\') {
                    escaped = true;
                    continue;
                }
                if (char === stringChar) {
                    inString = false;
                    stringChar = '';
                }
            }
        }
        return inString;
    }
    // 基于有效文本范围检查语法错误
    static checkForCommonSyntaxErrorsWithValidText(originalLine, validText, validRange, lineIndex) {
        const diagnostics = [];
        // 跳过空行
        if (validText.trim().length === 0) {
            return diagnostics;
        }
        // 由于validText可能是多个片段拼接的结果，我们需要直接在原始行中查找
        // 但只检查那些不在注释和字符串中的位置
        const typoPatterns = [
            { pattern: /\bloacl\b/g, correct: 'local', message: '拼写错误：应该是 "local" 而不是 "loacl"' },
            { pattern: /\bfunctoin\b/g, correct: 'function', message: '拼写错误：应该是 "function" 而不是 "functoin"' },
            { pattern: /\bretun\b/g, correct: 'return', message: '拼写错误：应该是 "return" 而不是 "retun"' },
            { pattern: /\bwhlie\b/g, correct: 'while', message: '拼写错误：应该是 "while" 而不是 "whlie"' },
            { pattern: /\belsee\b/g, correct: 'else', message: '拼写错误：应该是 "else" 而不是 "elsee"' },
            { pattern: /\bforech\b/g, correct: 'foreach', message: '拼写错误：应该是 "foreach" 而不是 "forech"' },
            { pattern: /\bclas\b/g, correct: 'class', message: '拼写错误：应该是 "class" 而不是 "clas"' },
            { pattern: /\bbreka\b/g, correct: 'break', message: '拼写错误：应该是 "break" 而不是 "breka"' },
            { pattern: /\bcontineu\b/g, correct: 'continue', message: '拼写错误：应该是 "continue" 而不是 "contineu"' }
        ];
        typoPatterns.forEach(({ pattern, correct, message }) => {
            let match;
            // 在原始行中查找所有匹配
            while ((match = pattern.exec(originalLine)) !== null) {
                const matchPosition = match.index;
                // 检查这个位置是否在有效的代码区域（不在注释或字符串中）
                if (this.isPositionInValidCode(originalLine, matchPosition)) {
                    const range = new vscode.Range(new vscode.Position(lineIndex, matchPosition), new vscode.Position(lineIndex, matchPosition + match[0].length));
                    const diagnostic = new vscode.Diagnostic(range, message, vscode.DiagnosticSeverity.Error);
                    diagnostic.tags = [vscode.DiagnosticTag.Deprecated];
                    diagnostics.push(diagnostic);
                }
            }
        });
        return diagnostics;
    }
    // 检查指定位置是否在有效代码中（不在注释或字符串中）
    static isPositionInValidCode(line, position) {
        let inString = false;
        let stringChar = '';
        let escaped = false;
        let inBlockComment = false;
        for (let i = 0; i < position && i < line.length; i++) {
            const char = line[i];
            const nextChar = i < line.length - 1 ? line[i + 1] : '';
            // 如果在块注释中，检查是否遇到结束标记
            if (inBlockComment) {
                if (char === '*' && nextChar === '/') {
                    inBlockComment = false;
                    i++; // 跳过 '/'
                }
                continue;
            }
            // 处理字符串状态
            if (!inString) {
                if (char === '"' || char === "'") {
                    inString = true;
                    stringChar = char;
                    escaped = false;
                }
            }
            else {
                if (escaped) {
                    escaped = false;
                    continue;
                }
                if (char === '\\') {
                    escaped = true;
                    continue;
                }
                if (char === stringChar) {
                    inString = false;
                    stringChar = '';
                }
                continue;
            }
            // 只有在非字符串状态下才检查注释
            if (!inString) {
                // 检查行注释
                if (char === '/' && nextChar === '/') {
                    return false; // 位置在行注释中
                }
                // 检查块注释开始
                if (char === '/' && nextChar === '*') {
                    inBlockComment = true;
                    i++; // 跳过 '*'
                    continue;
                }
            }
        }
        // 如果到达目标位置时仍在字符串或块注释中，则该位置无效
        return !inString && !inBlockComment;
    }
    // 基于有效文本范围检查可能的拼写错误
    static checkForPossibleTyposWithValidText(originalLine, validText, validRange, lineIndex) {
        const diagnostics = [];
        // 暂时空实现，可以后续扩展
        return diagnostics;
    }
    // 检查常见的语法错误
    static checkForCommonSyntaxErrors(lineText, lineIndex) {
        const diagnostics = [];
        // 跳过空行
        const trimmedLine = lineText.trim();
        if (trimmedLine.length === 0) {
            return diagnostics;
        }
        // 检查是否使用了错误的关键字拼写（仅检查明显的拼写错误）
        const typoPatterns = [
            { pattern: /\bloacl\b/g, correct: 'local', message: '拼写错误：应该是 "local" 而不是 "loacl"' },
            { pattern: /\bfunctoin\b/g, correct: 'function', message: '拼写错误：应该是 "function" 而不是 "functoin"' },
            { pattern: /\bretun\b/g, correct: 'return', message: '拼写错误：应该是 "return" 而不是 "retun"' },
            { pattern: /\bwhlie\b/g, correct: 'while', message: '拼写错误：应该是 "while" 而不是 "whlie"' },
            { pattern: /\belsee\b/g, correct: 'else', message: '拼写错误：应该是 "else" 而不是 "elsee"' },
            { pattern: /\bforech\b/g, correct: 'foreach', message: '拼写错误：应该是 "foreach" 而不是 "forech"' },
            { pattern: /\bclas\b/g, correct: 'class', message: '拼写错误：应该是 "class" 而不是 "clas"' },
            { pattern: /\bbreka\b/g, correct: 'break', message: '拼写错误：应该是 "break" 而不是 "breka"' },
            { pattern: /\bcontineu\b/g, correct: 'continue', message: '拼写错误：应该是 "continue" 而不是 "contineu"' }
        ];
        typoPatterns.forEach(({ pattern, correct, message }) => {
            let match;
            while ((match = pattern.exec(lineText)) !== null) {
                // 检查这个匹配是否在注释或字符串中
                if (this.isPositionInCommentOrString(lineText, match.index)) {
                    continue;
                }
                const range = new vscode.Range(new vscode.Position(lineIndex, match.index), new vscode.Position(lineIndex, match.index + match[0].length));
                const diagnostic = new vscode.Diagnostic(range, message, vscode.DiagnosticSeverity.Error);
                // 添加快速修复信息
                diagnostic.tags = [vscode.DiagnosticTag.Deprecated];
                diagnostics.push(diagnostic);
            }
        });
        // 检查赋值操作符错误（使用 = 而不是 == 进行比较）
        // 更精确的正则表达式，避免误报
        const assignmentPattern = /\b(if|while)\s*\(\s*[^=<>!]*\s=(?!=)\s*[^=][^)]*\)/g;
        let assignmentMatch;
        while ((assignmentMatch = assignmentPattern.exec(lineText)) !== null) {
            // 检查这个匹配是否在注释或字符串中
            if (this.isPositionInCommentOrString(lineText, assignmentMatch.index)) {
                continue;
            }
            // 排除明显的合法赋值情况
            const matchText = assignmentMatch[0];
            // 检查是否是函数调用或其他合法语法
            if (!matchText.includes('()') && !matchText.includes('new ')) {
                const range = new vscode.Range(new vscode.Position(lineIndex, assignmentMatch.index), new vscode.Position(lineIndex, assignmentMatch.index + assignmentMatch[0].length));
                const diagnostic = new vscode.Diagnostic(range, '可能的逻辑错误：在条件语句中使用了赋值操作符 "=" 而不是比较操作符 "=="', vscode.DiagnosticSeverity.Warning);
                diagnostics.push(diagnostic);
            }
        }
        // 检查常见的语法结构错误
        // 检查函数定义语法
        if (lineText.includes('function') && !lineText.match(/function\s+[a-zA-Z_]\w*\s*\(/)) {
            const functionMatch = lineText.match(/function\s*\(/);
            if (functionMatch && !this.isPositionInCommentOrString(lineText, functionMatch.index)) {
                const range = new vscode.Range(new vscode.Position(lineIndex, functionMatch.index), new vscode.Position(lineIndex, functionMatch.index + functionMatch[0].length));
                const diagnostic = new vscode.Diagnostic(range, '语法错误：函数定义缺少函数名', vscode.DiagnosticSeverity.Error);
                diagnostics.push(diagnostic);
            }
        }
        // 检查缺少分号的语句（仅对明显需要分号的语句检查）
        const needsSemicolon = /\b(local|return|break|continue)\s+[^;\/]*[^;\s\/]$/;
        if (needsSemicolon.test(trimmedLine) && !trimmedLine.endsWith(';') && !trimmedLine.endsWith('{')) {
            // 确保这不是在注释中
            const cleanLine = this.removeStringsAndComments(lineText);
            if (cleanLine.trim()) {
                const range = new vscode.Range(new vscode.Position(lineIndex, lineText.length - 1), new vscode.Position(lineIndex, lineText.length));
                const diagnostic = new vscode.Diagnostic(range, '可能缺少分号', vscode.DiagnosticSeverity.Information);
                diagnostics.push(diagnostic);
            }
        }
        return diagnostics;
    }
    // 检查未闭合的字符串（支持多行文档检查）
    static checkForUnclosedStrings(document) {
        const diagnostics = [];
        const text = document.getText();
        // 使用状态机来正确解析字符串
        let inString = false;
        let stringStartPos = null;
        let stringChar = '';
        let escaped = false;
        let inLineComment = false;
        let inBlockComment = false;
        const lines = text.split('\n');
        for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
            const line = lines[lineIndex];
            // 检查是否整行都是注释（以 // 开头）
            const trimmedLine = line.trim();
            if (trimmedLine.startsWith('//')) {
                inLineComment = true;
            }
            for (let charIndex = 0; charIndex < line.length; charIndex++) {
                const char = line[charIndex];
                const nextChar = charIndex < line.length - 1 ? line[charIndex + 1] : '';
                // 处理注释
                if (!inString) {
                    if (!inBlockComment && char === '/' && nextChar === '/') {
                        inLineComment = true;
                        charIndex++; // 跳过下一个字符
                        continue;
                    }
                    if (!inLineComment && char === '/' && nextChar === '*') {
                        inBlockComment = true;
                        charIndex++; // 跳过下一个字符
                        continue;
                    }
                    if (inBlockComment && char === '*' && nextChar === '/') {
                        inBlockComment = false;
                        charIndex++; // 跳过下一个字符
                        continue;
                    }
                }
                // 如果在注释中，跳过所有处理
                if (inLineComment || inBlockComment) {
                    continue;
                }
                if (!inString) {
                    // 检查字符串开始
                    if (char === '"' || char === "'") {
                        inString = true;
                        stringChar = char;
                        stringStartPos = new vscode.Position(lineIndex, charIndex);
                        escaped = false;
                    }
                }
                else {
                    // 在字符串中
                    if (escaped) {
                        escaped = false;
                        continue;
                    }
                    if (char === '\\') {
                        escaped = true;
                        continue;
                    }
                    if (char === stringChar) {
                        // 字符串结束
                        inString = false;
                        stringStartPos = null;
                        stringChar = '';
                    }
                }
            }
            // 行结束处理
            inLineComment = false; // 行注释在行末结束
            // 只有在非注释行且有未闭合字符串时才报告错误
            if (inString && stringStartPos && stringStartPos.line === lineIndex && !trimmedLine.startsWith('//')) {
                // 如果字符串在当前行开始但没有结束，报告错误
                const range = new vscode.Range(stringStartPos, new vscode.Position(lineIndex, line.length));
                const diagnostic = new vscode.Diagnostic(range, `字符串未正确闭合：缺少结束${stringChar === '"' ? '双' : '单'}引号`, vscode.DiagnosticSeverity.Error);
                diagnostics.push(diagnostic);
                // 重置状态，避免后续行都报错
                inString = false;
                stringStartPos = null;
            }
        }
        // 如果文档结束时还有未闭合的字符串，并且不在注释中
        if (inString && stringStartPos) {
            const lastLine = lines.length - 1;
            const lastLineTrimmed = lines[lastLine].trim();
            if (!lastLineTrimmed.startsWith('//')) {
                const range = new vscode.Range(stringStartPos, new vscode.Position(lastLine, lines[lastLine].length));
                const diagnostic = new vscode.Diagnostic(range, `字符串未正确闭合：缺少结束${stringChar === '"' ? '双' : '单'}引号`, vscode.DiagnosticSeverity.Error);
                diagnostics.push(diagnostic);
            }
        }
        return diagnostics;
    }
    // 检查未闭合的括号（支持多行文档检查）
    static checkForUnclosedBrackets(document) {
        const diagnostics = [];
        const text = document.getText();
        // 括号栈，记录每个开括号的位置和类型
        const bracketStack = [];
        const bracketPairs = [
            { open: '(', close: ')', name: '圆括号' },
            { open: '[', close: ']', name: '方括号' },
            { open: '{', close: '}', name: '花括号' }
        ];
        // 状态追踪
        let inString = false;
        let stringChar = '';
        let escaped = false;
        let inLineComment = false;
        let inBlockComment = false;
        const lines = text.split('\n');
        for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
            const line = lines[lineIndex];
            // 检查是否整行都是注释（以 // 开头）
            const trimmedLine = line.trim();
            const isCommentLine = trimmedLine.startsWith('//');
            for (let charIndex = 0; charIndex < line.length; charIndex++) {
                const char = line[charIndex];
                const nextChar = charIndex < line.length - 1 ? line[charIndex + 1] : '';
                // 处理注释
                if (!inString) {
                    if (!inBlockComment && char === '/' && nextChar === '/') {
                        inLineComment = true;
                        charIndex++; // 跳过下一个字符
                        continue;
                    }
                    if (!inLineComment && char === '/' && nextChar === '*') {
                        inBlockComment = true;
                        charIndex++; // 跳过下一个字符
                        continue;
                    }
                    if (inBlockComment && char === '*' && nextChar === '/') {
                        inBlockComment = false;
                        charIndex++; // 跳过下一个字符
                        continue;
                    }
                }
                // 如果在注释中，跳过所有处理
                if (inLineComment || inBlockComment || isCommentLine) {
                    continue;
                }
                // 处理字符串状态
                if (!inString) {
                    if (char === '"' || char === "'") {
                        inString = true;
                        stringChar = char;
                        escaped = false;
                    }
                }
                else {
                    if (escaped) {
                        escaped = false;
                        continue;
                    }
                    if (char === '\\') {
                        escaped = true;
                        continue;
                    }
                    if (char === stringChar) {
                        inString = false;
                        stringChar = '';
                    }
                    continue; // 在字符串中，跳过括号检查
                }
                // 检查括号（只在非字符串、非注释中）
                if (!inString && !inLineComment && !inBlockComment && !isCommentLine) {
                    const openBracket = bracketPairs.find(bp => bp.open === char);
                    if (openBracket) {
                        bracketStack.push({
                            char: char,
                            position: new vscode.Position(lineIndex, charIndex),
                            name: openBracket.name,
                            inComment: false
                        });
                    }
                    else {
                        const closeBracket = bracketPairs.find(bp => bp.close === char);
                        if (closeBracket) {
                            if (bracketStack.length === 0) {
                                // 多余的闭合括号
                                const range = new vscode.Range(new vscode.Position(lineIndex, charIndex), new vscode.Position(lineIndex, charIndex + 1));
                                const diagnostic = new vscode.Diagnostic(range, `多余的${closeBracket.name}闭合符`, vscode.DiagnosticSeverity.Error);
                                diagnostics.push(diagnostic);
                            }
                            else {
                                const lastOpen = bracketStack.pop();
                                const expectedClose = bracketPairs.find(bp => bp.open === lastOpen.char)?.close;
                                if (expectedClose !== char) {
                                    // 括号不匹配
                                    const range = new vscode.Range(new vscode.Position(lineIndex, charIndex), new vscode.Position(lineIndex, charIndex + 1));
                                    const diagnostic = new vscode.Diagnostic(range, `括号不匹配：期望 "${expectedClose}" 但找到 "${char}"`, vscode.DiagnosticSeverity.Error);
                                    diagnostics.push(diagnostic);
                                    // 也标记未匹配的开括号
                                    const openRange = new vscode.Range(lastOpen.position, new vscode.Position(lastOpen.position.line, lastOpen.position.character + 1));
                                    const openDiagnostic = new vscode.Diagnostic(openRange, `未匹配的${lastOpen.name}`, vscode.DiagnosticSeverity.Error);
                                    diagnostics.push(openDiagnostic);
                                }
                            }
                        }
                    }
                }
            }
            // 行结束处理
            inLineComment = false; // 行注释在行末结束
        }
        // 检查未闭合的开括号（排除在注释中的括号）
        bracketStack.forEach(bracket => {
            if (!bracket.inComment) {
                const range = new vscode.Range(bracket.position, new vscode.Position(bracket.position.line, bracket.position.character + 1));
                const diagnostic = new vscode.Diagnostic(range, `未闭合的${bracket.name}`, vscode.DiagnosticSeverity.Error);
                diagnostics.push(diagnostic);
            }
        });
        return diagnostics;
    }
    // 检查可能的拼写错误
    static checkForPossibleTypos(lineText, lineIndex) {
        const diagnostics = [];
        // 跳过空行
        const trimmedLine = lineText.trim();
        if (trimmedLine.length === 0) {
            return diagnostics;
        }
        // 更完整的Squirrel关键字列表
        const squirrelKeywords = [
            'function', 'local', 'if', 'else', 'while', 'for', 'foreach', 'in',
            'return', 'break', 'continue', 'class', 'extends', 'constructor',
            'null', 'true', 'false', 'try', 'catch', 'throw', 'const',
            'enum', 'switch', 'case', 'default', 'delete', 'typeof',
            'clone', 'resume', 'yield', 'static', 'this', 'base'
        ];
        // 提取标识符（避免数字、操作符等）
        const wordPattern = /\b[a-zA-Z_]\w{2,}\b/g;
        let match;
        while ((match = wordPattern.exec(lineText)) !== null) {
            const word = match[0];
            const wordLower = word.toLowerCase();
            const startIndex = match.index;
            // 检查这个单词是否在注释或字符串中
            if (this.isPositionInCommentOrString(lineText, startIndex)) {
                continue;
            }
            // 跳过已知的关键字（正确拼写）
            if (squirrelKeywords.includes(wordLower)) {
                continue;
            }
            // 跳过常见的标识符模式（避免误报）
            if (this.isLikelyValidIdentifier(word)) {
                continue;
            }
            // 检查是否与关键字相似
            const similarKeyword = squirrelKeywords.find(keyword => {
                const distance = this.editDistance(wordLower, keyword);
                // 只对编辑距离为1-2且长度相近的单词提示
                return distance >= 1 && distance <= 2 &&
                    Math.abs(word.length - keyword.length) <= 2;
            });
            if (similarKeyword) {
                const range = new vscode.Range(new vscode.Position(lineIndex, startIndex), new vscode.Position(lineIndex, startIndex + word.length));
                const diagnostic = new vscode.Diagnostic(range, `可能的拼写错误：您是否想输入 "${similarKeyword}"?`, vscode.DiagnosticSeverity.Hint);
                diagnostics.push(diagnostic);
            }
        }
        return diagnostics;
    }
    // 检查指定位置是否在注释或字符串中
    static isPositionInCommentOrString(line, position) {
        let inString = false;
        let stringChar = '';
        let escaped = false;
        let inBlockComment = false;
        for (let i = 0; i < position && i < line.length; i++) {
            const char = line[i];
            const nextChar = i < line.length - 1 ? line[i + 1] : '';
            if (inBlockComment) {
                if (char === '*' && nextChar === '/') {
                    inBlockComment = false;
                    i++; // 跳过 '/'
                }
                continue;
            }
            // 检查行注释
            if (char === '/' && nextChar === '/') {
                return true; // 位置在行注释中
            }
            // 检查块注释开始
            if (char === '/' && nextChar === '*') {
                inBlockComment = true;
                i++; // 跳过 '*'
                continue;
            }
            if (!inString) {
                if (char === '"' || char === "'") {
                    inString = true;
                    stringChar = char;
                    escaped = false;
                }
            }
            else {
                if (escaped) {
                    escaped = false;
                    continue;
                }
                if (char === '\\') {
                    escaped = true;
                    continue;
                }
                if (char === stringChar) {
                    inString = false;
                    stringChar = '';
                }
            }
        }
        return inString || inBlockComment;
    }
    // 移除字符串和注释内容，避免对其中的内容进行拼写检查
    static removeStringsAndComments(line) {
        let result = '';
        let inString = false;
        let stringChar = '';
        let escaped = false;
        let inLineComment = false;
        let inBlockComment = false;
        for (let i = 0; i < line.length; i++) {
            const char = line[i];
            const nextChar = i < line.length - 1 ? line[i + 1] : '';
            // 如果已经在行注释中，所有后续字符都用空格替换
            if (inLineComment) {
                result += ' ';
                continue;
            }
            // 如果已经在块注释中，检查结束标记
            if (inBlockComment) {
                if (char === '*' && nextChar === '/') {
                    inBlockComment = false;
                    result += '  '; // 用空格替换 */ 
                    i++; // 跳过下一个字符
                }
                else {
                    result += ' '; // 用空格替换块注释内容
                }
                continue;
            }
            if (!inString) {
                // 检查行注释开始
                if (char === '/' && nextChar === '/') {
                    inLineComment = true;
                    result += '  '; // 用空格替换 //
                    i++; // 跳过下一个字符
                    continue;
                }
                // 检查块注释开始
                if (char === '/' && nextChar === '*') {
                    inBlockComment = true;
                    result += '  '; // 用空格替换 /*
                    i++; // 跳过下一个字符
                    continue;
                }
                // 检查字符串开始
                if (char === '"' || char === "'") {
                    inString = true;
                    stringChar = char;
                    escaped = false;
                    result += ' '; // 用空格替换字符串内容
                    continue;
                }
            }
            else {
                // 在字符串中处理转义和结束
                if (escaped) {
                    escaped = false;
                    result += ' ';
                    continue;
                }
                if (char === '\\') {
                    escaped = true;
                    result += ' ';
                    continue;
                }
                if (char === stringChar) {
                    inString = false;
                    stringChar = '';
                    result += ' ';
                    continue;
                }
                result += ' '; // 用空格替换字符串内容
                continue;
            }
            // 保留非字符串、非注释的字符
            result += char;
        }
        return result;
    }
    // 判断是否是可能的有效标识符（减少误报）
    static isLikelyValidIdentifier(word) {
        // 常见的有效标识符模式
        const validPatterns = [
            /^[A-Z][A-Z_0-9]+$/, // 常量名（全大写）
            /^[a-z][a-zA-Z0-9]*$/, // 驼峰命名
            /^[a-z]+_[a-z0-9_]*$/, // 下划线命名
            /^[A-Z][a-zA-Z0-9]*$/, // 帕斯卡命名
            /^\w+\d+$/, // 带数字结尾
            /^get[A-Z]/, // getter方法
            /^set[A-Z]/, // setter方法
            /^is[A-Z]/, // 布尔方法
            /^has[A-Z]/, // 检查方法
        ];
        return validPatterns.some(pattern => pattern.test(word));
    }
    // 计算两个字符串之间的编辑距离（Levenshtein距离）
    static editDistance(str1, str2) {
        const matrix = [];
        // 初始化矩阵
        for (let i = 0; i <= str2.length; i++) {
            matrix[i] = [i];
        }
        for (let j = 0; j <= str1.length; j++) {
            matrix[0][j] = j;
        }
        // 填充矩阵
        for (let i = 1; i <= str2.length; i++) {
            for (let j = 1; j <= str1.length; j++) {
                if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
                    matrix[i][j] = matrix[i - 1][j - 1];
                }
                else {
                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // 替换
                    matrix[i][j - 1] + 1, // 插入
                    matrix[i - 1][j] + 1 // 删除
                    );
                }
            }
        }
        return matrix[str2.length][str1.length];
    }
    // 实现CodeActionProvider接口
    async provideCodeActions(document, range, context, token) {
        const actions = [];
        // 为诊断问题提供快速修复
        for (const diagnostic of context.diagnostics) {
            // 拼写错误快速修复
            if (diagnostic.message.includes('可能的拼写错误：您是否想输入')) {
                const match = diagnostic.message.match(/您是否想输入 "([^"]+)"\?/);
                if (match) {
                    const correctWord = match[1];
                    const action = new vscode.CodeAction(`将 "${document.getText(diagnostic.range)}" 更正为 "${correctWord}"`, vscode.CodeActionKind.QuickFix);
                    action.edit = new vscode.WorkspaceEdit();
                    action.edit.replace(document.uri, diagnostic.range, correctWord);
                    action.isPreferred = true;
                    actions.push(action);
                }
            }
            // 明显拼写错误快速修复
            else if (diagnostic.message.includes('拼写错误：应该是')) {
                const match = diagnostic.message.match(/应该是 "([^"]+)" 而不是 "[^"]+"/);
                if (match) {
                    const correctWord = match[1];
                    const action = new vscode.CodeAction(`更正拼写为 "${correctWord}"`, vscode.CodeActionKind.QuickFix);
                    action.edit = new vscode.WorkspaceEdit();
                    action.edit.replace(document.uri, diagnostic.range, correctWord);
                    action.isPreferred = true;
                    actions.push(action);
                }
            }
            // 添加分号快速修复
            else if (diagnostic.message.includes('可能缺少分号')) {
                const action = new vscode.CodeAction('添加分号', vscode.CodeActionKind.QuickFix);
                action.edit = new vscode.WorkspaceEdit();
                const line = document.lineAt(diagnostic.range.start.line);
                const endPos = new vscode.Position(line.lineNumber, line.text.length);
                action.edit.insert(document.uri, endPos, ';');
                actions.push(action);
            }
            // 修复赋值操作符错误
            else if (diagnostic.message.includes('使用了赋值操作符 "=" 而不是比较操作符')) {
                const action = new vscode.CodeAction('将 "=" 更改为 "=="', vscode.CodeActionKind.QuickFix);
                action.edit = new vscode.WorkspaceEdit();
                const text = document.getText(diagnostic.range);
                const fixedText = text.replace(/([^=])=([^=])/g, '$1==$2');
                action.edit.replace(document.uri, diagnostic.range, fixedText);
                actions.push(action);
            }
        }
        return actions;
    }
}
exports.CodeErrorProvider = CodeErrorProvider;
//# sourceMappingURL=codeErrorProvider.js.map