/* start.c - Minimal libc for Pactor64 userspace
 *
 * Provides _start entry point, syscall wrappers, string functions,
 * printf, and bump allocator.
 */
#include "libc.h"

/* Syscall numbers (Linux x86-64 compatible) */
#define SYS_READ   0
#define SYS_WRITE  1
#define SYS_BRK    12
#define SYS_EXIT   60

/* Inline syscall instruction */
static inline long __syscall1(long num, long a1) {
    long ret;
    __asm__ volatile (
        "syscall"
        : "=a"(ret)
        : "a"(num), "D"(a1)
        : "rcx", "r11", "memory"
    );
    return ret;
}

static inline long __syscall3(long num, long a1, long a2, long a3) {
    long ret;
    __asm__ volatile (
        "syscall"
        : "=a"(ret)
        : "a"(num), "D"(a1), "S"(a2), "d"(a3)
        : "rcx", "r11", "memory"
    );
    return ret;
}

/* === System call wrappers === */

long write(int fd, const void *buf, unsigned long count) {
    return __syscall3(SYS_WRITE, fd, (long)buf, (long)count);
}

long read(int fd, void *buf, unsigned long count) {
    return __syscall3(SYS_READ, fd, (long)buf, (long)count);
}

void exit(int status) {
    __syscall1(SYS_EXIT, status);
    __builtin_unreachable();
}

long brk(void *addr) {
    return __syscall1(SYS_BRK, (long)addr);
}

/* === String functions === */

unsigned long strlen(const char *s) {
    unsigned long len = 0;
    while (s[len]) len++;
    return len;
}

int strcmp(const char *s1, const char *s2) {
    while (*s1 && *s1 == *s2) { s1++; s2++; }
    return (unsigned char)*s1 - (unsigned char)*s2;
}

int strncmp(const char *s1, const char *s2, unsigned long n) {
    while (n && *s1 && *s1 == *s2) { s1++; s2++; n--; }
    return n ? (unsigned char)*s1 - (unsigned char)*s2 : 0;
}

char *strcpy(char *dst, const char *src) {
    char *ret = dst;
    while ((*dst++ = *src++));
    return ret;
}

char *strncpy(char *dst, const char *src, unsigned long n) {
    char *ret = dst;
    while (n && (*dst++ = *src++)) n--;
    while (n--) *dst++ = '\0';
    return ret;
}

void *memset(void *s, int c, unsigned long n) {
    unsigned char *p = (unsigned char *)s;
    while (n--) *p++ = (unsigned char)c;
    return s;
}

void *memcpy(void *dst, const void *src, unsigned long n) {
    unsigned char *d = (unsigned char *)dst;
    const unsigned char *s = (const unsigned char *)src;
    while (n--) *d++ = *s++;
    return dst;
}

void *memmove(void *dst, const void *src, unsigned long n) {
    unsigned char *d = (unsigned char *)dst;
    const unsigned char *s = (const unsigned char *)src;
    if (d < s) {
        while (n--) *d++ = *s++;
    } else {
        d += n; s += n;
        while (n--) *--d = *--s;
    }
    return dst;
}

/* === Bump allocator === */

static void *heap_start = 0;
static void *heap_end = 0;
static void *heap_current = 0;

static void heap_init(void) {
    heap_start = (void *)0x400000;  /* Start at 4MB */
    heap_end = (void *)0x10000000;  /* Up to 256MB */
    heap_current = heap_start;
    brk(heap_end);
}

void *malloc(unsigned long size) {
    if (heap_start == 0) heap_init();

    /* Align to 16 bytes */
    size = (size + 15) & ~15UL;

    void *ptr = heap_current;
    heap_current = (void *)((unsigned long)heap_current + size);

    if (heap_current > heap_end) {
        /* Out of memory */
        return 0;
    }

    return ptr;
}

void free(void *ptr) {
    /* Bump allocator - no-op for simplicity */
    (void)ptr;
}

/* === I/O === */

int putchar(int c) {
    char ch = (char)c;
    write(1, &ch, 1);
    return c;
}

int puts(const char *s) {
    unsigned long len = strlen(s);
    write(1, s, len);
    putchar('\n');
    return (int)(len + 1);
}

/* === printf === */

static void print_string(const char *s) {
    if (!s) s = "(null)";
    write(1, s, strlen(s));
}

static void print_dec(unsigned long val) {
    char buf[21];
    int i = 0;
    if (val == 0) { putchar('0'); return; }
    while (val > 0) {
        buf[i++] = '0' + (val % 10);
        val /= 10;
    }
    while (i > 0) putchar(buf[--i]);
}

static void print_signed_dec(long val) {
    if (val < 0) {
        putchar('-');
        print_dec((unsigned long)-val);
    } else {
        print_dec((unsigned long)val);
    }
}

static void print_hex(unsigned long val) {
    char buf[17];
    int i = 0;
    if (val == 0) { putchar('0'); return; }
    while (val > 0) {
        int digit = val & 0xF;
        buf[i++] = digit < 10 ? '0' + digit : 'a' + digit - 10;
        val >>= 4;
    }
    while (i > 0) putchar(buf[--i]);
}

int printf(const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    int count = 0;

    for (int i = 0; fmt[i]; i++) {
        if (fmt[i] == '%' && fmt[i + 1]) {
            i++;
            switch (fmt[i]) {
                case 'd':
                    print_signed_dec(va_arg(ap, long));
                    break;
                case 'u':
                    print_dec(va_arg(ap, unsigned long));
                    break;
                case 'x':
                    print_hex(va_arg(ap, unsigned long));
                    break;
                case 's':
                    print_string(va_arg(ap, const char *));
                    break;
                case 'c':
                    putchar((char)va_arg(ap, int));
                    break;
                case '%':
                    putchar('%');
                    break;
                default:
                    putchar('%');
                    putchar(fmt[i]);
                    break;
            }
        } else {
            putchar(fmt[i]);
            count++;
        }
    }
    va_end(ap);
    return count;
}

/* === Entry point === */

void _start(void) {
    int ret = main(0, 0);
    exit(ret);
}