/*
   * Copyright (C) 2016 Eistec AB
   *
   * This file is subject to the terms and conditions of the GNU Lesser
   * General Public License v2.1. See the file LICENSE in the top level
   * directory for more details.
   */
  
  /**
   * @ingroup     sys_fs_constfs
   * @{
   *
   * @file
   * @brief       ConstFS implementation
   *
   * @author      Joakim Nohlgård <joakim.nohlgard@eistec.se>
   *
   * @}
   */
  
  /* Required for strnlen in string.h, when building with -std=c99 */
  #define _DEFAULT_SOURCE 1
  #include <stddef.h>
  #include <string.h>
  #include <unistd.h>
  #include <fcntl.h>
  #include <errno.h>
  
  #include "fs/constfs.h"
  #include "vfs.h"
  
  #define ENABLE_DEBUG (0)
  #include "debug.h"
  
  /* File system operations */
  static int constfs_mount(vfs_mount_t *mountp);
  static int constfs_umount(vfs_mount_t *mountp);
  static int constfs_unlink(vfs_mount_t *mountp, const char *name);
  static int constfs_stat(vfs_mount_t *mountp, const char *restrict name, struct stat *restrict buf);
  static int constfs_statvfs(vfs_mount_t *mountp, const char *restrict path, struct statvfs *restrict buf);
  
  /* File operations */
  static int constfs_close(vfs_file_t *filp);
  static int constfs_fstat(vfs_file_t *filp, struct stat *buf);
  static off_t constfs_lseek(vfs_file_t *filp, off_t off, int whence);
  static int constfs_open(vfs_file_t *filp, const char *name, int flags, mode_t mode, const char *abs_path);
  static ssize_t constfs_read(vfs_file_t *filp, void *dest, size_t nbytes);
  static ssize_t constfs_write(vfs_file_t *filp, const void *src, size_t nbytes);
  
  /* Directory operations */
  static int constfs_opendir(vfs_DIR *dirp, const char *dirname, const char *abs_path);
  static int constfs_readdir(vfs_DIR *dirp, vfs_dirent_t *entry);
  static int constfs_closedir(vfs_DIR *dirp);
  
  static const vfs_file_system_ops_t constfs_fs_ops = {
      .mount = constfs_mount,
      .umount = constfs_umount,
      .unlink = constfs_unlink,
      .statvfs = constfs_statvfs,
      .stat = constfs_stat,
  };
  
  static const vfs_file_ops_t constfs_file_ops = {
      .close = constfs_close,
      .fstat = constfs_fstat,
      .lseek = constfs_lseek,
      .open  = constfs_open,
      .read  = constfs_read,
      .write = constfs_write,
  };
  
  static const vfs_dir_ops_t constfs_dir_ops = {
      .opendir = constfs_opendir,
      .readdir = constfs_readdir,
      .closedir = constfs_closedir,
  };
  
  
  const vfs_file_system_t constfs_file_system = {
      .f_op = &constfs_file_ops,
      .fs_op = &constfs_fs_ops,
      .d_op = &constfs_dir_ops,
  };
  
  /**
   * @internal
   * @brief Fill a file information struct with information about the file
   * pointed to by @p fp
   *
   * @param[in]  fp     file to query
   * @param[out] buf    output buffer
   */
  static void _constfs_write_stat(const constfs_file_t *fp, struct stat *restrict buf);
  
  static int constfs_mount(vfs_mount_t *mountp)
  {
      /* perform any extra initialization here */
      (void) mountp; /* prevent warning: unused parameter */
      return 0;
  }
  
  static int constfs_umount(vfs_mount_t *mountp)
  {
      /* free resources and perform any clean up here */
      (void) mountp; /* prevent warning: unused parameter */
      return 0;
  }
  
  static int constfs_unlink(vfs_mount_t *mountp, const char *name)
  {
      /* Removing files is prohibited */
      (void) mountp; /* prevent warning: unused parameter */
      (void) name; /* prevent warning: unused parameter */
      return -EROFS;
  }
  
  static int constfs_stat(vfs_mount_t *mountp, const char *restrict name, struct stat *restrict buf)
  {
      (void) name;
      /* Fill out some information about this file */
      if (buf == NULL) {
          return -EFAULT;
      }
      constfs_t *fs = mountp->private_data;
      /* linear search through the files array */
      for (size_t i = 0; i < fs->nfiles; ++i) {
          DEBUG("constfs_stat ? \"%s\"\n", fs->files[i].path);
          if (strcmp(fs->files[i].path, name) == 0) {
              DEBUG("constfs_stat: Found :)\n");
              _constfs_write_stat(&fs->files[i], buf);
              buf->st_ino = i;
              return 0;
          }
      }
      DEBUG("constfs_stat: Not found :(\n");
      return -ENOENT;
  }
  
  static int constfs_statvfs(vfs_mount_t *mountp, const char *restrict path, struct statvfs *restrict buf)
  {
      (void) path;
      /* Fill out some information about this file system */
      if (buf == NULL) {
          return -EFAULT;
      }
      constfs_t *fs = mountp->private_data;
      /* clear out the stat buffer first */
      memset(buf, 0, sizeof(*buf));
      buf->f_bsize = sizeof(uint8_t); /* block size */
      buf->f_frsize = sizeof(uint8_t); /* fundamental block size */
      fsblkcnt_t f_blocks = 0;
      for (size_t i = 0; i < fs->nfiles; ++i) {
          f_blocks += fs->files[i].size;
      }
      buf->f_blocks = f_blocks;  /* Blocks total */
      buf->f_bfree = 0;          /* Blocks free */
      buf->f_bavail = 0;         /* Blocks available to non-privileged processes */
      buf->f_files = fs->nfiles; /* Total number of file serial numbers */
      buf->f_ffree = 0;          /* Total number of free file serial numbers */
      buf->f_favail = 0;         /* Number of file serial numbers available to non-privileged process */
      buf->f_fsid = 0;           /* File system id */
      buf->f_flag = (ST_RDONLY | ST_NOSUID); /* File system flags */
      buf->f_namemax = UINT8_MAX; /* Maximum file name length */
      return 0;
  }
  
  static int constfs_close(vfs_file_t *filp)
  {
      /* perform any necessary clean ups */
      (void) filp; /* prevent warning: unused parameter */
      return 0;
  }
  
  static int constfs_fstat(vfs_file_t *filp, struct stat *buf)
  {
      constfs_file_t *fp = filp->private_data.ptr;
      if (buf == NULL) {
          return -EFAULT;
      }
      _constfs_write_stat(fp, buf);
      return 0;
  }
  
  static off_t constfs_lseek(vfs_file_t *filp, off_t off, int whence)
  {
      constfs_file_t *fp = filp->private_data.ptr;
      switch (whence) {
          case SEEK_SET:
              break;
          case SEEK_CUR:
              off += filp->pos;
              break;
          case SEEK_END:
              off += fp->size;
              break;
          default:
              return -EINVAL;
      }
      if (off < 0) {
          /* the resulting file offset would be negative */
          return -EINVAL;
      }
      /* POSIX allows seeking past the end of the file, even with O_RDONLY */
      filp->pos = off;
      return off;
  }
  
  static int constfs_open(vfs_file_t *filp, const char *name, int flags, mode_t mode, const char *abs_path)
  {
      (void) mode;
      (void) abs_path;
      constfs_t *fs = filp->mp->private_data;
      DEBUG("constfs_open: %p, \"%s\", 0x%x, 0%03lo, \"%s\"\n", (void *)filp, name, flags, (unsigned long)mode, abs_path);
      /* We only support read access */
      if ((flags & O_ACCMODE) != O_RDONLY) {
          return -EROFS;
      }
      /* linear search through the files array */
      for (size_t i = 0; i < fs->nfiles; ++i) {
          DEBUG("constfs_open ? \"%s\"\n", fs->files[i].path);
          if (strcmp(fs->files[i].path, name) == 0) {
              DEBUG("constfs_open: Found :)\n");
              filp->private_data.ptr = (void *)&fs->files[i];
              return 0;
          }
      }
      DEBUG("constfs_open: Not found :(\n");
      return -ENOENT;
  }
  
  static ssize_t constfs_read(vfs_file_t *filp, void *dest, size_t nbytes)
  {
      constfs_file_t *fp = filp->private_data.ptr;
      DEBUG("constfs_read: %p, %p, %lu\n", (void *)filp, dest, (unsigned long)nbytes);
      if ((size_t)filp->pos >= fp->size) {
          /* Current offset is at or beyond end of file */
          return 0;
      }
  
      if (nbytes > (fp->size - filp->pos)) {
          nbytes = fp->size - filp->pos;
      }
      memcpy(dest, fp->data + filp->pos, nbytes);
      DEBUG("constfs_read: read %d bytes\n", nbytes);
      filp->pos += nbytes;
      return nbytes;
  }
  
  static ssize_t constfs_write(vfs_file_t *filp, const void *src, size_t nbytes)
  {
      DEBUG("constfs_write: %p, %p, %lu\n", (void *)filp, src, (unsigned long)nbytes);
      /* Read only file system */
      DEBUG("constfs_write: read only FS\n");
      /* prevent warning: unused parameter */
      (void) filp;
      (void) src;
      (void) nbytes;
      return -EBADF;
  }
  
  static int constfs_opendir(vfs_DIR *dirp, const char *dirname, const char *abs_path)
  {
      (void) abs_path;
      DEBUG("constfs_opendir: %p, \"%s\", \"%s\"\n", (void *)dirp, dirname, abs_path);
      if (strncmp(dirname, "/", 2) != 0) {
          /* We keep it simple and only support a flat file system, only a root directory */
          return -ENOENT;
      }
      dirp->private_data.value = 0;
      return 0;
  }
  
  static int constfs_readdir(vfs_DIR *dirp, vfs_dirent_t *entry)
  {
      DEBUG("constfs_readdir: %p, %p\n", (void *)dirp, (void *)entry);
      constfs_t *fs = dirp->mp->private_data;
      int filenum = dirp->private_data.value;
      if ((size_t)filenum >= fs->nfiles) {
          /* End of stream */
          return 0;
      }
      const constfs_file_t *fp = &fs->files[filenum];
      if (fp->path == NULL) {
          return -EIO;
      }
      size_t len = strnlen(fp->path, VFS_NAME_MAX + 1);
      if (len > VFS_NAME_MAX) {
          /* name does not fit in vfs_dirent_t buffer */
          /* skipping past the broken entry */
          ++filenum;
          dirp->private_data.value = filenum;
          return -EAGAIN;
      }
      /* copy the string, including terminating null */
      memcpy(&entry->d_name[0], fp->path, len + 1);
      entry->d_ino = filenum;
      ++filenum;
      dirp->private_data.value = filenum;
      return 1;
  }
  
  static int constfs_closedir(vfs_DIR *dirp)
  {
      /* Just an example, it's not necessary to define closedir if there is
       * nothing to clean up */
      (void) dirp;
      return 0;
  }
  
  static void _constfs_write_stat(const constfs_file_t *fp, struct stat *restrict buf)
  {
      /* clear out the stat buffer first */
      memset(buf, 0, sizeof(*buf));
      buf->st_nlink = 1;
      buf->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH;
      buf->st_size = fp->size;
      buf->st_blocks = fp->size;
      buf->st_blksize = sizeof(uint8_t);
  }