#ifndef OS_IMPL_LINUX_C
#define OS_IMPL_LINUX_C

#include "os.h"

#include "sys/mman.h"
#include "sys/stat.h"
#include "unistd.h" // POSIX Standard
#include "stdio.h"
#include "pthread.h"

#include "sys/socket.h"
#include "netinet/in.h"
#include "stdlib.h"
#include "arpa/inet.h"


void *os_alloc(size_t capacity) {
    return mmap(0, capacity, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
}

void os_commit(void *ptr) {
}

void os_decommit(void *ptr) {
}

void os_free(void *ptr, size_t size) {
    int err = munmap(ptr, size);
    Assert(err != -1);
}

string os_readEntireFile(Arena *arena, string filename) {
    Scratch temp = scratchStart(&arena, 1);

    FILE *input = fopen(cstring(temp.arena, filename), "r");
    string readBuffer;
    if (input) {
        struct stat st;
        stat((char *)filename.str, &st);
        size_t fsize = st.st_size;
        readBuffer = PushString(arena, fsize);
        fread(readBuffer.str, sizeof(byte), readBuffer.length, input);
        fclose(input);
    } else {
        readBuffer = PushString(arena, 0);
    }

    scratchEnd(temp);
    return readBuffer;
}

bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
    Scratch temp = scratchStart(&arena, 1);

    bool result = false;
    FILE *output = fopen(cstring(temp.arena, filename), "w");
    if (output) {
        fwrite(contents, sizeof(byte), contentsLength, output);
        fclose(output);
        result = true;
    }

    scratchEnd(temp);
    return result;
}

bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
    Scratch temp = scratchStart(&arena, 1);

    bool result = false;
    FILE *output = fopen(cstring(temp.arena, filename), "a");
    if (output) {
        fwrite(contents, sizeof(byte), contentsLength, output);
        fclose(output);
        result = true;
    }

    scratchEnd(temp);
    return result;
}

void os_print(StdStream target, const char *fmt, va_list argList) {
    Scratch temp = scratchStart(0, 0);

    string result = strPrintfv(temp.arena, fmt, argList);
    // TODO(djledda): finish implementation without cstdlib
    switch (target) {
        case StdStream_stdin:
            write(0, (const void *)result.str, result.length);
            break;
        case StdStream_stderr:
            fflush(stderr);
            write(2, (const void *)result.str, result.length);
            break;
        case StdStream_stdout:
        default:
            fflush(stdout);
            write(1, (const void *)result.str, result.length);
            break;
    }

    scratchEnd(temp);
}

OS_Thread os_createThread(void *(*entry)(void *), void *ctx) {
    pthread_t handle;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_create(&handle, &attr, entry, ctx);
    pthread_attr_destroy(&attr);
    return (OS_Thread){ .id=handle };
}

Server serverInit(ServerInitInfo info) {
    Arena *arena = arenaAlloc(info.memory);

    struct sockaddr_in6 *serverAddr = PushStructZero(arena, struct sockaddr_in6);
    serverAddr->sin6_family = AF_INET6;
    serverAddr->sin6_port = htons(info.port);
    serverAddr->sin6_addr = in6addr_loopback;

    Server server = {
        .arena=arena,
        .serverAddressData=(Address *)serverAddr,
        .clients=PushListZero(arena, ClientList, info.concurrentClients),
        .listening=false,
        .serverPort=info.port,
        .socket=(Socket *)(uint64)socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */),
    };

    int bindErr = bind((int)(uint64)server.socket, (struct sockaddr *)serverAddr, sizeof(*serverAddr));
    if (bindErr == -1) {
        // TODO(dledda): handle err
    }

    return server;
}

void serverListen(Server *s) {
    int listenErr = listen((uint64)s->socket, s->clients.capacity);
    if (listenErr == -1) {
        // TODO(dledda): handle err
    }
}

Client *serverAccept(Server *s) {
    struct sockaddr_in6 *clientAddr = PushStructZero(s->arena, struct sockaddr_in6);
    socklen_t clientAddrLen = sizeof(*clientAddr);

    uint64 clientSock = accept((int)(uint64)s->socket, (struct sockaddr *)clientAddr, &clientAddrLen);
    if (clientSock == -1) {
        // TODO(dledda): handle err
    }

    if (s->clients.length < s->clients.capacity) {
        AppendList(&s->clients, ((Client){
            .socket=(Socket *)(uint64)clientSock,
            .clientAddressData=(Address *)clientAddr,
        }));
    }

    return &s->clients.data[s->clients.length - 1];
}

uint64 clientRead(Client *client, void *dest, size_t bytes) {
    int bytesRead = read((uint64)client->socket, dest, bytes);
    if (bytesRead == -1) {
        // TODO(dledda): handle err
    }
    return bytesRead;
}

void clientWrite(Client *client) {
}

void clientClose(Client *client) {
    close((int)(uint64)client->socket);
}

void serverClose(Server *s) {
    close((int)(uint64)s->socket);
}

#endif