import "./core.zc"
import "./string.zc"

raw {
    char* format(const char* fmt, ...) {
        static char buffer[1024];
        va_list args;
        va_start(args, fmt);
        vsnprintf(buffer, sizeof(buffer), fmt, args);
        va_end(args);
        return buffer;
    }
    
    char* format_new(const char* fmt, ...) {
        char* buffer = malloc(1024);
        va_list args;
        va_start(args, fmt);
        vsnprintf(buffer, 1024, fmt, args);
        va_end(args);
        return buffer;
    }

    void* _z_get_stdin() 
    { 
        return stdin; 
    }

    int _z_get_eof() 
    { 
        return EOF; 
    }

    int _z_fgetc(void* stream) 
    { 
        return fgetc((FILE*)stream); 
    }
    
    char* _z_format_alloc(const char* fmt, va_list args) {
         int len = vsnprintf(NULL, 0, fmt, args);
         if (len < 0) return NULL;
         char* buffer = malloc(len + 1);
         if (!buffer) return NULL;
         vsnprintf(buffer, len + 1, fmt, args);
         return buffer;
    }
    
    char* format_s_raw(char* fmt, ...) {
        va_list args;
        va_start(args, fmt);
        char* ret = _z_format_alloc(fmt, args);
        va_end(args);
        return ret;
    }
}

extern fn format_s_raw(fmt: char*, ...) -> char*;

// TODO: add format function. We will need to do a few updates...
//       like adding support for varargs in Zen C functions.


fn readln() -> char* {
    var cap: usize = 64;
    var len: usize = 0;
    var line: char* = malloc(cap);
    if (line == NULL) return NULL;
    
    var c: int;
    var std_in = _z_get_stdin();
    var eof_val = _z_get_eof();

    while (true) {
        c = _z_fgetc(std_in);
        if (c == eof_val) break;
        if (c == 10) break; // '\n'

        if (len + 1 >= cap) {
            cap = cap * 2;
            var n = realloc(line, cap);
            if (n == NULL) {
                free(line);
                return NULL;
            }
            line = n;
        }
        
        line[len] = c;
        len = len + 1;
    }
    
    if (len == 0 && c == eof_val) {
        free(line);
        return NULL;
    }
    
    line[len] = 0;
    return line;
}