script.js

let fileSystem = {
    '/': {
        type: 'directory',
        content: {
            'home': {
                type: 'directory',
                content: {
                    'guest': {
                        type: 'directory',
                        content: {
                            'welcome.txt': {
                                type: 'file',
                                content: 'Welcome to Unix Terminal Simulator!\nCreated by 7OOT\n\nType "help" to see available commands.'
                            },
                            'documents': {
                                type: 'directory',
                                content: {}
                            }
                        }
                    }
                }
            },
            'etc': {
                type: 'directory',
                content: {
                    'config.txt': {
                        type: 'file',
                        content: 'System configuration file'
                    }
                }
            },
            'tmp': {
                type: 'directory',
                content: {}
            }
        }
    }
};

let currentPath = '/home/guest';
let previousPath = '/home/guest';
let commandHistory = [];
let historyIndex = -1;

const output = document.getElementById('output');
const commandInput = document.getElementById('commandInput');
const prompt = document.getElementById('prompt');
const terminal = document.getElementById('terminal');

window.onload = function () {
    printBanner();
    updatePrompt();
    commandInput.focus();
};

terminal.addEventListener('click', () => {
    commandInput.focus();
});

commandInput.addEventListener('keydown', function (e) {
    if (e.key === 'Enter') {
        const command = commandInput.value.trim();
        if (command) {
            addToHistory(command);
            executeCommand(command);
        } else {
            printPrompt();
        }
        commandInput.value = '';
        historyIndex = commandHistory.length;
    } else if (e.key === 'ArrowUp') {
        e.preventDefault();
        if (historyIndex > 0) {
            historyIndex--;
            commandInput.value = commandHistory[historyIndex];
        }
    } else if (e.key === 'ArrowDown') {
        e.preventDefault();
        if (historyIndex < commandHistory.length - 1) {
            historyIndex++;
            commandInput.value = commandHistory[historyIndex];
        } else {
            historyIndex = commandHistory.length;
            commandInput.value = '';
        }
    } else if (e.key === 'Tab') {
        e.preventDefault();
        autocomplete();
    }
});

function printBanner() {
    const banner = `
        _       _ __ _          _ _ 
  /\\/\\ (_)_ __ (_) _\\ |__   ___| | |
 /    \\| | '_ \\| \\ \\| '_ \\ / _ \\ | |
/ /\\/\\ \\ | | | | |\\ \\ | | |  __/ | |
\\/    \\/_|_| |_|_\\__/_| |_|\\___|_|_|
                                                                      
                by 7OOT

    Type 'help' for available commands.
    `;
    printOutput(banner, 'banner');
}

function printOutput(text, className = '') {
    const line = document.createElement('div');
    line.className = 'output-line ' + className;
    line.textContent = text;
    output.appendChild(line);
    scrollToBottom();
}

function printHTML(html, className = '') {
    const line = document.createElement('div');
    line.className = 'output-line ' + className;
    line.innerHTML = html;
    output.appendChild(line);
    scrollToBottom();
}

function printPrompt() {
    const line = document.createElement('div');
    line.className = 'output-line';
    line.innerHTML = `<span class="prompt">${prompt.textContent}</span>`;
    output.appendChild(line);
    scrollToBottom();
}

function scrollToBottom() {
    terminal.scrollTop = terminal.scrollHeight;
}

function updatePrompt() {
    const displayPath = currentPath.replace('/home/guest', '~');
    prompt.textContent = `MiniShell:${displayPath}$`;
}

function addToHistory(command) {
    commandHistory.push(command);
    if (commandHistory.length > 100) {
        commandHistory.shift();
    }
}

function executeCommand(input) {
    printHTML(`<span class="prompt">${prompt.textContent}</span> ${escapeHtml(input)}`);

    const parts = input.trim().split(/\s+/);
    const command = parts[0].toLowerCase();
    const args = parts.slice(1);

    switch (command) {
        case 'help':
            showHelp();
            break;
        case 'clear':
            output.innerHTML = '';
            break;
        case 'ls':
            listDirectory(args[0]);
            break;
        case 'pwd':
            printWorkingDirectory();
            break;
        case 'cd':
            changeDirectory(args[0]);
            break;
        case 'mkdir':
            makeDirectory(args[0]);
            break;
        case 'rmdir':
            removeDirectory(args[0]);
            break;
        case 'touch':
            createFile(args[0]);
            break;
        case 'rm':
            removeFile(args[0]);
            break;
        case 'cat':
            displayFile(args[0]);
            break;
        case 'echo':
            echoText(args);
            break;
        case 'date':
            showDate();
            break;
        case 'history':
            showHistory();
            break;
        case 'whoami':
            printOutput('guest', 'info');
            break;
        case 'uname':
            printOutput('Unix Terminal Simulator v1.0', 'info');
            break;
        case 'env':
            showEnvironment();
            break;
        case '':
            break;
        default:
            printOutput(`Command not found: ${command}. Type 'help' for available commands.`, 'error');
    }
}

function showHelp() {
    const helpText = `
<div class="help-section">
    <div class="help-title">=== Available Commands ===</div>
    <div class="help-command">ls [path]       - List directory contents</div>
    <div class="help-command">pwd             - Print working directory</div>
    <div class="help-command">cd &lt;dir&gt;        - Change directory (cd ~ for home, cd - for previous, cd .. for parent)</div>
    <div class="help-command">mkdir &lt;dir&gt;     - Create a new directory</div>
    <div class="help-command">rmdir &lt;dir&gt;     - Remove an empty directory</div>
    <div class="help-command">touch &lt;file&gt;    - Create a new file</div>
    <div class="help-command">rm &lt;file&gt;       - Delete a file</div>
    <div class="help-command">cat &lt;file&gt;      - Display file contents</div>
    <div class="help-command">echo &lt;text&gt;     - Display a line of text</div>
    <div class="help-command">date            - Display current date and time</div>
    <div class="help-command">history         - Show command history</div>
    <div class="help-command">whoami          - Display current user</div>
    <div class="help-command">uname           - Display system information</div>
    <div class="help-command">env             - Show environment information</div>
    <div class="help-command">clear           - Clear the screen</div>
    <div class="help-command">help            - Show this help message</div>
</div>`;
    printHTML(helpText);
}

function listDirectory(path) {
    const targetPath = resolvePath(path || currentPath);
    const dir = getNode(targetPath);

    if (!dir) {
        printOutput(`ls: cannot access '${path}': No such file or directory`, 'error');
        return;
    }

    if (dir.type !== 'directory') {
        printOutput(`ls: ${path}: Not a directory`, 'error');
        return;
    }

    printOutput(`Directory: ${targetPath}`, 'info');
    printOutput('----------------------------------------', 'info');

    const entries = Object.keys(dir.content);

    if (entries.length === 0) {
        printOutput('(empty)', 'warning');
    } else {
        let dirCount = 0;
        let fileCount = 0;

        entries.sort().forEach(name => {
            const item = dir.content[name];
            if (item.type === 'directory') {
                printOutput(`📁 ${name}/`, 'directory');
                dirCount++;
            } else {
                const size = item.content ? item.content.length : 0;
                printOutput(`📄 ${name} (${size} bytes)`, 'file');
                fileCount++;
            }
        });

        printOutput(`\nTotal: ${dirCount} directories, ${fileCount} files`, 'warning');
    }
}

function printWorkingDirectory() {
    printOutput(currentPath, 'info');
}

function changeDirectory(path) {
    if (!path) {
        currentPath = '/home/guest';
        updatePrompt();
        return;
    }

    if (path === '-') {
        const temp = currentPath;
        currentPath = previousPath;
        previousPath = temp;
        printOutput(`Changed to: ${currentPath}`, 'success');
        updatePrompt();
        return;
    }

    if (path === '~') {
        currentPath = '/home/guest';
        updatePrompt();
        return;
    }

    const targetPath = resolvePath(path);
    const dir = getNode(targetPath);

    if (!dir) {
        printOutput(`cd: ${path}: No such file or directory`, 'error');
        return;
    }

    if (dir.type !== 'directory') {
        printOutput(`cd: ${path}: Not a directory`, 'error');
        return;
    }

    previousPath = currentPath;
    currentPath = targetPath;
    printOutput(`Changed to: ${currentPath}`, 'success');
    updatePrompt();
}

function makeDirectory(name) {
    if (!name) {
        printOutput('mkdir: missing operand', 'error');
        return;
    }

    const targetPath = resolvePath(name);
    const parentPath = getParentPath(targetPath);
    const dirName = getBaseName(targetPath);
    const parent = getNode(parentPath);

    if (!parent) {
        printOutput(`mkdir: cannot create directory '${name}': No such file or directory`, 'error');
        return;
    }

    if (parent.type !== 'directory') {
        printOutput(`mkdir: cannot create directory '${name}': Not a directory`, 'error');
        return;
    }

    if (parent.content[dirName]) {
        printOutput(`mkdir: cannot create directory '${name}': File exists`, 'error');
        return;
    }

    parent.content[dirName] = {
        type: 'directory',
        content: {}
    };

    printOutput(`Directory created: ${name}`, 'success');
}

function removeDirectory(name) {
    if (!name) {
        printOutput('rmdir: missing operand', 'error');
        return;
    }

    const targetPath = resolvePath(name);
    const parentPath = getParentPath(targetPath);
    const dirName = getBaseName(targetPath);
    const parent = getNode(parentPath);

    if (!parent) {
        printOutput(`rmdir: failed to remove '${name}': No such file or directory`, 'error');
        return;
    }

    const dir = parent.content[dirName];

    if (!dir) {
        printOutput(`rmdir: failed to remove '${name}': No such file or directory`, 'error');
        return;
    }

    if (dir.type !== 'directory') {
        printOutput(`rmdir: failed to remove '${name}': Not a directory`, 'error');
        return;
    }

    if (Object.keys(dir.content).length > 0) {
        printOutput(`rmdir: failed to remove '${name}': Directory not empty`, 'error');
        return;
    }

    delete parent.content[dirName];
    printOutput(`Directory removed: ${name}`, 'success');
}

function createFile(name) {
    if (!name) {
        printOutput('touch: missing file operand', 'error');
        return;
    }

    const targetPath = resolvePath(name);
    const parentPath = getParentPath(targetPath);
    const fileName = getBaseName(targetPath);
    const parent = getNode(parentPath);

    if (!parent) {
        printOutput(`touch: cannot touch '${name}': No such file or directory`, 'error');
        return;
    }

    if (parent.type !== 'directory') {
        printOutput(`touch: cannot touch '${name}': Not a directory`, 'error');
        return;
    }

    if (!parent.content[fileName]) {
        parent.content[fileName] = {
            type: 'file',
            content: ''
        };
        printOutput(`File created: ${name}`, 'success');
    } else {
        printOutput(`File already exists: ${name}`, 'warning');
    }
}

function removeFile(name) {
    if (!name) {
        printOutput('rm: missing operand', 'error');
        return;
    }

    const targetPath = resolvePath(name);
    const parentPath = getParentPath(targetPath);
    const fileName = getBaseName(targetPath);
    const parent = getNode(parentPath);

    if (!parent) {
        printOutput(`rm: cannot remove '${name}': No such file or directory`, 'error');
        return;
    }

    const file = parent.content[fileName];

    if (!file) {
        printOutput(`rm: cannot remove '${name}': No such file or directory`, 'error');
        return;
    }

    if (file.type === 'directory') {
        printOutput(`rm: cannot remove '${name}': Is a directory`, 'error');
        return;
    }

    delete parent.content[fileName];
    printOutput(`File deleted: ${name}`, 'success');
}

function displayFile(name) {
    if (!name) {
        printOutput('cat: missing file operand', 'error');
        return;
    }

    const targetPath = resolvePath(name);
    const file = getNode(targetPath);

    if (!file) {
        printOutput(`cat: ${name}: No such file or directory`, 'error');
        return;
    }

    if (file.type === 'directory') {
        printOutput(`cat: ${name}: Is a directory`, 'error');
        return;
    }

    if (!file.content || file.content.length === 0) {
        printOutput('(File is empty)', 'warning');
    } else {
        printOutput(`\n--- ${name} ---`, 'info');
        const lines = file.content.split('\n');
        lines.forEach((line, index) => {
            printHTML(`<span class="line-number">${(index + 1).toString().padStart(3, ' ')}</span>${escapeHtml(line)}`);
        });
        printOutput('--- End of file ---\n', 'info');
    }
}

function echoText(args) {
    const text = args.join(' ');
    printOutput(text);
}

function showDate() {
    const now = new Date();
    printOutput(`Current date/time: ${now.toString()}`, 'info');
}

function showHistory() {
    if (commandHistory.length === 0) {
        printOutput('No command history yet.', 'warning');
        return;
    }

    printOutput('\n=== Command History ===', 'info');
    commandHistory.forEach((cmd, index) => {
        printHTML(`<span class="command-history">${(index + 1).toString().padStart(4, ' ')}: ${escapeHtml(cmd)}</span>`);
    });
    printOutput('');
}

function showEnvironment() {
    printOutput('\n=== Environment Information ===', 'info');
    printOutput('USER: guest', 'warning');
    printOutput('HOME: /home/guest', 'warning');
    printOutput('SHELL: /bin/bash', 'warning');
    printOutput('PWD: ' + currentPath, 'warning');
    printOutput('TERM: xterm-256color', 'warning');
    printOutput('');
}

function autocomplete() {
    const input = commandInput.value;
    const parts = input.split(' ');
    const lastPart = parts[parts.length - 1];

    if (parts.length === 1) {

        const commands = ['help', 'clear', 'ls', 'pwd', 'cd', 'mkdir', 'rmdir', 'touch', 'rm', 'cat', 'echo', 'date', 'history', 'whoami', 'uname', 'env'];
        const matches = commands.filter(cmd => cmd.startsWith(lastPart));

        if (matches.length === 1) {
            commandInput.value = matches[0] + ' ';
        } else if (matches.length > 1) {
            printOutput('\n' + matches.join('  '), 'info');
            printPrompt();
        }
    } else {

        const dir = getNode(currentPath);
        if (dir && dir.type === 'directory') {
            const entries = Object.keys(dir.content);
            const matches = entries.filter(name => name.startsWith(lastPart));

            if (matches.length === 1) {
                parts[parts.length - 1] = matches[0];
                commandInput.value = parts.join(' ') + ' ';
            } else if (matches.length > 1) {
                printOutput('\n' + matches.join('  '), 'info');
                printPrompt();
            }
        }
    }
}

function resolvePath(path) {
    if (!path) return currentPath;

    if (path.startsWith('/')) {
        return normalizePath(path);
    }

    if (path === '~') {
        return '/home/guest';
    }

    return normalizePath(currentPath + '/' + path);
}

function normalizePath(path) {
    const parts = path.split('/').filter(p => p && p !== '.');
    const result = [];

    for (const part of parts) {
        if (part === '..') {
            result.pop();
        } else {
            result.push(part);
        }
    }

    return '/' + result.join('/');
}

function getNode(path) {
    if (path === '/') return fileSystem['/'];

    const parts = path.split('/').filter(p => p);
    let current = fileSystem['/'];

    for (const part of parts) {
        if (!current.content || !current.content[part]) {
            return null;
        }
        current = current.content[part];
    }

    return current;
}

function getParentPath(path) {
    const parts = path.split('/').filter(p => p);
    parts.pop();
    return '/' + parts.join('/');
}

function getBaseName(path) {
    const parts = path.split('/').filter(p => p);
    return parts[parts.length - 1];
}

function escapeHtml(text) {
    const div = document.createElement('div');
    div.textContent = text;
    return div.innerHTML;
}