const diagnostics = [];
// Basic syntax checking for SageMath
const lines = text.split('\n');
for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    // Check for common SageMath syntax issues
    // Check for unmatched parentheses, brackets, braces
    const openParens = (line.match(/\(/g) || []).length;
    const closeParens = (line.match(/\)/g) || []).length;
    if (openParens !== closeParens) {
        const diagnostic = {
            severity: node_1.DiagnosticSeverity.Warning,
            range: {
                start: { line: i, character: 0 },
                end: { line: i, character: line.length }
            },
            message: `Unmatched parentheses on line ${i + 1}`,
            source: 'sagemath-enhanced'
        };
        diagnostics.push(diagnostic);
    }
    // Check for undefined variables that might be typos

const OPENING_DELIMITERS = {
    '(': ')',
    '[': ']',
    '{': '}'
};
const CLOSING_DELIMITERS = {
    ')': '(',
    ']': '[',
    '}': '{'
};
function createDelimiterDiagnostic(line, character, lineLength, message) {
    return {
        severity: node_1.DiagnosticSeverity.Warning,
        range: {
            start: { line, character },
            end: { line, character: Math.min(character + 1, Math.max(lineLength, character + 1)) }
        },
        message,
        source: 'sagemath-enhanced'
    };
}
function collectDelimiterDiagnostics(lines) {
    const diagnostics = [];
    const stack = [];
    let stringState = undefined;
    for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
        const line = lines[lineNumber];
        for (let character = 0; character < line.length; character++) {
            const char = line[character];
            if (stringState) {
                if (stringState.escaped) {
                    stringState.escaped = false;
                    continue;
                }
                if (char === '\\') {
                    stringState.escaped = true;
                    continue;
                }
                if (stringState.triple) {
                    if (line.startsWith(stringState.quote.repeat(3), character)) {
                        character += 2;
                        stringState = undefined;
                    }
                }
                else if (char === stringState.quote) {
                    stringState = undefined;
                }
                continue;
            }
            if (char === '#') {
                break;
            }
            if (char === '"' || char === "'") {
                const triple = line.startsWith(char.repeat(3), character);
                stringState = { quote: char, triple, escaped: false };
                if (triple) {
                    character += 2;
                }
                continue;
            }
            if (OPENING_DELIMITERS[char]) {
                stack.push({ char, line: lineNumber, character });
                continue;
            }
            if (CLOSING_DELIMITERS[char]) {
                const opener = stack[stack.length - 1];
                if (opener && opener.char === CLOSING_DELIMITERS[char]) {
                    stack.pop();
                    continue;
                }
                diagnostics.push(createDelimiterDiagnostic(lineNumber, character, line.length, `Unmatched closing delimiter '${char}' on line ${lineNumber + 1}`));
            }
        }
        if (stringState && !stringState.triple) {
            stringState = undefined;
        }
    }
    for (const opener of stack) {
        diagnostics.push(createDelimiterDiagnostic(opener.line, opener.character, lines[opener.line].length, `Unmatched opening delimiter '${opener.char}' on line ${opener.line + 1}; expected '${OPENING_DELIMITERS[opener.char]}'`));
    }
    return diagnostics;
}

const diagnostics = [];
// Basic syntax checking for SageMath
const lines = text.split('\n');
diagnostics.push(...collectDelimiterDiagnostics(lines));
for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    // Check for undefined variables that might be typos

const runDisposable = vscode.commands.registerCommand('runsagemathfile.run', () => {
    const editor = vscode.window.activeTextEditor;
    if (!editor) {
        console.log('No editor is active');
        return;
    }
    const document = editor.document;
    if (document.languageId !== 'sage') {
        vscode.window.showInformationMessage('The active file is not a SageMath file');
        return;
    }
    const sagePath = vscode.workspace.getConfiguration().get('sagemathEnhanced.interpreterPath');

const runDisposable = vscode.commands.registerCommand('runsagemathfile.run', async () => {
    const editor = vscode.window.activeTextEditor;
    if (!editor) {
        console.log('No editor is active');
        return;
    }
    const document = editor.document;
    if (document.languageId !== 'sage') {
        vscode.window.showInformationMessage('The active file is not a SageMath file');
        return;
    }
    if (document.isDirty) {
        const saved = await document.save();
        if (!saved) {
            vscode.window.showErrorMessage('SageMath file was not saved. Run cancelled.');
            return;
        }
    }
    const sagePath = vscode.workspace.getConfiguration().get('sagemathEnhanced.interpreterPath');

function activate(context) {
    // Register the run command first to ensure it's available even if language server fails
    const runDisposable = vscode.commands.registerCommand('runsagemathfile.run', async () => {

context.subscriptions.push(runDisposable, restartDisposable);

function activate(context) {
    const moveCursorAfterSave = new Set();
    const ensureTrailingBlankLineDisposable = vscode.workspace.onWillSaveTextDocument(event => {
        const document = event.document;
        if (document.languageId !== 'sage') {
            return;
        }
        const text = document.getText();
        if (!text || text.endsWith('\n') || text.endsWith('\r')) {
            return;
        }
        const lastLine = document.lineAt(document.lineCount - 1);
        const endPosition = new vscode.Position(document.lineCount - 1, lastLine.text.length);
        const eol = document.eol === vscode.EndOfLine.CRLF ? '\r\n' : '\n';
        moveCursorAfterSave.add(document.uri.toString());
        event.waitUntil(Promise.resolve([vscode.TextEdit.insert(endPosition, eol)]));
    });
    const moveCursorToTrailingBlankLineDisposable = vscode.workspace.onDidSaveTextDocument(document => {
        const uri = document.uri.toString();
        if (!moveCursorAfterSave.delete(uri)) {
            return;
        }
        const editor = vscode.window.activeTextEditor;
        if (!editor || editor.document.uri.toString() !== uri) {
            return;
        }
        const position = new vscode.Position(document.lineCount - 1, 0);
        editor.selection = new vscode.Selection(position, position);
        editor.revealRange(new vscode.Range(position, position));
    });
    // Register the run command first to ensure it's available even if language server fails

context.subscriptions.push(ensureTrailingBlankLineDisposable, moveCursorToTrailingBlankLineDisposable, runDisposable, restartDisposable);