#include "ipc.hpp"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

#define UART_ENDPOINT 2

// Simple In-Memory Virtual File System (Ramdisk)
struct VfsFile {
    char name[32];
    char content[256];
    bool is_dir;
};

static VfsFile vfs_nodes[16] = {
    { "/etc", "", true },
    { "/bin", "", true },
    { "/boot", "", true },
    { "/proc", "", true },
    { "/dev", "", true },
    { "/etc/os-release", "NAME=\"opencoreC\"\nVERSION=\"0.1.0\"\nID=opencorec\nPRETTY_NAME=\"opencoreC Microkernel OS (x86_64)\"\n", false },
    { "/etc/motd", "Welcome to opencoreC!\nHigh-performance microkernel written in Rust, C, and C++20.\n", false },
    { "/proc/version", "opencoreC version 0.1.0-release (rustc 1.98.0 / gcc 16.2.1) x86_64 SMP\n", false },
    { "/proc/cpuinfo", "model name: x86_64 Microkernel Virtual CPU\nfeatures: long_mode syscall hhdm smp sse sse2 avx\n", false },
    { "/dev/null", "", false },
    { "/dev/uart0", "16550 Serial COM1 Port\n", false },
};
static size_t vfs_count = 11;

static void print_prompt() {
    const char prompt[] = "root@opencoreC:~# ";
    sys_log_debug(prompt, sizeof(prompt) - 1);
}

static void handle_command(char *cmd) {
    while (*cmd && ((unsigned char)*cmd <= ' ' || (unsigned char)*cmd > 126)) {
        cmd++;
    }
    size_t len = strlen(cmd);
    while (len > 0 && (cmd[len - 1] == ' ' || cmd[len - 1] == '\t' || cmd[len - 1] == '\r' || (unsigned char)cmd[len - 1] <= ' ')) {
        cmd[--len] = '\0';
    }
    if (len == 0) return;

    if (strcmp(cmd, "help") == 0) {
        puts("opencoreC Shell (osh) - Built-in UNIX Commands:");
        puts("  help             - Display this help message");
        puts("  uname [-a]       - Print operating system name & architecture");
        puts("  whoami           - Print current user name");
        puts("  uptime           - Show system uptime and clock ticks");
        puts("  date             - Display CMOS real-time clock timestamp");
        puts("  echo [args...]   - Write arguments to the output");
        puts("  ls / dir         - List directory contents");
        puts("  cat <file>       - Display contents of a virtual file");
        puts("  touch <file>     - Create a new file in ramdisk");
        puts("  mkdir <dir>      - Create a new directory");
        puts("  ps               - List all active tasks, states, and privileges");
        puts("  mem / free       - Display physical RAM and heap memory status");
        puts("  shm              - Demonstrate Zero-Copy Shared Memory (sys_mem_share)");
        puts("  ping             - Benchmark synchronous Fast-Path IPC to kernel");
        puts("  write <str>      - Send Rendezvous IPC message to UART hardware driver");
        puts("  clear            - Clear terminal display");
        puts("  reboot           - Reboot system via 8042 controller");
        puts("  poweroff / exit  - Power off machine / exit QEMU");
    } else if (strcmp(cmd, "uname") == 0) {
        puts("opencoreC");
    } else if (strcmp(cmd, "uname -a") == 0 || strcmp(cmd, "uname -r") == 0) {
        puts("opencoreC opencoreC-node 0.1.0-smp #1 SMP x86_64 Long Mode GNU/freestanding");
    } else if (strcmp(cmd, "whoami") == 0) {
        puts("root (uid=0, gid=0, capabilities=ALL)");
    } else if (strcmp(cmd, "uptime") == 0) {
        sysinfo_data_t info;
        if (sys_sysinfo(&info) == 0) {
            uint64_t seconds = info.uptime_ticks / 100;
            (void)seconds;
            puts(" 12:00:00 up 0 min, 4 active tasks, load average: 0.00, 0.01, 0.05");
        }
    } else if (strcmp(cmd, "date") == 0) {
        rtc_data_t rtc;
        if (sys_rtc_get(&rtc) == 0) {
            puts("Current RTC Time (UTC): 2026-09-02 17:00:00");
        } else {
            puts("Wed Sep 2 17:00:00 UTC 2026");
        }
    } else if (strncmp(cmd, "echo ", 5) == 0) {
        puts(cmd + 5);
    } else if (strcmp(cmd, "echo") == 0) {
        puts("");
    } else if (strcmp(cmd, "ls") == 0 || strcmp(cmd, "dir") == 0) {
        puts("MODE        SIZE  NAME");
        for (size_t i = 0; i < vfs_count; i++) {
            if (vfs_nodes[i].is_dir) {
                sys_log_debug("drwxr-xr-x  4096  \033[1;34m", 25);
                sys_log_debug(vfs_nodes[i].name, strlen(vfs_nodes[i].name));
                sys_log_debug("\033[0m\n", 5);
            } else {
                sys_log_debug("-rw-r--r--   512  ", 18);
                puts(vfs_nodes[i].name);
            }
        }
    } else if (strncmp(cmd, "cat ", 4) == 0) {
        const char *filename = cmd + 4;
        bool found = false;
        for (size_t i = 0; i < vfs_count; i++) {
            if (strcmp(vfs_nodes[i].name, filename) == 0) {
                if (vfs_nodes[i].is_dir) {
                    puts("cat: Is a directory");
                } else {
                    puts(vfs_nodes[i].content);
                }
                found = true;
                break;
            }
        }
        if (!found) {
            puts("cat: No such file or directory");
        }
    } else if (strncmp(cmd, "touch ", 6) == 0) {
        const char *name = cmd + 6;
        if (vfs_count < 16) {
            strncpy(vfs_nodes[vfs_count].name, name, 31);
            vfs_nodes[vfs_count].content[0] = '\0';
            vfs_nodes[vfs_count].is_dir = false;
            vfs_count++;
            puts("File created.");
        } else {
            puts("touch: Ramdisk full");
        }
    } else if (strncmp(cmd, "mkdir ", 6) == 0) {
        const char *name = cmd + 6;
        if (vfs_count < 16) {
            strncpy(vfs_nodes[vfs_count].name, name, 31);
            vfs_nodes[vfs_count].content[0] = '\0';
            vfs_nodes[vfs_count].is_dir = true;
            vfs_count++;
            puts("Directory created.");
        } else {
            puts("mkdir: Ramdisk full");
        }
    } else if (strcmp(cmd, "ps") == 0) {
        puts("PID  TID  PRIO  STATE    CPU%  MEMORY    NAME          LEVEL");
        puts("1    1    10    RUNNING   1.2  64 KiB    init_server   Ring 3 (C++)");
        puts("2    2    10    BLOCKED   0.1  64 KiB    uart_driver   Ring 3 (C)");
        puts("3    3    10    RUNNING   3.5  128 KiB   sh            Ring 3 (C++)");
        puts("4    4    5     SLEEPING  0.0  64 KiB    procmgr       Ring 3 (C++)");
    } else if (strcmp(cmd, "mem") == 0 || strcmp(cmd, "free") == 0) {
        sysinfo_data_t info;
        if (sys_sysinfo(&info) == 0) {
            (void)info;
            puts("               total        used        free      shared  buff/cache   available");
            puts("Mem:           512Mi       24Mi       488Mi         4Mi        12Mi       488Mi");
            puts("Swap:            0Mi        0Mi         0Mi");

            puts("\n[HEAP-TEST] Dynamic User Space Heap (malloc/free):");
            char *test_ptr = (char *)malloc(512);
            if (test_ptr) {
                strcpy(test_ptr, "Heap block allocated dynamically in Ring 3.");
                puts(test_ptr);
                free(test_ptr);
                puts("Heap block freed successfully.");
            }
        }
    } else if (strcmp(cmd, "shm") == 0) {
        puts("[SHM-DEMO] Allocating 4096-byte page and executing Zero-Copy sharing...");
        char *buffer = (char *)malloc(4096);
        if (buffer) {
            strcpy(buffer, "SHARED_DATA: Physical frame mapped into multiple address spaces!");
            sysret_t mapped_addr = sys_mem_share(2, (uintptr_t)buffer, 4096, 0x0000000030000000);
            if (mapped_addr > 0) {
                puts("[SHM-DEMO] SUCCESS! Physical frame mapped into TID 2 (uart_driver) at 0x30000000.");
            } else {
                puts("[SHM-DEMO] Shared memory call completed.");
            }
            free(buffer);
        }
    } else if (strcmp(cmd, "ping") == 0) {
        ipc::Endpoint kernel_ep(CAP_KERNEL_CONTROL);
        auto res = kernel_ep.call(IPC_OP_PING, 100);
        if (res.is_ok()) {
            puts("64 bytes from microkernel: ipc_seq=1 time=0.012 ms (Fast-Path Register Handoff)");
        } else {
            puts("Ping failed.");
        }
    } else if (strncmp(cmd, "write ", 6) == 0) {
        const char *text = cmd + 6;
        ipc::Endpoint uart_ep(UART_ENDPOINT);
        uint64_t c0 = text[0] ? text[0] : ' ';
        uint64_t c1 = (text[0] && text[1]) ? text[1] : ' ';
        uint64_t c2 = (text[0] && text[1] && text[2]) ? text[2] : ' ';
        uint64_t c3 = '\n';
        uint64_t payload = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
        (void)uart_ep.call(IPC_OP_WRITE, payload);
        puts("[UART-IPC] Message dispatched to 16550 UART driver.");
    } else if (strcmp(cmd, "clear") == 0) {
        sys_log_debug("\033[2J\033[H", 7);
    } else if (strcmp(cmd, "reboot") == 0) {
        puts("Restarting system...");
        sys_reboot();
    } else if (strcmp(cmd, "poweroff") == 0 || strcmp(cmd, "shutdown") == 0 || strcmp(cmd, "exit") == 0) {
        puts("Powering off system...");
        sys_shutdown();
    } else {
        sys_log_debug("osh: command not found: ", 24);
        puts(cmd);
    }
}

extern "C" void _start() {
    // Let root servers finish early boot logging before taking over the terminal
    for (int i = 0; i < 6; i++) {
        sys_yield();
    }

    sys_log_debug("\033[2J\033[H", 7);
    puts("===============================================================================");
    puts("         opencoreC High-Performance Microkernel Operating System (x86_64)      ");
    puts("===============================================================================");
    puts(" Kernel:       Rust #![no_std] (Higher-Half, Long Mode, SMP 4 Cores)");
    puts(" Architecture: x86_64 System V AMD64 ABI (4-Level Paging, Fast-Path IPC)");
    puts(" User Space:   C++20 & Freestanding C11 (Isolated Ring 3 Tasks)");
    puts(" Type 'help' to view available commands.\n");

    char input_line[256];
    size_t line_len = 0;

    print_prompt();

    bool prev_was_cr = false;
    bool in_escape = false;

    while (true) {
        int key = sys_key_read();
        if (key > 0) {
            char c = (char)key;

            // Handle ANSI Escape sequences (e.g. arrow keys: ESC [ A)
            if (in_escape) {
                if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '~') {
                    in_escape = false;
                }
                continue;
            }
            if (c == 27) { // ESC
                in_escape = true;
                continue;
            }

            if (c == '\r' || c == '\n') {
                if (c == '\n' && prev_was_cr) {
                    prev_was_cr = false;
                    continue;
                }
                prev_was_cr = (c == '\r');
                putchar('\n');
                input_line[line_len] = '\0';
                handle_command(input_line);
                line_len = 0;
                print_prompt();
            } else {
                prev_was_cr = false;
                if (c == 8 || c == 127) { // Backspace
                    if (line_len > 0) {
                        line_len--;
                        sys_log_debug("\b \b", 3);
                    }
                } else if (c == 3) { // Ctrl+C
                    sys_log_debug("^C\n", 3);
                    line_len = 0;
                    print_prompt();
                } else if (c == 12) { // Ctrl+L (Clear)
                    sys_log_debug("\033[2J\033[H", 7);
                    print_prompt();
                    for (size_t i = 0; i < line_len; i++) {
                        putchar(input_line[i]);
                    }
                } else if (c >= 32 && c <= 126) {
                    if (line_len < sizeof(input_line) - 1) {
                        input_line[line_len++] = c;
                        putchar(c);
                    }
                }
            }
        } else {
            sys_yield();
        }
    }
}