extension.js

const vscode = require('vscode');
const path = require('path');

const testCommand = 'composer test';
let persistentTerminal = null;

/**
 * Gets or creates a persistent terminal for running tests
 * @returns {vscode.Terminal}
 */
function getOrCreateTerminal() {
    if (!persistentTerminal) {
        persistentTerminal = vscode.window.createTerminal('Test Runner');
    }
    return persistentTerminal;
}

/**
 * Runs a command in the persistent terminal
 * @param {string} command The command to run
 * @param {string} message The message to show
 */
async function runInTerminal(command, message) {
    const terminal = getOrCreateTerminal();
    terminal.show();
    terminal.sendText(command);
    vscode.window.showInformationMessage(message);
}

/**
 * Activates the extension
 * @param {vscode.ExtensionContext} context
 */
function activate(context) {
    console.log('Test Runner extension is now active');

    // Register the command to run test for current function
    let runTestFunction = vscode.commands.registerCommand('test-runner.runTest', async function () {
        try {
            const editor = vscode.window.activeTextEditor;
            if (!editor) {
                vscode.window.showErrorMessage('No active editor found');
                return;
            }

            const document = editor.document;
            const filePath = document.fileName;

            // Check if this is a test file (contains "Test" in the filename or path)
            if (!isTestFile(filePath)) {
                vscode.window.showErrorMessage('Not a test file. File name or path should contain "Test" or "test"');
                return;
            }

            // Get the workspace folder
            const workspaceFolder = vscode.workspace.getWorkspaceFolder(document.uri);
            if (!workspaceFolder) {
                vscode.window.showErrorMessage('File is not part of a workspace');
                return;
            }

            // Get the relative path from the workspace root
            const relativePath = path.relative(workspaceFolder.uri.fsPath, filePath);

            // Get the current function name
            const functionName = getCurrentFunctionName(document, editor.selection.active.line);
            if (!functionName) {
                vscode.window.showErrorMessage('No test function found at cursor position');
                return;
            }

            // Format and run the command
            const command = `${testCommand} ${relativePath}:${functionName}`;
            await runInTerminal(command, `Running test for function: ${functionName}`);
        } catch (error) {
            vscode.window.showErrorMessage(`Error: ${error.message}`);
        }
    });

    // Register the command to run tests for current file
    let runFileTests = vscode.commands.registerCommand('test-runner.runFileTests', async function () {
        try {
            const editor = vscode.window.activeTextEditor;
            if (!editor) {
                vscode.window.showErrorMessage('No active editor found');
                return;
            }

            const document = editor.document;
            const filePath = document.fileName;

            // Check if this is a test file (contains "Test" in the filename or path)
            if (!isTestFile(filePath)) {
                vscode.window.showErrorMessage('Not a test file. File name or path should contain "Test" or "test"');
                return;
            }

            // Get the workspace folder
            const workspaceFolder = vscode.workspace.getWorkspaceFolder(document.uri);
            if (!workspaceFolder) {
                vscode.window.showErrorMessage('File is not part of a workspace');
                return;
            }

            // Get the relative path from the workspace root
            const relativePath = path.relative(workspaceFolder.uri.fsPath, filePath);

            // Format and run the command
            const command = `${testCommand} ${relativePath}`;
            await runInTerminal(command, `Running tests for file: ${relativePath}`);
        } catch (error) {
            vscode.window.showErrorMessage(`Error: ${error.message}`);
        }
    });

    context.subscriptions.push(runTestFunction, runFileTests);
}

/**
 * Checks if the file is a test file
 * @param {string} filePath
 * @returns {boolean}
 */
function isTestFile(filePath) {
    const fileName = path.basename(filePath);
    const fileDir = path.dirname(filePath);

    // Check if the file name or path contains "Test" or "test"
    return fileName.includes('Test') ||
           fileName.includes('test') ||
           fileDir.includes('Test') ||
           fileDir.includes('test') ||
           fileDir.includes('tests');
}

/**
 * Gets the current function name based on the cursor position
 * @param {vscode.TextDocument} document
 * @param {number} currentLine
 * @returns {string|null} The function name or null if not found
 */
function getCurrentFunctionName(document, currentLine) {
    // For PHP test files, look for function patterns
    const phpFunctionRegex = /\s*(public|protected|private)?\s*function\s+(\w+)\s*\(/;
    const phpMethodRegex = /\s*function\s+(\w+)\s*\(/;

    // Start from the current line and go up to find the function declaration
    for (let i = currentLine; i >= 0; i--) {
        const line = document.lineAt(i).text;

        // Try to match PHP function patterns
        let match = line.match(phpFunctionRegex);
        if (match && match[2]) {
            return match[2];
        }

        // Try to match PHP method pattern (without visibility modifier)
        match = line.match(phpMethodRegex);
        if (match && match[1]) {
            return match[1];
        }

        // If we find a class declaration or closing brace, stop searching
        if (line.includes('class ') || line.trim() === '}') {
            break;
        }
    }

    return null;
}

function deactivate() {}

module.exports = {
    activate,
    deactivate
};