#include <amd64/gdt.h>
#include <aux/elf.h>
#include <libk/list.h>
#include <libk/std.h>
#include <libk/string.h>
#include <limine/requests.h>
#include <mm/liballoc.h>
#include <mm/pmm.h>
#include <proc/proc.h>
#include <sync/spin_lock.h>
#include <sys/debug.h>

static atomic_int pids = 1;

struct proc* proc_from_elf (uint8_t* elf_contents) {
  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  struct proc* proc = malloc (sizeof (*proc));
  if (proc == NULL)
    return NULL;

  memset (proc, 0, sizeof (*proc));

  proc->pd.lock = SPIN_LOCK_INIT;
  proc->pd.cr3_paddr = mm_alloc_user_pd_phys ();
  if (proc->pd.cr3_paddr == 0) {
    free (proc);
    return NULL;
  }

  proc->pdata.kernel_stack = pmm_alloc (KSTACK_SIZE / PAGE_SIZE);
  if (proc->pdata.kernel_stack == PMM_ALLOC_ERR) {
    free (proc);
    return NULL;
  }
  uintptr_t kernel_stack = proc->pdata.kernel_stack;
  proc->pdata.kernel_stack += (uintptr_t)hhdm->offset + KSTACK_SIZE;

  proc->pdata.user_stack = pmm_alloc (USTACK_SIZE / PAGE_SIZE);
  if (proc->pdata.user_stack == PMM_ALLOC_ERR) {
    free (proc);
    pmm_free (kernel_stack, USTACK_SIZE / PAGE_SIZE);
    return NULL;
  }

  proc_map (proc, proc->pdata.user_stack, PROC_USTACK_TOP - USTACK_SIZE, USTACK_SIZE / PAGE_SIZE,
            MM_PG_USER | MM_PG_PRESENT | MM_PG_RW);

  struct elf_aux aux = proc_load_segments (proc, elf_contents);

  proc->pdata.regs.ss = GDT_UDATA | 0x03;
  proc->pdata.regs.rsp = (uint64_t)PROC_USTACK_TOP;
  proc->pdata.regs.rflags = 0x202;
  proc->pdata.regs.cs = GDT_UCODE | 0x03;
  proc->pdata.regs.rip = aux.entry;
  proc->lock = SPIN_LOCK_INIT;
  atomic_store (&proc->state, PROC_READY);
  proc->pid = atomic_fetch_add (&pids, 1);

  return proc;
}

void proc_cleanup (struct proc* proc) {
  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;

  struct list_node_link *mapping_link, *mapping_link_tmp;
  spin_lock (&proc->pd.lock);

  list_foreach (proc->mappings, mapping_link, mapping_link_tmp) {
    struct proc_mapping* mapping =
        list_entry (mapping_link, struct proc_mapping, proc_mappings_link);

    pmm_free (mapping->paddr, mapping->size / PAGE_SIZE);
    list_remove (proc->mappings, mapping_link);
    free (mapping);
  }

  spin_unlock (&proc->pd.lock);

  pmm_free (proc->pd.cr3_paddr, 1);

  pmm_free (proc->pdata.kernel_stack - (uintptr_t)hhdm->offset - KSTACK_SIZE,
            KSTACK_SIZE / PAGE_SIZE);
  pmm_free (proc->pdata.user_stack, USTACK_SIZE / PAGE_SIZE);

  free (proc);
}
