#include <aux/compiler.h>
#include <libk/assert.h>
#include <libk/std.h>
#include <limine/requests.h>
#include <m/status.h>
#include <m/syscall_defs.h>
#include <mm/pmm.h>
#include <proc/mem.h>
#include <proc/mutex.h>
#include <proc/proc.h>
#include <proc/resource.h>
#include <sync/spin_lock.h>
#include <sys/debug.h>
#include <sys/mm.h>
#include <sys/proc.h>
#include <syscall/syscall.h>

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

static void* sys_get_user_buffer (struct proc* proc, uintptr_t uvaddr, size_t size) {
  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
  spin_lock_ctx_t ctxprpd;

  spin_lock (&proc->pd->lock, &ctxprpd);

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

  uintptr_t out_paddr = mm_v2p (proc->pd, uvaddr, 0);

  spin_unlock (&proc->pd->lock, &ctxprpd);

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

  return (void*)out_kvaddr;
}

/* int quit (void) */
DEFINE_SYSCALL (sys_quit) {
  proc_kill (proc);
  return ST_OK;
}

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

/* int map (int mem_rid, int vis, uintptr_t vaddr, uint32_t flags) */
DEFINE_SYSCALL (sys_map) {
  spin_lock_ctx_t ctxrs;

  int mem_rid = (int)a1;
  int vis = (int)a2;
  uintptr_t vaddr = a3;
  uint32_t flags = (uint32_t)a4;

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

  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
    return -ST_BAD_RESOURCE;

  struct proc_resource* mem_resource = proc_find_resource (proc, mem_rid, vis);

  if (mem_resource == NULL) {
    return -ST_NOT_FOUND;
  }

  spin_lock (&mem_resource->lock, &ctxrs);

  if (mem_resource->type != PR_MEM) {
    spin_unlock (&mem_resource->lock, &ctxrs);
    return -ST_BAD_RESOURCE;
  }

  uintptr_t paddr = mem_resource->u.mem.paddr;
  size_t pages = mem_resource->u.mem.pages;

  spin_unlock (&mem_resource->lock, &ctxrs);

  return proc_map (proc, paddr, vaddr, pages, flags) ? ST_OK : -ST_OOM_ERROR;
}

/* int unmap (uintptr_t vaddr, size_t pages) */
DEFINE_SYSCALL (sys_unmap) {
  uintptr_t vaddr = a1;
  size_t pages = (size_t)a2;

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

  return proc_unmap (proc, vaddr, pages) ? ST_OK : -ST_OOM_ERROR;
}

/* int create_mem (int rid, int vis, size_t pages) */
DEFINE_SYSCALL (sys_create_mem) {
  int rid = (int)a1;
  int vis = (int)a2;
  size_t pages = (size_t)a3;

  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
    return -ST_BAD_RESOURCE;

  if (pages == 0)
    return ST_OK;

  int rid1 = rid < 0 ? atomic_fetch_add (&proc->resources->sys_rids, 1) : rid;

  struct proc_resource_mem_init mem_init = {.managed = false, .pages = pages};
  struct proc_resource* mem_resource = proc_create_resource (proc, rid1, PR_MEM, vis, &mem_init);

  if (mem_resource == NULL)
    return -ST_OOM_ERROR;

  return mem_resource->rid;
}

/* int unlink_mem (int rid, int vis, size_t pages) */
DEFINE_SYSCALL (sys_unlink_mem) {
  spin_lock_ctx_t ctxrs;

  int rid = (int)a1;
  int vis = (int)a2;
  size_t pages = (size_t)a3;

  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
    return -ST_BAD_RESOURCE;

  struct proc_resource* mem_resource = proc_find_resource (proc, rid, vis);

  if (mem_resource == NULL)
    return -ST_NOT_FOUND;

  spin_lock (&mem_resource->lock, &ctxrs);

  if (mem_resource->type != PR_MEM) {
    spin_unlock (&mem_resource->lock, &ctxrs);
    return -ST_BAD_RESOURCE;
  }

  mem_resource->u.mem.alive_pages -= pages;
  if (mem_resource->u.mem.alive_pages < 0) {
    spin_unlock (&mem_resource->lock, &ctxrs);
    proc_drop_resource (proc, mem_resource, true);
  }

  return ST_OK;
}

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

  struct cpu* cpu = proc->cpu;

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

  DEBUG ("new=%p\n", new);

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

  int pid = new->pid;

  proc_register (new, cpu);

  return pid;
}

/* int sched (void) */
DEFINE_SYSCALL (sys_sched) {
  proc_sched ();
  return ST_OK;
}

/* int create_mutex (int mutex_rid, int vis) */
DEFINE_SYSCALL (sys_create_mutex) {
  int mutex_rid = (int)a1;
  int vis = (int)a2;

  if (mutex_rid < 0)
    return -ST_BAD_RESOURCE;

  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
    return -ST_BAD_RESOURCE;

  struct proc_resource* mutex_resource =
      proc_create_resource (proc, mutex_rid, PR_MUTEX, vis, NULL);

  if (mutex_resource == NULL)
    return -ST_OOM_ERROR;

  return mutex_resource->rid;
}

/* int unlink_mutex (int mutex_rid, int vis) */
DEFINE_SYSCALL (sys_unlink_mutex) {
  int mutex_rid = (int)a1;
  int vis = (int)a2;

  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
    return -ST_BAD_RESOURCE;

  struct proc_resource* mutex_resource = proc_find_resource (proc, mutex_rid, vis);

  if (mutex_resource == NULL)
    return -ST_NOT_FOUND;

  proc_drop_resource (proc, mutex_resource, true);

  return ST_OK;
}

/* int lock_mutex (int mutex_rid, int vis) */
DEFINE_SYSCALL (sys_lock_mutex) {
  int mutex_rid = (int)a1;
  int vis = (int)a2;

  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
    return -ST_BAD_RESOURCE;

  struct proc_resource* mutex_resource = proc_find_resource (proc, mutex_rid, vis);

  if (mutex_resource == NULL)
    return -ST_NOT_FOUND;

  DEBUG ("locking %d\n", proc->pid);
  proc_mutex_lock (proc, &mutex_resource->u.mutex);

  return ST_OK;
}

/* int unlock_mutex (int mutex_rid, int vis) */
DEFINE_SYSCALL (sys_unlock_mutex) {
  int mutex_rid = (int)a1;
  int vis = (int)a2;

  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
    return -ST_BAD_RESOURCE;

  struct proc_resource* mutex_resource = proc_find_resource (proc, mutex_rid, vis);

  if (mutex_resource == NULL)
    return -ST_NOT_FOUND;

  DEBUG ("unlocking %d\n", proc->pid);
  return proc_mutex_unlock (proc, &mutex_resource->u.mutex) ? ST_OK : -ST_PERMISSION_ERROR;
}

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_SCHED] = &sys_sched,
    [SYS_CREATE_MEM] = &sys_create_mem,
    [SYS_UNLINK_MEM] = &sys_unlink_mem,
    [SYS_CREATE_MUTEX] = &sys_create_mutex,
    [SYS_UNLINK_MUTEX] = &sys_unlink_mutex,
    [SYS_LOCK_MUTEX] = &sys_lock_mutex,
    [SYS_UNLOCK_MUTEX] = &sys_unlock_mutex,
};

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];
}