/* ============================================================================
 * Pactor64 Kernel Main — x86-64
 * Core kernel: I/O, printf, CPU detection, init sequence
 * ============================================================================ */

#include "types.h"

/* === GCC builtins for va_list (no libc) === */
typedef __builtin_va_list va_list;
#define va_start(ap, last) __builtin_va_start(ap, last)
#define va_end(ap)         __builtin_va_end(ap)
#define va_arg(ap, type)   __builtin_va_arg(ap, type)

/* === Port I/O === */
void outb(uint16_t port, uint8_t val) {
    __asm__ volatile ("outb %0, %1" : : "a"(val), "Nd"(port));
}
uint8_t inb(uint16_t port) {
    uint8_t val;
    __asm__ volatile ("inb %1, %0" : "=a"(val) : "Nd"(port));
    return val;
}

/* === String utilities === */
size_t kstrlen(const char *s) { size_t n=0; while(s[n]) n++; return n; }
int kstrcmp(const char *a, const char *b) { while(*a&&*a==*b){a++;b++;} return (uint8_t)*a-(uint8_t)*b; }
int kstrncmp(const char *a, const char *b, size_t n) { for(size_t i=0;i<n;i++){if(a[i]!=b[i])return(uint8_t)a[i]-(uint8_t)b[i];if(!a[i])return 0;}return 0; }
void *kmemset(void *d, int c, size_t n) { uint8_t *p=d; while(n--) *p++=(uint8_t)c; return d; }
void *kmemcpy(void *d, const void *s, size_t n) { uint8_t *dp=d; const uint8_t *sp=s; while(n--) *dp++=*sp++; return d; }

/* === Serial I/O (COM1) === */
#define COM1 0x3F8

void serial_init(void) {
    outb(COM1+1, 0x00);
    outb(COM1+3, 0x80);
    outb(COM1+0, 0x03);
    outb(COM1+1, 0x00);
    outb(COM1+3, 0x03);
    outb(COM1+2, 0xC7);
    outb(COM1+4, 0x0B);
}

void serial_putc(char c) {
    while (!(inb(COM1+5) & 0x20)) {}
    outb(COM1, c);
}

void serial_puts(const char *s) { while(*s) serial_putc(*s++); }

int serial_poll(void) { return inb(COM1+5) & 0x01; }
int serial_getc(void) { return serial_poll() ? inb(COM1) : -1; }

/* === Number printing === */
void kprint_hex(uint64_t val) {
    serial_puts("0x");
    for (int i = 60; i >= 0; i -= 4) {
        int n = (val >> i) & 0xF;
        serial_putc(n < 10 ? '0'+n : 'A'+n-10);
    }
}

void kprint_dec(uint64_t val) {
    if (!val) { serial_putc('0'); return; }
    char buf[21]; int i = 0;
    while (val) { buf[i++] = '0'+(val%10); val /= 10; }
    while (i > 0) serial_putc(buf[--i]);
}

/* === kprintf === */
void kprintf(const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    for (int i = 0; fmt[i]; i++) {
        if (fmt[i] == '%' && fmt[i+1]) {
            i++;
            switch (fmt[i]) {
                case 'd': kprint_dec(va_arg(ap, uint64_t)); break;
                case 'x': kprint_hex(va_arg(ap, uint64_t)); break;
                case 's': { const char *s = va_arg(ap, const char*);
                            serial_puts(s ? s : "(null)"); break; }
                case 'c': serial_putc((char)va_arg(ap, int)); break;
                case '%': serial_putc('%'); break;
                default:  serial_putc('%'); serial_putc(fmt[i]); break;
            }
        } else serial_putc(fmt[i]);
    }
    va_end(ap);
}

/* === Assembly functions === */
extern void idt_init(void);
extern void pic_remap(int offset1, int offset2);

/* === Module init functions === */
extern void timer_init(uint32_t hz);
extern void keyboard_init(void);
extern void pmm_init(uint64_t mb2_info);
extern void heap_init(void);
extern void vga_init(void);
extern void vga_clear(void);
extern void vga_puts(const char *s);
extern void ata_init(void);
extern void syscall_init(void);
extern void shell_init(void);

extern void shell_run(void);

extern uint64_t kernel_end;

/* === Timer tick counter (from isr.asm) === */
extern volatile uint64_t timer_ticks;

/* === CPU Detection === */
static void detect_cpu(void) {
    uint32_t eax, ebx, ecx, edx;
    char vendor[13] = {0};
    __asm__ volatile ("cpuid":"=a"(eax),"=b"(ebx),"=c"(ecx),"=d"(edx):"a"(0));
    *(uint32_t*)&vendor[0]=ebx; *(uint32_t*)&vendor[4]=edx; *(uint32_t*)&vendor[8]=ecx;
    kprintf("  CPU Vendor:     %s\n", vendor);
    __asm__ volatile ("cpuid":"=a"(eax),"=d"(edx):"a"(1));
    kprintf("  Family/Model:   %d/%d Stepping %d\n", (eax>>8)&0xF, (eax>>4)&0xF, eax&0xF);
    kprintf("  Features:       ");
    if(edx&(1<<4))  kprintf("TSC ");
    if(edx&(1<<8))  kprintf("CX8 ");
    if(edx&(1<<23)) kprintf("MMX ");
    if(edx&(1<<25)) kprintf("SSE ");
    if(edx&(1<<26)) kprintf("SSE2 ");
    __asm__ volatile ("cpuid":"=a"(eax),"=d"(edx):"a"(0x80000001));
    if(edx&(1<<29)) kprintf("LM ");
    kprintf("\n");
}

static void dump_registers(void) {
    uint64_t rsp, cr0, cr3, cr4;
    __asm__ volatile ("mov %%rsp,%0":"=r"(rsp));
    __asm__ volatile ("mov %%cr0,%0":"=r"(cr0));
    __asm__ volatile ("mov %%cr3,%0":"=r"(cr3));
    __asm__ volatile ("mov %%cr4,%0":"=r"(cr4));
    kprintf("  RSP:            %x\n", rsp);
    kprintf("  CR0:            %x (PE=%d PG=%d)\n", cr0, cr0&1, (cr0>>31)&1);
    kprintf("  CR3 (PML4):     %x\n", cr3);
    kprintf("  CR4:            %x (PAE=%d)\n", cr4, (cr4>>5)&1);
}

/* === Exception Handler === */
void exception_handler(uint64_t int_num, uint64_t err_code, uint64_t rip) {
    kprintf("\n*** EXCEPTION %d at RIP %x err=%x ***\n", int_num, rip, err_code);
    for (;;) __asm__ volatile ("cli; hlt");
}

/* === Kernel Main === */
void kernel_main_64(uint64_t mb2_info, uint64_t mb2_magic) {
    serial_init();

    kprintf("\n========================================\n");
    kprintf("  Pactor64 — x86-64 Kernel\n");
    kprintf("  Built from NT source code analysis\n");
    kprintf("========================================\n\n");

    if (mb2_magic == 0x36D76289) kprintf("  [OK] Multiboot2 verified\n");
    else kprintf("  [WARN] Multiboot magic: %x\n", mb2_magic);

    detect_cpu();
    dump_registers();

    /* PIC + IDT */
    pic_remap(0x20, 0x28);
    kprintf("  [OK] PIC remapped (IRQs 0x20-0x2F)\n");
    idt_init();
    kprintf("  [OK] IDT initialized (256 vectors, 64-bit)\n");

    /* Enable interrupts */
    __asm__ volatile ("sti");
    kprintf("  [OK] Interrupts enabled\n");

    /* Timer */
    timer_init(100);
    kprintf("  [OK] PIT timer at 100 Hz\n");

    /* Keyboard */
    keyboard_init();
    kprintf("  [OK] PS/2 keyboard initialized\n");

    /* Physical memory */
    pmm_init(mb2_info);

    /* Heap */
    heap_init();
    syscall_init();
    kprintf("  [OK] SYSCALL interface (STAR/LSTAR MSRs)\n");

    /* VGA */
    vga_init();
    vga_clear();
    vga_puts("Pactor64 VGA active.\n");
    kprintf("  [OK] VGA text mode (80x25)\n");

    /* ATA */
    ata_init();

    kprintf("\n  Kernel at 0x100000, end at %x\n", (uint64_t)&kernel_end);
    kprintf("  PML4 at ");
    uint64_t cr3; __asm__ volatile ("mov %%cr3,%0":"=r"(cr3));
    kprint_hex(cr3);
    kprintf("\n\n");

    /* Shell */
    shell_init();

    shell_run();

    kprintf("\n  System halted.\n");
    for (;;) __asm__ volatile ("cli; hlt");
}