#include <signal.h>
#include <logger.h>
#include <string.h>
#include <process.h>
#include <thread.h>
#include <kmalloc.h>
#include <interrupt.h>
#include <exec.h>

static inline
void _sighandler_wrapper(signal_handler_t handler)
{
  handler();
  asm volatile(
    "mov x8, #10" ENDL
    "svc 0"
    ::: "x8"
  );
}

static inline
void _sigkill_default_handler()
{
  thread_t *th = get_current();
  th->status = THREAD_STATUS_ZOMBIE;
}

void run_signal(int32_t SIGNAL)
{
  process_t *process = get_current()->process;
  process->current_signal = SIGNAL;
  LOG("run_signal"); LOG(process->sighandlers[SIGNAL]); DEBUG_SIGNAL(SIGNAL);

  if (!process->sighandlers[SIGNAL]) {
    switch (SIGNAL) {
    case SIGKILL:
      _sigkill_default_handler();
      break;
    default:
      LOG("No default handler for this signal"); DEBUG_SIGNAL(SIGNAL);
    }
    return;
  }

  DEBUG_SIGNAL(process->sighandlers[SIGNAL]);

  process->retregs = process->regs;
  process->regs = kmalloc(sizeof(trapframe_t));
  memcpy(process->regs, process->retregs, sizeof(trapframe_t));
  *process->regs = (trapframe_t){
    .x0 = (uint64_t)process->sighandlers[SIGNAL],
    .elr_el1 = (uint64_t)_sighandler_wrapper,
    .sp_el0 = ((uint64_t)process->sigstack + process->sigstack_size - 64),
  };

  disable_interrupt();
  process->current_signal = SIGNAL;
  process->sigstate[SIGNAL] = false;
  user_exec(process->regs);

  __builtin_unreachable();
}

void end_signal()
{
  DEBUG_SIGNAL("end_signal");
  process_t *process = get_current()->process;

  disable_interrupt();
  process->current_signal = 0x0;
  kfree(process->regs);
  process->regs = process->retregs;
  user_exec(process->regs);

  __builtin_unreachable();
}