#include <libk/std.h>
#include <libk/string.h>
#include <mm/liballoc.h>
#include <proc/mail.h>
#include <proc/proc.h>
#include <proc/resource.h>
#include <proc/suspension_q.h>
#include <sys/debug.h>
#include <sys/smp.h>

bool proc_cleanup_resource_mail (struct proc_resource* resource, struct cpu** reschedule_cpu) {
  struct proc_mail* mail = &resource->u.mail;
  bool reschedule = PROC_NO_RESCHEDULE;

  spin_lock (&mail->resource->lock);

  if (mail->pending_mesg != NULL)
    free (mail->pending_mesg);

  mail->pending_mesg_size = 0;

  spin_lock (&mail->send_sq.lock);

  while (mail->send_sq.proc_list != NULL) {
    struct list_node_link* node = mail->send_sq.proc_list;
    struct proc_sq_entry* sq_entry = list_entry (node, struct proc_sq_entry, sq_link);
    struct proc* suspended_proc = sq_entry->proc;

    spin_unlock (&mail->send_sq.lock);
    spin_unlock (&mail->resource->lock);

    reschedule = reschedule || proc_sq_resume (suspended_proc, sq_entry, reschedule_cpu);

    spin_lock (&mail->resource->lock);
    spin_lock (&mail->send_sq.lock);
  }

  spin_unlock (&mail->send_sq.lock);

  spin_unlock (&mail->resource->lock);

  return reschedule;
}

bool proc_mail_send (struct proc* proc, struct proc_mail* mail, struct cpu** reschedule_cpu,
                     void* data, size_t data_size) {
  spin_lock (&mail->resource->lock);
  spin_lock (&mail->recv_sq.lock);

  /* if receiver available, hand off directly */
  struct list_node_link* node = mail->recv_sq.proc_list;

  if (node != NULL) {
    struct proc_sq_entry* sq_entry = list_entry (node, struct proc_sq_entry, sq_link);
    struct proc* resumed_proc = sq_entry->proc;

    spin_unlock (&mail->recv_sq.lock);
    spin_unlock (&mail->resource->lock);

    spin_lock (&proc->lock);

    if (resumed_proc->mail_recv_buffer != NULL) {
      size_t copy_size =
          (data_size < resumed_proc->mail_recv_size) ? data_size : resumed_proc->mail_recv_size;
      memcpy (resumed_proc->mail_recv_buffer, data, copy_size);

      resumed_proc->mail_recv_buffer = NULL;
      resumed_proc->mail_recv_size = 0;
    }

    spin_unlock (&proc->lock);

    return proc_sq_resume (resumed_proc, sq_entry, reschedule_cpu);
  }

  spin_unlock (&mail->recv_sq.lock);

  /* mail full */
  if (mail->pending_mesg != NULL) {
    return proc_sq_suspend (proc, &mail->send_sq, &mail->resource->lock, reschedule_cpu);
  }

  /* mail is empty and nobody is waiting */
  mail->pending_mesg = malloc (data_size);
  memcpy (mail->pending_mesg, data, data_size);
  mail->pending_mesg_size = data_size;

  spin_unlock (&mail->resource->lock);

  return PROC_NO_RESCHEDULE;
}

bool proc_mail_receive (struct proc* proc, struct proc_mail* mail, struct cpu** reschedule_cpu,
                        void* recv_buffer, size_t recv_size) {
  spin_lock (&proc->lock);
  proc->mail_recv_buffer = recv_buffer;
  proc->mail_recv_size = recv_size;
  spin_unlock (&proc->lock);

  spin_lock (&mail->resource->lock);

  /* consume mesg if available */
  if (mail->pending_mesg != NULL) {
    memcpy (recv_buffer, mail->pending_mesg, recv_size);
    free (mail->pending_mesg);
    mail->pending_mesg = NULL;
    mail->pending_mesg_size = 0;

    /* check for suspended sender */
    spin_lock (&mail->send_sq.lock);

    struct list_node_link* node = mail->send_sq.proc_list;

    if (node != NULL) {
      struct proc_sq_entry* sq_entry = list_entry (node, struct proc_sq_entry, sq_link);
      struct proc* resumed_proc = sq_entry->proc;

      spin_unlock (&mail->send_sq.lock);
      spin_unlock (&mail->resource->lock);

      return proc_sq_resume (resumed_proc, sq_entry, reschedule_cpu);
    }

    spin_unlock (&mail->send_sq.lock);
    spin_unlock (&mail->resource->lock);

    return PROC_NO_RESCHEDULE;
  }

  /* nothing to receive */
  return proc_sq_suspend (proc, &mail->recv_sq, &mail->resource->lock, reschedule_cpu);
}