// BUBO Kernel v0.2 — interactive shell
// The kernel talks back with intent now.

#include "uart.h"

// Pyre GPU (bare metal)
void pyre_bubo_init(void);
int pyre_bubo_render(float angle_rad);
void pyre_bubo_dump_ppm(void);
void pyre_bubo_info(void);

#define SHELL_MAX_LINE 128
#define PROMPT "bubo> "

// Linker symbols
extern unsigned long _bss_start;
extern unsigned long _bss_end;
extern unsigned long _stack_bottom;
extern unsigned long _stack_top;

// ---- tiny libc ----
static int k_strcmp(const char *a, const char *b) {
    while (*a && *a == *b) { a++; b++; }
    return (unsigned char)*a - (unsigned char)*b;
}

// print unsigned long in base 10
static void k_print_ulong(unsigned long v) {
    char buf[24];
    int i = 0;
    if (v == 0) { uart_putc('0'); return; }
    while (v > 0 && i < 23) { buf[i++] = '0' + (v % 10); v /= 10; }
    while (i > 0) uart_putc(buf[--i]);
}

// ---- generic timer (EL1-safe) ----
static unsigned long timer_freq(void) {
    unsigned long f;
    __asm__ volatile("mrs %0, cntfrq_el0" : "=r"(f));
    return f;
}

static unsigned long timer_count(void) {
    unsigned long c;
    __asm__ volatile("mrs %0, cntvct_el0" : "=r"(c));
    return c;
}

// ---- commands ----
static void cmd_help(void) {
    uart_puts("commands:\n");
    uart_puts("  help   - this list\n");
    uart_puts("  about  - kernel info\n");
    uart_puts("  uptime - ticks since boot\n");
    uart_puts("  mem    - memory layout\n");
    uart_puts("  clear  - clear screen\n");
    uart_puts("  echo   - print text\n");
    uart_puts("  gpu    - Pyre GPU: info | cube [angle] | ppm\n");
}

static void cmd_about(void) {
    uart_puts("BUBO Kernel v0.2\n");
    uart_puts("ARM64 bare metal. Vibe-coded on a phone.\n");
    uart_puts("(c) 2026 N8toriousAi\n");
    uart_puts("boot: EL2 -> EL1, 16KB stack, PL011 UART\n");
}

static void cmd_uptime(void) {
    unsigned long freq = timer_freq();
    unsigned long now  = timer_count();
    unsigned long secs = freq ? now / freq : 0;
    uart_puts("uptime: ");
    k_print_ulong(secs);
    uart_puts("s (timer ");
    k_print_ulong(now);
    uart_puts(" ticks @ ");
    k_print_ulong(freq);
    uart_puts(" Hz)\n");
}

static void cmd_mem(void) {
    unsigned long text_sz  = (unsigned long)&_bss_start - 0x40080000UL;
    unsigned long bss_sz   = (unsigned long)&_bss_end - (unsigned long)&_bss_start;
    unsigned long stack_sz = (unsigned long)&_stack_top - (unsigned long)&_stack_bottom;
    uart_puts("memory:\n");
    uart_puts("  load base : 0x40080000\n");
    uart_puts("  text+data : "); k_print_ulong(text_sz);  uart_puts(" bytes\n");
    uart_puts("  bss       : "); k_print_ulong(bss_sz);   uart_puts(" bytes\n");
    uart_puts("  stack     : "); k_print_ulong(stack_sz); uart_puts(" bytes\n");
    uart_puts("  total     : "); k_print_ulong(text_sz + bss_sz + stack_sz);
    uart_puts(" bytes\n");
}

static void cmd_clear(void) {
    uart_puts("\033[2J\033[H");
}

static void cmd_echo(const char *args) {
    if (args && *args) uart_puts(args);
    uart_putc('\n');
}

static void cmd_gpu(const char *args) {
    if (!args || *args == '\0') {
        uart_puts("gpu: info | cube [angle] | ppm\n");
        return;
    }
    // split subcommand
    char sub[16]; int i = 0;
    while (args[i] && args[i] != ' ' && i < 15) { sub[i] = args[i]; i++; }
    sub[i] = '\0';

    if (k_strcmp(sub, "info") == 0) {
        pyre_bubo_info();
    } else if (k_strcmp(sub, "cube") == 0) {
        // optional angle in degrees
        float angle = 0.7854f; // 45 deg default
        const char *p = args + i;
        while (*p == ' ') p++;
        if (*p) {
            int deg = 0;
            while (*p >= '0' && *p <= '9') { deg = deg * 10 + (*p - '0'); p++; }
            angle = (float)deg * 0.0174533f;
        }
        int tris = pyre_bubo_render(angle);
        uart_puts("gpu: rendered ");
        k_print_ulong((unsigned long)tris);
        uart_puts("/12 tris\n");
    } else if (k_strcmp(sub, "ppm") == 0) {
        uart_puts("gpu: dumping PPM frame...\n");
        pyre_bubo_dump_ppm();
    } else {
        uart_puts("gpu: unknown subcommand (info|cube|ppm)\n");
    }
}

// ---- shell ----
static void dispatch(char *line) {
    // skip leading spaces
    while (*line == ' ') line++;
    if (*line == '\0') return;

    // split command from args
    char *args = line;
    while (*args && *args != ' ') args++;
    if (*args == ' ') { *args = '\0'; args++; }
    while (*args == ' ') args++;

    if (k_strcmp(line, "help") == 0)       cmd_help();
    else if (k_strcmp(line, "about") == 0)  cmd_about();
    else if (k_strcmp(line, "uptime") == 0) cmd_uptime();
    else if (k_strcmp(line, "mem") == 0)    cmd_mem();
    else if (k_strcmp(line, "clear") == 0)  cmd_clear();
    else if (k_strcmp(line, "echo") == 0)   cmd_echo(args);
    else if (k_strcmp(line, "gpu") == 0)    cmd_gpu(args);
    else {
        uart_puts("unknown: ");
        uart_puts(line);
        uart_puts(" (try 'help')\n");
    }
}

void kernel_main(void) {
    char line[SHELL_MAX_LINE];
    int len = 0;

    uart_init();
    uart_puts("\n");
    uart_puts("  BUBO Kernel v0.2\n");
    uart_puts("  ARM64 bare metal. Vibe-coded on a phone.\n");
    uart_puts("  (c) 2026 N8toriousAi\n");
    uart_puts("\n");

    // Auto-demo disabled for interactive use.
    // uart_puts("[auto] rendering Pyre cube...\n");
    // int atris = pyre_bubo_render(0.7854f);
    // uart_puts("[auto] rendered ");
    // k_print_ulong((unsigned long)atris);
    // uart_puts(" tris, dumping PPM...\n");
    // pyre_bubo_dump_ppm();
    // uart_puts("[auto] done\n");

    uart_puts(PROMPT);

    for (;;) {
        char c = uart_getc();

        if (c == '\r' || c == '\n') {
            // execute
            uart_puts("\n");
            line[len] = '\0';
            dispatch(line);
            len = 0;
            uart_puts(PROMPT);
        } else if (c == 0x7f || c == 0x08) {
            // backspace / DEL
            if (len > 0) {
                len--;
                uart_puts("\b \b");
            }
        } else if (c >= 0x20 && c < 0x7f) {
            // printable
            if (len < SHELL_MAX_LINE - 1) {
                line[len++] = c;
                uart_putc(c);
            }
        }
        // ignore everything else (escape sequences, etc.)
    }
}
