#include <sys/mman.h>
#include <sys/inotify.h>
#include <errno.h>
#include <unistd.h>
#include <limits.h> // for NAME_MAX

internal
i32 os_page_size()
{
  return getpagesize();
}

internal
bool os_open_and_map_file(const char *fname, App_State &app)
{
  FILE *file = fopen(fname, "rb");
  if (!file) {
    fprintf(stderr, "Failed to open file '%s' for reading: %s (%d)\n", fname, strerror(errno), errno);
    return false;
  }
  int fd = fileno(file);
  size_t fsize = file_size(file);

  void *fmem = mmap(0, fsize, PROT_READ, MAP_SHARED_VALIDATE, fd, 0);
  if (!fmem) {
    fprintf(stderr, "Failed to open file %s\n", fname);
    return false;
  }

  app.inspected_file.name = str8(fname);
  app.inspected_file.stream = file;
  app.inspected_file.size = fsize;
  app.inspected_file.mem = reinterpret_cast<u8*>(fmem);

  return true;
}

internal
void os_unmap_file(u8 *&mem, u64 size)
{
  if (mem) munmap(mem, size);
  mem = nullptr;
}

internal
void os_start_file_watch(const char *fname, App_State &app)
{
  int inot = inotify_init1(IN_NONBLOCK);
  if (inot == -1)
    fprintf(stderr, "Failed to init inotify: %s (%d)\n", strerror(errno), errno);
  if (inotify_add_watch(inot, fname, IN_MODIFY) == -1)
    fprintf(stderr, "Failed to add inotify watch: %s (%d)\n", strerror(errno), errno);

  app.inspected_file.inot = inot;
}

internal
void os_stop_file_watch(App_State &app)
{
  if (app.inspected_file.inot != -1) close(app.inspected_file.inot);
  app.inspected_file.inot = -1;
}

internal 
void *os_reserve(u64 size)
{
  void *mem = mmap(0, size, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
  if (UNLIKELY(mem == MAP_FAILED)) {
    fprintf(stderr, "Error reserving memory: %s (%d)\n", strerror(errno), errno);
  }
  return mem;
}

internal 
void os_release(void *mem, u64 size)
{
  munmap(mem, size);
}

internal 
b32x os_commit(void *addr, u64 size)
{
  b32x err = mprotect(addr, size, PROT_READ|PROT_WRITE);
  if (UNLIKELY(err)) {
    fprintf(stderr, "Error committing memory: %s (%d)\n", strerror(errno), errno);
  }
  return err == 0;
}