#include <aux/compiler.h>
#include <device/device.h>
#include <device_info.h>
#include <fs/path.h>
#include <fs/vfs.h>
#include <libk/assert.h>
#include <libk/fieldlengthof.h>
#include <libk/std.h>
#include <libk/string.h>
#include <limine/requests.h>
#include <mm/pmm.h>
#include <path_defs.h>
#include <proc/mail.h>
#include <proc/mutex.h>
#include <proc/proc.h>
#include <proc/procgroup.h>
#include <proc/resource.h>
#include <proc_info.h>
#include <status.h>
#include <sync/spin_lock.h>
#include <sys/debug.h>
#include <sys/mm.h>
#include <sys/proc.h>
#include <sys/time.h>
#include <syscall/syscall.h>
#include <syscall_defs.h>
#include <time.h>
#include <volume_info.h>
#include <write_file.h>

#define DEFINE_SYSCALL(name)                                                                       \
  uintptr_t name(struct proc* UNUSED proc, void* UNUSED regs, struct reschedule_ctx* UNUSED rctx,  \
                 uintptr_t UNUSED a1, uintptr_t UNUSED a2, uintptr_t UNUSED a3,                    \
                 uintptr_t UNUSED a4, uintptr_t UNUSED a5, uintptr_t UNUSED a6)

#define SYSRESULT(x) ((uintptr_t)(x))

static void* sys_get_user_buffer(struct procgroup* procgroup, uintptr_t uvaddr, size_t size) {
  uint64_t fpg;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  spin_lock(&procgroup->lock, &fpg);

  if (!mm_validate_buffer(&procgroup->pd, (uintptr_t)uvaddr, size)) {
    spin_unlock(&procgroup->lock, fpg);
    return NULL;
  }

  uintptr_t out_paddr = mm_v2p(&procgroup->pd, uvaddr);

  spin_unlock(&procgroup->lock, fpg);

  uintptr_t out_kvaddr = (uintptr_t)hhdm->offset + out_paddr;

  return (void*)out_kvaddr;
}

/* int quit (void) */
DEFINE_SYSCALL(sys_quit) {
  proc_kill(proc, rctx);

  return SYSRESULT(ST_OK);
}

/* int test (void) */
DEFINE_SYSCALL(sys_test) {
  char c = (char)a1;
  DEBUG("test syscall from %d! %c\n", proc->pid, c);
  return SYSRESULT(ST_OK);
}

/* int map (uintptr_t vaddr, size_t pages, uint32_t flags) */
DEFINE_SYSCALL(sys_map) {
  uint64_t fp;

  uintptr_t vaddr = a1;
  size_t pages = (size_t)a2;
  uint32_t flags = (uint32_t)a3;

  if (vaddr % PAGE_SIZE != 0)
    return SYSRESULT(-ST_UNALIGNED);

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  return SYSRESULT(procgroup_map(procgroup, vaddr, pages, flags, NULL));
}

/* int unmap (uintptr_t vaddr, size_t pages) */
DEFINE_SYSCALL(sys_unmap) {
  uint64_t fp;

  uintptr_t vaddr = a1;
  size_t pages = (size_t)a2;

  if (vaddr % PAGE_SIZE != 0)
    return SYSRESULT(-ST_UNALIGNED);

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  return SYSRESULT(procgroup_unmap(procgroup, vaddr, pages));
}

/* int clone (uintptr_t vstack_top, void* entry, void* argument_ptr) */
DEFINE_SYSCALL(sys_clone) {
  uintptr_t vstack_top = a1;
  uintptr_t entry = a2;
  uintptr_t argument_ptr = a3;

  struct proc* new = proc_clone(proc, vstack_top, entry, argument_ptr);

  if (new == NULL) {
    return SYSRESULT(-ST_OOM_ERROR);
  }

  int pid = new->pid;

  proc_register(new, NULL, rctx);

  return SYSRESULT(pid);
}

/* void* argument_ptr (void) */
DEFINE_SYSCALL(sys_argument_ptr) {
  uint64_t fp;

  spin_lock(&proc->lock, &fp);
  uintptr_t p = proc->uvaddr_argument;
  spin_unlock(&proc->lock, fp);

  return p;
}

/* int sched (void) */
DEFINE_SYSCALL(sys_sched) {
  rctx_insert_cpu(rctx, thiscpu);
  return SYSRESULT(ST_OK);
}

/* int mutex_create (void) */
DEFINE_SYSCALL(sys_mutex_create) {
  uint64_t fr, fp;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  struct proc_resource* mutex_resource = proc_create_resource_mutex(procgroup);

  if (mutex_resource == NULL)
    return SYSRESULT(-ST_OOM_ERROR);

  spin_lock(&mutex_resource->lock, &fr);
  int rid = mutex_resource->rid;
  spin_unlock(&mutex_resource->lock, fr);

  return SYSRESULT(rid);
}

/* int mutex_delete (int mutex_rid) */
DEFINE_SYSCALL(sys_mutex_delete) {
  uint64_t fp;

  int mutex_rid = (int)a1;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  struct proc_resource* mutex_resource = proc_find_resource(procgroup, mutex_rid);

  if (mutex_resource == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  proc_delete_resource(procgroup, mutex_resource, rctx);

  return SYSRESULT(ST_OK);
}

/* int mutex_lock (int mutex_rid) */
DEFINE_SYSCALL(sys_mutex_lock) {
  uint64_t fp;

  int mutex_rid = (int)a1;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  struct proc_resource* mutex_resource = proc_find_resource(procgroup, mutex_rid);

  if (mutex_resource == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  proc_mutex_lock(proc, &mutex_resource->u.mutex, rctx);

  return SYSRESULT(ST_OK);
}

/* int mutex_unlock (int mutex_rid) */
DEFINE_SYSCALL(sys_mutex_unlock) {
  uint64_t fp;

  int mutex_rid = (int)a1;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  struct proc_resource* mutex_resource = proc_find_resource(procgroup, mutex_rid);

  if (mutex_resource == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  proc_mutex_unlock(proc, &mutex_resource->u.mutex, rctx);

  return SYSRESULT(ST_OK);
}

/* int mail_send (int pgid, void* mesg, size_t mesg_size) */
DEFINE_SYSCALL(sys_mail_send) {
  uint64_t fp;

  int pgid = (int)a1;
  uintptr_t uvaddr_mesg = a2;
  size_t mesg_size = (size_t)a3;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  void* mesg = sys_get_user_buffer(procgroup, uvaddr_mesg, mesg_size);

  if (mesg == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  struct procgroup* procgroup1 = procgroup_find(pgid);

  if (procgroup1 == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  struct proc_resource* mail_resource = proc_find_resource(procgroup1, 0);

  if (mail_resource == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  proc_mail_send(proc, &mail_resource->u.mail, rctx, mesg, mesg_size);

  return SYSRESULT(ST_OK);
}

/* int mail_receive (void* recv_mesg, size_t mesg_size) */
DEFINE_SYSCALL(sys_mail_receive) {
  uint64_t fp;

  uintptr_t uvaddr_mesg = a1;
  size_t mesg_size = (size_t)a2;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  void* mesg = sys_get_user_buffer(procgroup, uvaddr_mesg, mesg_size);

  if (mesg == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  struct proc_resource* mail_resource = proc_find_resource(procgroup, 0);

  if (mail_resource == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  proc_mail_receive(proc, &mail_resource->u.mail, rctx, mesg, mesg_size);

  return SYSRESULT(ST_OK);
}

/* int device_do (int device_id, int cmd, void* a1, void* a2, void* a3, void* a4) */
DEFINE_SYSCALL(sys_device_do) {
  uint64_t fpg, fd, fp;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t uvaddr_key = a1;
  int cmd = (int)a2;
  uintptr_t ua1 = a3, ka1 = 0;
  uintptr_t ua2 = a4, ka2 = 0;
  uintptr_t ua3 = a5, ka3 = 0;
  uintptr_t ua4 = a6, ka4 = 0;
  uintptr_t out_paddr;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  if (!(cmd >= 0 && cmd < (int)fieldlengthof(struct device, ops)))
    return SYSRESULT(-ST_BAD_DEVICE_OP);

  spin_lock(&procgroup->lock, &fpg);

  out_paddr = mm_v2p(&procgroup->pd, uvaddr_key);

  if (out_paddr == 0) {
    spin_unlock(&procgroup->lock, fpg);
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);
  }

  const char* key = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  out_paddr = mm_v2p(&procgroup->pd, ua1);
  if (out_paddr != 0)
    ka1 = (uintptr_t)hhdm->offset + out_paddr;

  out_paddr = mm_v2p(&procgroup->pd, ua2);
  if (out_paddr != 0)
    ka2 = (uintptr_t)hhdm->offset + out_paddr;

  out_paddr = mm_v2p(&procgroup->pd, ua3);
  if (out_paddr != 0)
    ka3 = (uintptr_t)hhdm->offset + out_paddr;

  out_paddr = mm_v2p(&procgroup->pd, ua4);
  if (out_paddr != 0)
    ka4 = (uintptr_t)hhdm->offset + out_paddr;

  spin_unlock(&procgroup->lock, fpg);

  struct device* device = device_find(key);

  if (device == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  spin_lock(&device->lock, &fd);

  if (device->ops[cmd] == NULL) {
    spin_unlock(&device->lock, fd);
    return SYSRESULT(-ST_NOT_FOUND);
  }

  int ret = device_op(device, cmd, proc, rctx, &fd, ka1, ka2, ka3, ka4);

  spin_unlock(&device->lock, fd);

  return SYSRESULT(ret);
}

/* int exec (char* volume, char* path) */
DEFINE_SYSCALL(sys_exec) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_volume = a1;
  uintptr_t uvaddr_path = a2;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  int pid1 = proc->pid;
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_path);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  spin_lock(&procgroup->lock, &fpg);

  out_paddr = mm_v2p(&procgroup->pd, uvaddr_volume);

  if (out_paddr == 0) {
    spin_unlock(&procgroup->lock, fpg);
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);
  }

  const char* volume = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  struct proc* new = proc_from_file(proc, volume, path, rctx);

  if (new == NULL) {
    spin_unlock(&procgroup->lock, fpg);
    return SYSRESULT(-ST_EXEC_ERROR);
  }

  spin_unlock(&procgroup->lock, fpg);

  int pid = new->pid;
  new->exec_pid = pid1;

  proc_register(new, NULL, rctx);

  return SYSRESULT(pid);
}

/* int exec_partial (char* volume, char* path) */
DEFINE_SYSCALL(sys_exec_partial) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_volume = a1;
  uintptr_t uvaddr_path = a2;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  int pid1 = proc->pid;
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_path);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  spin_lock(&procgroup->lock, &fpg);

  out_paddr = mm_v2p(&procgroup->pd, uvaddr_volume);

  if (out_paddr == 0) {
    spin_unlock(&procgroup->lock, fpg);
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);
  }

  const char* volume = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  struct proc* new = proc_from_file(proc, volume, path, rctx);

  if (new == NULL) {
    spin_unlock(&procgroup->lock, fpg);
    return SYSRESULT(-ST_EXEC_ERROR);
  }

  spin_unlock(&procgroup->lock, fpg);

  int pid = new->pid;
  new->exec_pid = pid1;
  new->state = PROC_PARTIAL;

  proc_register_partial(new);

  return SYSRESULT(pid);
}

/* int exec_partial_fini (int pid) */
DEFINE_SYSCALL(sys_exec_partial_fini) {
  uint64_t fp, fc;

  int pid = (int)a1;

  struct proc* target_proc = proc_find_pid(pid);

  if (target_proc == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  spin_lock(&target_proc->lock, &fp);

  if (target_proc->state != PROC_PARTIAL) {
    spin_unlock(&target_proc->lock, fp);
    return SYSRESULT(-ST_NOT_PARTIAL);
  }

  spin_unlock(&target_proc->lock, fp);

  struct cpu* cpu = cpu_find_lightest();

  spin_lock(&cpu->lock, &fc);
  spin_lock(&target_proc->lock, &fp);

  target_proc->cpu = cpu;
  target_proc->state = PROC_READY;

  cpu->proc_run_q_count++;
  list_append(cpu->proc_run_q, &target_proc->cpu_run_q_link);

  spin_unlock(&target_proc->lock, fp);
  spin_unlock(&cpu->lock, fc);

  rctx_insert_cpu(rctx, cpu);

  return SYSRESULT(ST_OK);
}

/* int volume_open (char* volume) */
DEFINE_SYSCALL(sys_volume_open) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_volume = a1;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_volume);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* volume = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  int ret = vfs_volume_open(proc, volume, rctx);

  if (ret < 0)
    return SYSRESULT(ret);

  spin_lock(&proc->lock, &fp);
  strncpy(proc->cwv, volume, VOLUME_MAX);
  spin_unlock(&proc->lock, fp);

  return SYSRESULT(ST_OK);
}

/* int volume_close (void) */
DEFINE_SYSCALL(sys_volume_close) {
  uint64_t fp;

  char cwv[VOLUME_MAX];
  spin_lock(&proc->lock, &fp);
  memcpy(cwv, proc->cwv, sizeof(proc->cwv));
  spin_unlock(&proc->lock, fp);

  int ret = vfs_volume_close(proc, cwv, rctx);

  if (ret == ST_OK) {
    spin_lock(&proc->lock, &fp);
    memset(proc->cwv, 0, sizeof(proc->cwv));
    spin_unlock(&proc->lock, fp);
  }

  return SYSRESULT(ret);
}

/* int read_file (char* path, size_t off, uint8_t* buffer, size_t size) */
DEFINE_SYSCALL(sys_read_file) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_path = a1;
  size_t off = (size_t)a2;
  uintptr_t uvaddr_buffer = a3;
  size_t size = (size_t)a4;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  char cwv[VOLUME_MAX];
  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  memcpy(cwv, proc->cwv, sizeof(proc->cwv));
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_path);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  uint8_t* buffer = sys_get_user_buffer(procgroup, uvaddr_buffer, size);

  if (buffer == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  int ret = vfs_read_file(proc, rctx, cwv, path, buffer, off, size);

  return SYSRESULT(ret);
}

/* int describe (char* path, struct desc* desc) */
DEFINE_SYSCALL(sys_describe) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_path = a1;
  uintptr_t uvaddr_desc = a2;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  char cwv[VOLUME_MAX];
  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  memcpy(cwv, proc->cwv, sizeof(proc->cwv));
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_path);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  struct desc* desc = sys_get_user_buffer(procgroup, uvaddr_desc, sizeof(struct desc));

  if (desc == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  int ret = vfs_describe(proc, rctx, cwv, path, desc);

  return SYSRESULT(ret);
}

/* int get_procgroup (int pid) */
DEFINE_SYSCALL(sys_get_procgroup) {
  uint64_t fp, fpg;

  int pid = (int)a1;

  struct proc* target_proc = proc_find_pid(pid);

  if (target_proc == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  spin_lock(&target_proc->lock, &fp);
  struct procgroup* procgroup = target_proc->procgroup;
  spin_unlock(&target_proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  int pgid = procgroup->pgid;
  spin_unlock(&procgroup->lock, fpg);

  return SYSRESULT(pgid);
}

/* int read_dir_entry (char* path, struct dir_entry* entry, size_t entry_num) */
DEFINE_SYSCALL(sys_read_dir_entry) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_path = a1;
  uintptr_t uvaddr_entry = a2;
  size_t entry_num = (size_t)a3;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  char cwv[VOLUME_MAX];
  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  memcpy(cwv, proc->cwv, sizeof(proc->cwv));
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_path);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  struct dir_entry* entry = sys_get_user_buffer(procgroup, uvaddr_entry, sizeof(struct dir_entry));

  if (entry == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  int ret = vfs_read_dir_entry(proc, rctx, cwv, path, entry, entry_num);

  return SYSRESULT(ret);
}

/* int create_file (char* path) */
DEFINE_SYSCALL(sys_create_file) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_path = a1;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  char cwv[VOLUME_MAX];
  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  memcpy(cwv, proc->cwv, sizeof(proc->cwv));
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_path);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  int ret = vfs_create_file(proc, rctx, cwv, path);

  return SYSRESULT(ret);
}

/* int write_file (char* path, size_t off, uint8_t* buffer, size_t size, uint32_t flags) */
DEFINE_SYSCALL(sys_write_file) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_path = a1;
  size_t off = (size_t)a2;
  uintptr_t uvaddr_buffer = a3;
  size_t size = (size_t)a4;
  uint32_t flags = (uint32_t)a5;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  char cwv[VOLUME_MAX];
  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  memcpy(cwv, proc->cwv, sizeof(proc->cwv));
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_path);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  uint8_t* buffer = sys_get_user_buffer(procgroup, uvaddr_buffer, size);

  if (buffer == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  int ret = vfs_write_file(proc, rctx, cwv, path, buffer, off, size, flags);

  return SYSRESULT(ret);
}

/* int get_exec_pid (void) */
DEFINE_SYSCALL(sys_get_exec_pid) {
  uint64_t fp;

  spin_lock(&proc->lock, &fp);
  int exec_pid = proc->exec_pid;
  spin_unlock(&proc->lock, fp);

  return SYSRESULT(exec_pid);
}

/* wait_for_pid (int pid) */
DEFINE_SYSCALL(sys_wait_for_pid) {
  int pid = (int)a1;

  struct proc* wait_proc = proc_find_pid(pid);

  if (wait_proc == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  proc_wait_for(proc, rctx, wait_proc);

  return SYSRESULT(ST_OK);
}

/* int kill (int pid) */
DEFINE_SYSCALL(sys_kill) {
  int pid = (int)a1;

  struct proc* target_proc = proc_find_pid(pid);

  if (target_proc == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  proc_kill(target_proc, rctx);

  return ST_OK;
}

/* int create_dir (char* path) */
DEFINE_SYSCALL(sys_create_dir) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_path = a1;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  char cwv[VOLUME_MAX];
  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  memcpy(cwv, proc->cwv, sizeof(proc->cwv));
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_path);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  int ret = vfs_create_dir(proc, rctx, cwv, path);

  return SYSRESULT(ret);
}

/* int remove (char* path) */
DEFINE_SYSCALL(sys_remove) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_path = a1;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  char cwv[VOLUME_MAX];
  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  memcpy(cwv, proc->cwv, sizeof(proc->cwv));
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_path);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  int ret = vfs_remove(proc, rctx, cwv, path);

  return SYSRESULT(ret);
}

/* int create_volume (char* key, int fs_type, char* device_key) */
DEFINE_SYSCALL(sys_create_volume) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_key = a1;
  int type = (int)a2;
  uintptr_t uvaddr_device_key = a3;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  char cwv[VOLUME_MAX];
  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  memcpy(cwv, proc->cwv, sizeof(proc->cwv));
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);

  out_paddr = mm_v2p(&procgroup->pd, uvaddr_key);

  if (out_paddr == 0) {
    spin_unlock(&procgroup->lock, fpg);
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);
  }

  const char* key = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  out_paddr = mm_v2p(&procgroup->pd, uvaddr_device_key);

  if (out_paddr == 0) {
    spin_unlock(&procgroup->lock, fpg);
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);
  }

  const char* device_key = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  spin_unlock(&procgroup->lock, fpg);

  struct device* device = device_find(device_key);

  if (device == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  return SYSRESULT(vfs_create_volume(proc, rctx, key, type, device, false));
}

/* int env_set (int pgid, char* key, void* buffer, size_t size) */
DEFINE_SYSCALL(sys_env_set) {
  uint64_t fp, fpg;

  int pgid = (int)a1;
  uintptr_t uvaddr_key = a2;
  uintptr_t uvaddr_buffer = a3;
  size_t size = (size_t)a4;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  struct procgroup* target_procgroup = procgroup_find(pgid);

  if (target_procgroup == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  uintptr_t out_paddr;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);

  out_paddr = mm_v2p(&procgroup->pd, uvaddr_key);

  if (out_paddr == 0) {
    spin_unlock(&procgroup->lock, fpg);
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);
  }

  const char* key = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  spin_unlock(&procgroup->lock, fpg);

  void* buffer = sys_get_user_buffer(procgroup, uvaddr_buffer, size);

  if (buffer == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  return SYSRESULT(proc_env_set(target_procgroup, key, buffer, size));
}

/* int env_get (int pgid, char* key, void* buffer, size_t size) */
DEFINE_SYSCALL(sys_env_get) {
  uint64_t fp, fpg;

  int pgid = (int)a1;
  uintptr_t uvaddr_key = a2;
  uintptr_t uvaddr_buffer = a3;
  size_t size = (size_t)a4;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  struct procgroup* target_procgroup = procgroup_find(pgid);

  if (target_procgroup == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  uintptr_t out_paddr;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);

  out_paddr = mm_v2p(&procgroup->pd, uvaddr_key);

  if (out_paddr == 0) {
    spin_unlock(&procgroup->lock, fpg);
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);
  }

  const char* key = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  spin_unlock(&procgroup->lock, fpg);

  void* buffer = sys_get_user_buffer(procgroup, uvaddr_buffer, size);

  if (buffer == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  return SYSRESULT(proc_env_get(target_procgroup, key, buffer, size));
}

/* int get_self_pid (void) */
DEFINE_SYSCALL(sys_get_self_pid) {
  uint64_t fp;

  spin_lock(&proc->lock, &fp);
  int pid = proc->pid;
  spin_unlock(&proc->lock, fp);

  return SYSRESULT(pid);
}

/* int stream_write (int pgid, int rid, void* buffer, size_t size) */
DEFINE_SYSCALL(sys_stream_write) {
  uint64_t fp;

  int pgid = (int)a1;
  int rid = (int)a2;
  uintptr_t uvaddr_buffer = a3;
  size_t buffer_size = (size_t)a4;

  struct procgroup* target_procgroup = procgroup_find(pgid);

  if (target_procgroup == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  void* buffer = sys_get_user_buffer(procgroup, uvaddr_buffer, buffer_size);

  if (buffer == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  struct proc_resource* stream_resource = proc_find_resource(target_procgroup, rid);

  if (stream_resource == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  proc_stream_write(&stream_resource->u.stream, buffer, buffer_size);

  return SYSRESULT(ST_OK);
}

/* int stream_read (int pgid, int rid, void* buffer, size_t size) */
DEFINE_SYSCALL(sys_stream_read) {
  uint64_t fp;

  int pgid = (int)a1;
  int rid = (int)a2;
  uintptr_t uvaddr_buffer = a3;
  size_t buffer_size = (size_t)a4;

  struct procgroup* target_procgroup = procgroup_find(pgid);

  if (target_procgroup == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  void* buffer = sys_get_user_buffer(procgroup, uvaddr_buffer, buffer_size);

  if (buffer == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  struct proc_resource* stream_resource = proc_find_resource(target_procgroup, rid);

  if (stream_resource == NULL)
    return SYSRESULT(-ST_NOT_FOUND);

  return SYSRESULT(proc_stream_read(&stream_resource->u.stream, buffer, buffer_size));
}

/* int get_proc_int (struct proc_info* infos, size_t count) */
DEFINE_SYSCALL(sys_get_proc_info) {
  uint64_t fp;

  uintptr_t uvaddr_infos = a1;
  size_t infos_count = (size_t)a2;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  struct proc_info* infos =
      sys_get_user_buffer(procgroup, uvaddr_infos, infos_count * sizeof(struct proc_info));

  if (infos == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  return SYSRESULT(proc_populate_proc_infos(infos, infos_count));
}

/* int get_device_info (struct device_info* infos, size_t count) */
DEFINE_SYSCALL(sys_get_device_info) {
  uint64_t fp;

  uintptr_t uvaddr_infos = a1;
  size_t infos_count = (size_t)a2;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  struct device_info* infos =
      sys_get_user_buffer(procgroup, uvaddr_infos, infos_count * sizeof(struct device_info));

  if (infos == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  return SYSRESULT(device_populate_device_infos(infos, infos_count));
}

/* int get_volume_info (struct volume_info* infos, size_t count) */
DEFINE_SYSCALL(sys_get_volume_info) {
  uint64_t fp;

  uintptr_t uvaddr_infos = a1;
  size_t infos_count = (size_t)a2;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  struct volume_info* infos =
      sys_get_user_buffer(procgroup, uvaddr_infos, infos_count * sizeof(struct volume_info));

  if (infos == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  return SYSRESULT(volume_populate_volume_infos(infos, infos_count));
}

/* int volume_delete (const char* volume) */
DEFINE_SYSCALL(sys_volume_delete) {
  uint64_t fpg, fp;

  uintptr_t uvaddr_volume = a1;

  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  uintptr_t out_paddr;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  spin_lock(&procgroup->lock, &fpg);
  out_paddr = mm_v2p(&procgroup->pd, uvaddr_volume);
  spin_unlock(&procgroup->lock, fpg);

  if (out_paddr == 0)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  const char* volume = (const char*)((uintptr_t)hhdm->offset + out_paddr);

  int ret = vfs_volume_delete(volume);

  if (ret < 0)
    return SYSRESULT(ret);

  return SYSRESULT(ST_OK);
}

/* int date_time (struct date_time* dt) */
DEFINE_SYSCALL(sys_date_time) {
  uint64_t fp;

  uintptr_t uvaddr_dt = a1;

  spin_lock(&proc->lock, &fp);
  struct procgroup* procgroup = proc->procgroup;
  spin_unlock(&proc->lock, fp);

  struct date_time* dt = sys_get_user_buffer(procgroup, uvaddr_dt, sizeof(struct date_time));

  if (dt == NULL)
    return SYSRESULT(-ST_BAD_ADDRESS_SPACE);

  date_time(dt);

  return ST_OK;
}

static syscall_handler_func_t handler_table[] = {
    [SYS_QUIT] = &sys_quit,
    [SYS_TEST] = &sys_test,
    [SYS_MAP] = &sys_map,
    [SYS_UNMAP] = &sys_unmap,
    [SYS_CLONE] = &sys_clone,
    [SYS_ARGUMENT_PTR] = &sys_argument_ptr,
    [SYS_SCHED] = &sys_sched,
    [SYS_MUTEX_CREATE] = &sys_mutex_create,
    [SYS_MUTEX_DELETE] = &sys_mutex_delete,
    [SYS_MUTEX_LOCK] = &sys_mutex_lock,
    [SYS_MUTEX_UNLOCK] = &sys_mutex_unlock,
    [SYS_DEVICE_DO] = &sys_device_do,
    [SYS_EXEC] = &sys_exec,
    [SYS_VOLUME_OPEN] = &sys_volume_open,
    [SYS_VOLUME_CLOSE] = &sys_volume_close,
    [SYS_READ_FILE] = &sys_read_file,
    [SYS_DESCRIBE] = &sys_describe,
    [SYS_MAIL_SEND] = &sys_mail_send,
    [SYS_MAIL_RECEIVE] = &sys_mail_receive,
    [SYS_GET_PROCGROUP] = &sys_get_procgroup,
    [SYS_GET_EXEC_PID] = &sys_get_exec_pid,
    [SYS_READ_DIR_ENTRY] = &sys_read_dir_entry,
    [SYS_CREATE_FILE] = &sys_create_file,
    [SYS_WRITE_FILE] = &sys_write_file,
    [SYS_WAIT_FOR_PID] = &sys_wait_for_pid,
    [SYS_KILL] = &sys_kill,
    [SYS_CREATE_DIR] = &sys_create_dir,
    [SYS_REMOVE] = &sys_remove,
    [SYS_CREATE_VOLUME] = &sys_create_volume,
    [SYS_ENV_SET] = &sys_env_set,
    [SYS_ENV_GET] = &sys_env_get,
    [SYS_EXEC_PARTIAL] = &sys_exec_partial,
    [SYS_EXEC_PARTIAL_FINI] = &sys_exec_partial_fini,
    [SYS_GET_SELF_PID] = &sys_get_self_pid,
    [SYS_STREAM_WRITE] = &sys_stream_write,
    [SYS_STREAM_READ] = &sys_stream_read,
    [SYS_GET_PROC_INFO] = &sys_get_proc_info,
    [SYS_GET_DEVICE_INFO] = &sys_get_device_info,
    [SYS_GET_VOLUME_INFO] = &sys_get_volume_info,
    [SYS_VOLUME_DELETE] = &sys_volume_delete,
    [SYS_DATE_TIME] = &sys_date_time,
};

syscall_handler_func_t syscall_find_handler(int syscall_num) {
  if (!(syscall_num >= 0 &&
        syscall_num < (int)(sizeof(handler_table) / sizeof(handler_table[0])))) {
    return NULL;
  }

  return handler_table[syscall_num];
}