#include "mmap.h"
#include "page.h"
#include "threads/vaddr.h"
#include "threads/malloc.h"
#include "userprog/syscall.h"
#include "userprog/pagedir.h"
#include <stdio.h>

static unsigned mmap_hash (const struct hash_elem *e, void *aux);
static bool mmap_less (const struct hash_elem *a_, const struct hash_elem *b_,
                void *aux);
static void mmap_cleanup(struct hash_elem *e, void *aux);

/* Initializes the mmap table for the given thread, setting the mmap counter to
   0 and initializing the hash table. */
bool
mmap_init (struct thread *t)
{
  t->mmap_counter = 0;
  return hash_init (&t->mmap_files, mmap_hash, mmap_less, NULL);
}

struct mmap_entry *
mmap_get (mapid_t mapping)
{
  struct mmap_entry fake_mmap_entry;
  fake_mmap_entry.mapping = mapping;

  struct hash_elem *e
    = hash_find (&thread_current ()->mmap_files, &fake_mmap_entry.elem);

  if (e == NULL)
    return NULL;

  return hash_entry (e, struct mmap_entry, elem);
}

/* Inserts a new mmap entry into the mmap table for the current thread. Upage
   is the start address of the file data in the user VM. */
struct mmap_entry *
mmap_insert (struct file *file, void *upage)
{
  if (file == NULL || upage == NULL)
    return NULL;

  struct mmap_entry *mmap = malloc (sizeof (struct mmap_entry));
  if (mmap == NULL)
    return NULL;

  mmap->mapping = thread_current ()->mmap_counter++;
  mmap->file = file;
  mmap->upage = upage;

  hash_insert (&thread_current ()->mmap_files, &mmap->elem);
  return mmap;
}

/* Unmaps the given mmap entry from the current thread's mmap table. */
void
mmap_unmap (struct mmap_entry *mmap)
{
  if (mmap == NULL)
    return;

  /* Free all the pages associated with the mapping, writing back to the file
     if necessary. */
  off_t length = file_length (mmap->file);
  for (off_t ofs = 0; ofs < length; ofs += PGSIZE)
  {
    void *upage = mmap->upage + ofs;

    /* Get the SPT page entry for this page. */
    struct page_entry *page = page_get(upage);
    if (page == NULL)
      continue;

    /* Write the page back to the file if it is dirty. */
    if (pagedir_is_dirty (thread_current ()->pagedir, upage))
    {
      lock_acquire (&filesys_lock);
      file_write_at (mmap->file, upage, page->read_bytes, ofs);
      lock_release (&filesys_lock);
    }

    /* Remove the page from the supplemental page table. */
    hash_delete (&thread_current ()->pages, &page->elem);
  }

  file_close (mmap->file);
  free (mmap);
}

/* Destroys the mmap table for the current thread. Frees all the memory
   allocated for the mmap entries. */
void
mmap_destroy (void)
{
  hash_destroy (&thread_current ()->mmap_files, mmap_cleanup);
}

/* A hash function for the mmap table. Returns a hash for an entry, based on its
   mapping. */
static unsigned
mmap_hash (const struct hash_elem *e, void *aux UNUSED)
{
  return hash_entry (e, struct mmap_entry, elem)->mapping;
}

/* A comparator function for the mmap table. Compares two entries based on their
   mappings. */
static bool
mmap_less (const struct hash_elem *a_, const struct hash_elem *b_,
                void *aux UNUSED)
{
  const struct mmap_entry *a = hash_entry (a_, struct mmap_entry, elem);
  const struct mmap_entry *b = hash_entry (b_, struct mmap_entry, elem);

  return a->mapping < b->mapping;
}

/* Cleans up the mmap table for the current thread. Implicitly unmaps the mmap
   entry, freeing pages and writing back to the file if necessary. */
static void
mmap_cleanup (struct hash_elem *e, void *aux UNUSED)
{
  struct mmap_entry *mmap = hash_entry (e, struct mmap_entry, elem);
  mmap_unmap (mmap);
}