/* compile
 * gcc -nostdlib -ffreestanding -nostartfiles -nostdinc hello.c -o hello
 */
#define null ((void *)0)
#define NULL null
#define SYSREAD 0
#define SYSWRITE 1
#define SYSOPEN 2
#define SYSEXIT 60
#define SYSMMAP 9
#define STDOUT_FILENO 1
#define STDIN_FILENO 0

typedef unsigned long long int uint64_t;
typedef signed long long int int64_t;
typedef unsigned int size_t;
typedef unsigned char uint8_t;

/* boolean type */
typedef uint8_t _bool;
#ifdef bool
#undef bool
#define bool _bool;
#define false 0
#define true 1
#else
#define bool _bool
#define false 0
#define true 1
#endif

void _exit(int exitcode) {
    __asm__ inline(
        "movl %0 ,%%edi;"
        "xorl %%eax, %%eax;"
        "movl %1, %%eax;"
        "syscall" ::"r"(exitcode),
        "r"(SYSEXIT));
}

typedef __builtin_va_list _va_list;
#define _va_start(v, ...) __builtin_va_start(v, 0)
// #define _va_start(v,l)     __builtin_va_start(v,l)
#define _va_end(v) __builtin_va_end(v)
#define _va_arg(v, l) __builtin_va_arg(v, l)

char *_itoa(int number);

#define _static_assert(condition, message) \
    if (!(condition)) {                    \
        _print(_itoa(__LINE__));           \
        _print(" : ");                     \
        _print(__FILE__);                  \
        _print(" : ");                     \
        _print(__func__);                  \
        _print("()\n");                    \
        _print("\t[ ");                    \
        _print(#condition);                \
        _print(" ] FAILED\n");             \
        _print("MESSAGE: ");               \
        _print(message);                   \
        _print("\n");                      \
        _exit(-1);                         \
    }

#define _throw_assert(message) \
    _print(_itoa(__LINE__));   \
    _print(" : ");             \
    _print(__FILE__);          \
    _print(" : ");             \
    _print(__func__);          \
    _print("()\n");            \
    _print(message);           \
    _print("\n");              \
    _exit(-1);

#define CHECKNULL(buf)                                 \
    if (buf == null) {                                 \
        _throw_assert(" buffer is null<((void *)0)>"); \
    }

#ifndef __STACK_CHK_FAIL__
#define __STACK_CHK_FAIL__
int __stack_chk_fail(void) { return 0; };
#endif

size_t _strlen(const char *buf) {
    if (buf == null) {
        _exit(-1);
    }
    size_t count = 0;
    while (*buf != '\0') {
        buf++;
        count++;
    }
    return count;
}

void *_mmap(void *addr, uint64_t length, int64_t prot, int64_t flags,
            int64_t fd, int64_t offset) {
    void *ptr = null;
    __asm__ inline(
        "movq %%rcx,%%r10;"
        "syscall;"
        "mov %%rax, %[return_ptr];"
        : [return_ptr] "=rm"(ptr)
        : "a"(SYSMMAP));
    return ptr;
}

// malloc using mmap
[[nodiscard("returns pointer to heap memory")]] void *_malloc(size_t size) {
    void *ptr = null;
    __asm__ inline(
        "mov $0, %%r9;"     // offset
        "mov $0, %%r8;"     // file descriptor
        "mov $34,%%r10;"    // MAP_PRIVATE || MAP_SHARED
        "movq $0, %%rdi;"   // mapp destination (void addr)
        "movq $3 , %%rdx;"  // PROT_READ || PROT_WRITE
        "syscall;"
        "mov %%rax, %[return_ptr];"
        : [return_ptr] "=rm"(ptr)
        : "S"(size), "a"(SYSMMAP));

    return ptr;
}

int _reverse(char *str, size_t length) {
    if (str == null) {
        return -1;
    }

    int start = 0;
    int end = length - 1;
    while (start < end) {
        char temp = str[start];
        str[start] = str[end];
        str[end] = temp;
        end--;
        start++;
    }
    return 0;
}

char *_itoa(int number) {
    if (number == 0) {
        return "0\0";
    }

    const int MAX_LENGTH = 11;
    char *intstr = (char *)_malloc(MAX_LENGTH);

    // check for negative
    _bool isNeg = false;

    if (number < 0) {
        isNeg = true;
        int temp = 0;
        __asm__ inline(
            "movl %1 ,%%eax;"
            "neg %%eax;"
            "movl %%eax, %0;"
            : "=r"(temp)
            : "a"(number));

        number = temp;
    }

    int i = 0;
    while (number != 0 && i < MAX_LENGTH) {
        int temp = number % 10;
        intstr[i] = (temp > 9) ? (temp - 10) + 'a' : temp + '0';
        number /= 10;
        i++;
    }

    // fix the negative sign
    if (isNeg == true) {
        intstr[i] = '-';
        i++;
    }

    // fix the null terminator
    intstr[i] = '\0';
    int reverse = _reverse(intstr, _strlen(intstr));

    if (reverse == -1) {
        return "-1";
    }

    return intstr;
}

void _read(int fd, char *__restrict __buf, unsigned int count) {
    __asm__ inline("syscall;"
                   : "=S"(__buf)
                   : "a"(SYSREAD), "D"(fd), "d"(count));
}

void _write(int fd, const char *buf, unsigned int count) {
    __asm__ inline("syscall;" : : "a"(SYSWRITE), "D"(fd), "d"(count), "S"(buf));
}

void _print(const char *str) {
    CHECKNULL(str);
    _write(STDOUT_FILENO, str, _strlen(str));
}

void _printn(const char *str, size_t n) {
    CHECKNULL(str);
    _static_assert(n <= _strlen(str), "<size_t>  n  > <size_t> strlen");
    _write(STDOUT_FILENO, str, n);
}

void _println(const char *str) {
    CHECKNULL(str);
    _write(STDOUT_FILENO, str, _strlen(str));
    _write(STDOUT_FILENO, "\n", 1);
}

void _printf(const char *__restrict __fmt, ...) {
    _va_list ap;
    _va_start(ap, __fmt);

    size_t len = _strlen(__fmt);
    size_t i = 0;

    for (; i < len; i++) {
        if (__fmt[i] == '%') {
            i++;
            switch (__fmt[i]) {
                case 'd':
                    _print(_itoa(_va_arg(ap, int)));
                    break;
                case 'c': {
                    char temp = (char)(_va_arg(ap, int));
                    _printn(&temp, 1);
                    break;
                }
                case 's':
                    _print(_va_arg(ap, char *));
                    break;
                case 'l':
                    _print(_itoa(_va_arg(ap, long)));
                    break;
                default:
                    _printn(&__fmt[i], 1);
                    break;
            }
        } else if (__fmt[i] != '\0') {
            _printn(&__fmt[i], 1);
        } else if (__fmt[i] == '\0') {
            break;
        }
    }
    _va_end(ap);
}

void _start() {
    _printf("hello world\n");
    _exit(0);
}