#define MODULE "stdio"

#include "errno.h"
#include "interrupts/Context.h"
#include "io/Serial.h"
#include "log/Log.h"
#include "render/TextRenderer.h"
#include "thread/Scheduler.h"
#include "thread/Task.h"

#define OPEN_READ 1
#define OPEN_WRITE 2

#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2

#define STDIO_FAIL(function, error) kwarnln("%s failed with %s", #function, #error)

void sys_seek(Context* context, int fd, long offset, int whence)
{
    if (whence < SEEK_SET || whence > SEEK_END)
    {
        STDIO_FAIL(seek, EINVAL);
        context->rax = -EINVAL;
        return;
    }
    if (fd >= TASK_MAX_FDS || fd < 0)
    {
        STDIO_FAIL(seek, EBADF);
        context->rax = -EBADF;
        return;
    }
    Task* current_task = Scheduler::current_task();
    if (!current_task->files[fd].is_open())
    {
        STDIO_FAIL(seek, EBADF);
        context->rax = -EBADF;
        return;
    }
    long new_offset;
    if (whence == SEEK_SET) new_offset = offset;
    else if (whence == SEEK_CUR)
        new_offset = offset + current_task->files[fd].offset();
    else if (whence == SEEK_END)
        new_offset = current_task->files[fd].length() + offset;
    else
        __builtin_unreachable();
    if (new_offset < 0)
    {
        STDIO_FAIL(seek, EINVAL);
        context->rax = -EINVAL; // FIXME: Is this the right error?
        return;
    }
    int result = current_task->files[fd].seek(new_offset);
    if (result < 0)
    {
        context->rax = result;
        return;
    }
    context->rax = new_offset;
    return;
}

void sys_write(Context* context, int fd, size_t size, const char* addr)
{
    if (!addr)
    {
        STDIO_FAIL(write, EINVAL);
        context->rax = -EINVAL; // FIXME: This should probably return EFAULT.
        return;
    }
    if (fd >= TASK_MAX_FDS || fd < 0)
    {
        STDIO_FAIL(write, EBADF);
        context->rax = -EBADF;
        return;
    }
    Task* current_task = Scheduler::current_task();
    if (!current_task->files[fd].is_open())
    {
        STDIO_FAIL(write, EBADF);
        context->rax = -EBADF;
        return;
    }
    if (!current_task->files[fd].can_write())
    {
        STDIO_FAIL(write, EBADF);
        context->rax = -EBADF;
        return;
    }
    ssize_t result = current_task->files[fd].write(size, addr);
    context->rax = (size_t)result;
    return;
}

void sys_open(Context* context, const char* filename, int flags)
{
    Task* current_task = Scheduler::current_task();
    int fd;
    for (fd = 0; fd < TASK_MAX_FDS; fd++)
    {
        if (!current_task->files[fd].is_open()) break;
    }

    if (fd == TASK_MAX_FDS)
    {
        STDIO_FAIL(open, EMFILE);
        context->rax = -EMFILE;
        return;
    }

    VFS::Node* node = VFS::resolve_path(filename);
    if (!node)
    {
        STDIO_FAIL(open, ENOENT);
        context->rax = -ENOENT;
        return;
    }

    bool can_read = (flags & OPEN_READ) > 0;
    bool can_write = (flags & OPEN_WRITE) > 0;
    if (!can_read && !can_write)
    {
        STDIO_FAIL(open, EINVAL);
        context->rax = -EINVAL;
        return;
    }

    kdbgln("open(): opening %s %s, allocated file descriptor %d", filename,
           (can_read && can_write) ? "rw"
           : can_read              ? "r-"
                                   : "-w",
           fd);

    current_task->files[fd].open(node, can_read, can_write);
    context->rax = fd;
    return;
}

void sys_read(Context* context, int fd, size_t size, char* buffer)
{
    if (!buffer)
    {
        STDIO_FAIL(read, EINVAL);
        context->rax = -EINVAL; // FIXME: This should probably return EFAULT.
        return;
    }
    if (fd >= TASK_MAX_FDS || fd < 0)
    {
        STDIO_FAIL(read, EBADF);
        context->rax = -EBADF;
        return;
    }
    Task* current_task = Scheduler::current_task();
    if (!current_task->files[fd].is_open() || !current_task->files[fd].can_read())
    {
        STDIO_FAIL(read, EBADF);
        context->rax = -EBADF;
        return;
    }
    ssize_t result = current_task->files[fd].read(size, buffer);
    context->rax = (size_t)result;
    return;
}

void sys_close(Context* context, int fd)
{
    if (fd >= TASK_MAX_FDS || fd < 0)
    {
        STDIO_FAIL(close, EBADF);
        context->rax = -EBADF;
        return;
    }
    Task* current_task = Scheduler::current_task();
    if (!current_task->files[fd].is_open())
    {
        STDIO_FAIL(close, EBADF);
        context->rax = -EBADF;
        return;
    }
    kdbgln("close(): releasing file descriptor %d", fd);
    current_task->files[fd].close();
    context->rax = 0;
    return;
}