/*
 * Copyright 2009, Raghuram Nagireddy <raghuram87@gmail.com>.
 * Distributed under the terms of the MIT License.
 */

#define FUSE_USE_VERSION 27

#include <fuse/fuse.h>
#include <stdio.h>
#include <stdlib.h>
#include <syslog.h>
#include <unistd.h>

#include "fssh.h"

#include "driver_settings.h"
#include "external_commands.h"
#include "fd.h"
#include "fssh_dirent.h"
#include "fssh_errno.h"
#include "fssh_errors.h"
#include "fssh_fcntl.h"
#include "fssh_fs_info.h"
#include "fssh_module.h"
#include "fssh_node_monitor.h"
#include "fssh_stat.h"
#include "fssh_string.h"
#include "fssh_type_constants.h"
#include "module.h"
#include "syscalls.h"
#include "vfs.h"


extern fssh_module_info *modules[];

extern fssh_file_system_module_info gRootFileSystem;

namespace FSShell {

const char* kMountPoint = "/myfs";

static mode_t sUmask = 0022;

#define PRINTD(x) if (gIsDebug) fprintf(stderr, x)

bool gIsDebug = false;

static fssh_status_t
init_kernel()
{
        fssh_status_t error;

        // init module subsystem
        error = module_init(NULL);
        if (error != FSSH_B_OK) {
                fprintf(stderr, "module_init() failed: %s\n", fssh_strerror(error));
                return error;
        }

        // init driver settings
        error = driver_settings_init();
        if (error != FSSH_B_OK) {
                fprintf(stderr, "initializing driver settings failed: %s\n",
                        fssh_strerror(error));
                return error;
        }

        // register built-in modules, i.e. the rootfs and the client FS
        register_builtin_module(&gRootFileSystem.info);
        for (int i = 0; modules[i]; i++)
                register_builtin_module(modules[i]);

        // init VFS
        error = vfs_init(NULL);
        if (error != FSSH_B_OK) {
                fprintf(stderr, "initializing VFS failed: %s\n", fssh_strerror(error));
                return error;
        }

        // init kernel IO context
        gKernelIOContext = (io_context*)vfs_new_io_context(NULL);
        if (!gKernelIOContext) {
                fprintf(stderr, "creating IO context failed!\n");
                return FSSH_B_NO_MEMORY;
        }

        // mount root FS
        fssh_dev_t rootDev = _kern_mount("/", NULL, "rootfs", 0, NULL, 0);
        if (rootDev < 0) {
                fprintf(stderr, "mounting rootfs failed: %s\n", fssh_strerror(rootDev));
                return rootDev;
        }

        // set cwd to "/"
        error = _kern_setcwd(-1, "/");
        if (error != FSSH_B_OK) {
                fprintf(stderr, "setting cwd failed: %s\n", fssh_strerror(error));
                return error;
        }

        // create mount point for the client FS
        error = _kern_create_dir(-1, kMountPoint, 0775);
        if (error != FSSH_B_OK) {
                fprintf(stderr, "creating mount point failed: %s\n",
                        fssh_strerror(error));
                return error;
        }

        return FSSH_B_OK;
}


static void
fromFsshStatToStat(struct fssh_stat* f_stbuf, struct stat* stbuf)
{
        stbuf->st_dev = f_stbuf->fssh_st_dev;
        stbuf->st_ino = f_stbuf->fssh_st_ino;
        stbuf->st_mode = f_stbuf->fssh_st_mode;
        stbuf->st_nlink = f_stbuf->fssh_st_nlink;
        stbuf->st_uid = f_stbuf->fssh_st_uid;
        stbuf->st_gid = f_stbuf->fssh_st_gid;
        stbuf->st_rdev = f_stbuf->fssh_st_rdev;
        stbuf->st_size = f_stbuf->fssh_st_size;
        stbuf->st_blksize = f_stbuf->fssh_st_blksize;
        stbuf->st_blocks = f_stbuf->fssh_st_blocks;
        stbuf->st_atime = f_stbuf->fssh_st_atime;
        stbuf->st_mtime = f_stbuf->fssh_st_mtime;
        stbuf->st_ctime = f_stbuf->fssh_st_ctime;
}

#define _ERR(x) (-1 * fssh_to_host_error(x))


// pragma mark - FUSE functions


int
fuse_getattr(const char* path, struct stat* stbuf)
{
        PRINTD("##getattr\n");
        struct fssh_stat f_stbuf;
        fssh_status_t status = _kern_read_stat(-1, path, false, &f_stbuf,
                        sizeof(f_stbuf));
        fromFsshStatToStat(&f_stbuf, stbuf);
        if (gIsDebug)
                printf("GETATTR returned: %d\n", status);
        return _ERR(status);
}


static int
fuse_access(const char* path, int mask)
{
        PRINTD("##access\n");
        return _ERR(_kern_access(path, mask));
}


static int
fuse_readlink(const char* path, char* buffer, size_t size)
{
        PRINTD("##readlink\n");
        fssh_size_t n_size = size - 1;
        fssh_status_t st = _kern_read_link(-1, path, buffer, &n_size);
        if (st >= FSSH_B_OK)
                buffer[n_size] = '\0';
        return _ERR(st);
}


static int
fuse_readdir(const char* path, void* buf, fuse_fill_dir_t filler,
        off_t offset, struct fuse_file_info* fi)
{
        PRINTD("##readdir\n");
        int dfp = _kern_open_dir(-1, path);
        if (dfp < FSSH_B_OK)
                return _ERR(dfp);

        fssh_ssize_t entriesRead = 0;
        struct fssh_stat f_st;
        struct stat st;
        char buffer[sizeof(fssh_dirent) + FSSH_B_FILE_NAME_LENGTH];
        fssh_dirent* dirEntry = (fssh_dirent*)buffer;
        while ((entriesRead = _kern_read_dir(dfp, dirEntry,
                        sizeof(buffer), 1)) == 1) {
                fssh_memset(&st, 0, sizeof(st));
                fssh_memset(&f_st, 0, sizeof(f_st));
                fssh_status_t status = _kern_read_stat(dfp, dirEntry->d_name,
                        false, &f_st, sizeof(f_st));
                if (status >= FSSH_B_OK) {
                        fromFsshStatToStat(&f_st, &st);
                        if (filler(buf, dirEntry->d_name, &st, 0))
                                break;
                }
        }
        _kern_close(dfp);
        //TODO: check _kern_close
        return 0;
}


static int
fuse_mknod(const char* path, mode_t mode, dev_t rdev)
{
        PRINTD("##mknod\n");
        if (S_ISREG(mode)) {
                int fd = _kern_open(-1, path,
                        FSSH_O_CREAT | FSSH_O_EXCL | FSSH_O_WRONLY, mode);
                if (fd >= FSSH_B_OK)
                        return _ERR(_kern_close(fd));
                return _ERR(fd);
        } else if (S_ISFIFO(mode))
                return _ERR(FSSH_EINVAL);
        else
                return _ERR(FSSH_EINVAL);
}


static int
fuse_mkdir(const char* path, mode_t mode)
{
        PRINTD("##mkdir\n");
        return _ERR(_kern_create_dir(-1, path, mode));
}


static int
fuse_symlink(const char* from, const char* to)
{
        PRINTD("##symlink\n");
        return _ERR(_kern_create_symlink(-1, to, from,
                FSSH_S_IRWXU | FSSH_S_IRWXG | FSSH_S_IRWXO));
}


static int
fuse_unlink(const char* path)
{
        PRINTD("##unlink\n");
        return _ERR(_kern_unlink(-1, path));
}


static int
fuse_rmdir(const char* path)
{
        PRINTD("##rmdir\n");
        return _ERR(_kern_remove_dir(-1, path));
}


static int
fuse_rename(const char* from, const char* to)
{
        PRINTD("##rename\n");
        return _ERR(_kern_rename(-1, from, -1, to));
}


static int
fuse_link(const char* from, const char* to)
{
        PRINTD("##link\n");
        return _ERR(_kern_create_link(to, from));
}


static int
fuse_chmod(const char* path, mode_t mode)
{
        PRINTD("##chmod\n");
        fssh_struct_stat st;
        st.fssh_st_mode = mode;
        return _ERR(_kern_write_stat(-1, path, false, &st, sizeof(st),
                        FSSH_B_STAT_MODE));
}


static int
fuse_chown(const char* path, uid_t uid, gid_t gid)
{
        PRINTD("##chown\n");
        fssh_struct_stat st;
        st.fssh_st_uid = uid;
        st.fssh_st_gid = gid;
        return _ERR(_kern_write_stat(-1, path, false, &st, sizeof(st),
                        FSSH_B_STAT_UID|FSSH_B_STAT_GID));
}


static int
fuse_open(const char* path, struct fuse_file_info* fi)
{
        PRINTD("##open\n");
        // TODO: Do we have a syscall similar to the open syscall in linux which
        // takes only two args: path and flags with no mask/perms?
        int fd = _kern_open(-1, path, fi->flags,
                (FSSH_S_IRWXU | FSSH_S_IRWXG | FSSH_S_IRWXO) & ~sUmask);
        _kern_close(fd);
        if (fd < FSSH_B_OK)
                return _ERR(fd);
        else
                return 0;
}


static int
fuse_read(const char* path, char* buf, size_t size, off_t offset,
        struct fuse_file_info* fi)
{
        PRINTD("##read\n");
        int fd = _kern_open(-1, path, FSSH_O_RDONLY,
                (FSSH_S_IRWXU | FSSH_S_IRWXG | FSSH_S_IRWXO) & ~sUmask);
        if (fd < FSSH_B_OK)
                return _ERR(fd);

        int res = _kern_read(fd, offset, buf, size);
        _kern_close(fd);
        if (res < FSSH_B_OK)
                res = _ERR(res);
        return res;
}


static int
fuse_write(const char* path, const char* buf, size_t size, off_t offset,
        struct fuse_file_info* fi)
{
        PRINTD("##write\n");
        int fd = _kern_open(-1, path, FSSH_O_WRONLY,
                (FSSH_S_IRWXU | FSSH_S_IRWXG | FSSH_S_IRWXO) & ~sUmask);
        if (fd < FSSH_B_OK)
                return _ERR(fd);

        int res = _kern_write(fd, offset, buf, size);
        _kern_close(fd);
        if (res < FSSH_B_OK)
                res = _ERR(res);
        return res;
}


static int
fuse_truncate(const char *path, off_t off)
{
        PRINTD("##truncate\n");

        struct fssh_stat st;
        st.fssh_st_size = off;
        fssh_status_t res = _kern_write_stat(-1, path, true, &st, sizeof(st), FSSH_B_STAT_SIZE);
        if (res < FSSH_B_OK)
                return _ERR(res);
        return 0;
}


static void
fuse_destroy(void* priv_data)
{
        _kern_sync();
}


static fssh_dev_t
get_volume_id()
{
        struct fssh_stat st;
        fssh_status_t error = _kern_read_stat(-1, kMountPoint, false, &st,
                sizeof(st));
        if (error != FSSH_B_OK)
                return error;
        return st.fssh_st_dev;
}


static int
fuse_statfs(const char *path __attribute__((unused)),
                            struct statvfs *sfs)
{
        PRINTD("##statfs\n");

        fssh_dev_t volumeID = get_volume_id();
        if (volumeID < 0)
                return _ERR(volumeID);

        fssh_fs_info info;
        fssh_status_t status = _kern_read_fs_info(volumeID, &info);
        if (status != FSSH_B_OK)
                return _ERR(status);

        sfs->f_bsize = sfs->f_frsize = info.block_size;
        sfs->f_blocks = info.total_blocks;
        sfs->f_bavail = sfs->f_bfree = info.free_blocks;

        return 0;
}


struct fuse_operations gFUSEOperations;


static void
initialiseFuseOps(struct fuse_operations* fuseOps)
{
        fuseOps->getattr        = fuse_getattr;
        fuseOps->access         = fuse_access;
        fuseOps->readlink       = fuse_readlink;
        fuseOps->readdir        = fuse_readdir;
        fuseOps->mknod          = fuse_mknod;
        fuseOps->mkdir          = fuse_mkdir;
        fuseOps->symlink        = fuse_symlink;
        fuseOps->unlink         = fuse_unlink;
        fuseOps->rmdir          = fuse_rmdir;
        fuseOps->rename         = fuse_rename;
        fuseOps->link           = fuse_link;
        fuseOps->chmod          = fuse_chmod;
        fuseOps->chown          = fuse_chown;
        fuseOps->truncate       = fuse_truncate;
        fuseOps->utimens        = NULL;
        fuseOps->open           = fuse_open;
        fuseOps->read           = fuse_read;
        fuseOps->write          = fuse_write;
        fuseOps->statfs         = fuse_statfs;
        fuseOps->release        = NULL;
        fuseOps->fsync          = NULL;
        fuseOps->destroy        = fuse_destroy;
}


static int
mount_volume(const char* device, const char* mntPoint, const char* fsName)
{
        // Mount the volume in the root FS.
        fssh_dev_t fsDev = _kern_mount(kMountPoint, device, fsName, 0, NULL, 0);
        if (fsDev < 0) {
                fprintf(stderr, "Error: Mounting FS failed: %s\n",
                        fssh_strerror(fsDev));
                return 1;
        }

        if (!gIsDebug) {
                bool isErr = false;
                fssh_dev_t volumeID = get_volume_id();
                if (volumeID < 0)
                        isErr = true;
                fssh_fs_info info;
                if (!isErr) {
                        fssh_status_t status = _kern_read_fs_info(volumeID, &info);
                        if (status != FSSH_B_OK)
                                isErr = true;
                }
                syslog(LOG_INFO, "Mounted %s (%s) to %s",
                        device,
                        isErr ? "unknown" : info.volume_name,
                        mntPoint);
        }
        
        return 0;
}


static int
unmount_volume(const char* device, const char* mntPoint)
{
        // Unmount the volume again.
        // Avoid a "busy" vnode.
        _kern_setcwd(-1, "/");
        fssh_status_t error = _kern_unmount(kMountPoint, 0);
        if (error != FSSH_B_OK) {
                if (gIsDebug)
                        fprintf(stderr, "Error: Unmounting FS failed: %s\n",
                                fssh_strerror(error));
                else
                        syslog(LOG_INFO, "Error: Unmounting FS failed: %s",
                                fssh_strerror(error));
                return 1;
        }

        if (!gIsDebug)
                syslog(LOG_INFO, "UnMounted %s from %s", device, mntPoint);
        
        return 0;
}


static int
fssh_fuse_session(const char* device, const char* mntPoint, const char* fsName,
        struct fuse_args& fuseArgs)
{
        int ret;
        
        ret = mount_volume(device, mntPoint, fsName);
        if (ret != 0)
                return ret;
        
        if (getuid() == 0 && geteuid() == 0 && getgid() == 0 && getegid() == 0) {
                // only add FUSE options when user is root

                char* fuseOptions = NULL;

                // default FUSE options
                char* fsNameOption = NULL;
                if (fuse_opt_add_opt(&fuseOptions, "allow_other") < 0
                        || asprintf(&fsNameOption, "fsname=%s", device) < 0
                        || fuse_opt_add_opt(&fuseOptions, fsNameOption) < 0) {
                        unmount_volume(device, mntPoint);
                        return 1;
                }

                struct stat sbuf;
                if ((stat(device, &sbuf) == 0) && S_ISBLK(sbuf.st_mode)) {
                        int blkSize = 512;
                        fssh_dev_t volumeID = get_volume_id();
                        if (volumeID >= 0) {
                                fssh_fs_info info;
                                if (_kern_read_fs_info(volumeID, &info) == FSSH_B_OK)
                                        blkSize = info.block_size;
                        }

                        char* blkSizeOption = NULL;
                        if (fuse_opt_add_opt(&fuseOptions, "blkdev") < 0
                                || asprintf(&blkSizeOption, "blksize=%i", blkSize) < 0
                                || fuse_opt_add_opt(&fuseOptions, blkSizeOption) < 0) {
                                unmount_volume(device, mntPoint);
                                return 1;
                        }
                }

                if (fuse_opt_add_arg(&fuseArgs, "-o") < 0
                        || fuse_opt_add_arg(&fuseArgs, fuseOptions) < 0) {
                        unmount_volume(device, mntPoint);
                        return 1;
                }
        }

        // Run the fuse_main() loop.
        if (fuse_opt_add_arg(&fuseArgs, "-s") < 0) {
                unmount_volume(device, mntPoint);
                return 1;
        }

        initialiseFuseOps(&gFUSEOperations);

        int res = fuse_main(fuseArgs.argc, fuseArgs.argv, &gFUSEOperations, NULL);

        ret = unmount_volume(device, mntPoint);
        if (ret != 0)
                return ret;

        return res;
}


}       // namespace FSShell


using namespace FSShell;


static void
print_usage_and_exit(const char* binName)
{
        fprintf(stderr,"Usage: %s [-d] <device> <mount point>\n", binName);
        exit(1);
}


struct FsConfig {
        const char* device;
        const char* mntPoint;
};


enum {
        KEY_DEBUG,
        KEY_HELP
};


static int
process_options(void* data, const char* arg, int key, struct fuse_args* outArgs)
{
        struct FsConfig* config = (FsConfig*) data;

        switch (key) {
                case FUSE_OPT_KEY_NONOPT:
                        if (!config->device) {
                                config->device = arg;
                                return 0;
                                        // don't pass the device path to fuse_main()
                        } else if (!config->mntPoint)
                                config->mntPoint = arg;
                        else
                                print_usage_and_exit(outArgs->argv[0]);
                        break;
                case KEY_DEBUG:
                        gIsDebug = true;
                        break;
                case KEY_HELP:
                        print_usage_and_exit(outArgs->argv[0]);
        }

        return 1;
}


int
main(int argc, char* argv[])
{
        struct fuse_args fuseArgs = FUSE_ARGS_INIT(argc, argv);
        struct FsConfig config;
        memset(&config, 0, sizeof(config));
        const struct fuse_opt fsOptions[] = {
                FUSE_OPT_KEY("uhelper=",        FUSE_OPT_KEY_DISCARD),
                        // fuse_main() throws an error about this unknown option
                        // TODO: do not use fuse_main to mount filesystem, instead use
                        // fuse_mount, fuse_new, fuse_set_signal_handlers and fuse_loop
                FUSE_OPT_KEY("-d",                      KEY_DEBUG),
                FUSE_OPT_KEY("-h",                      KEY_HELP),
                FUSE_OPT_KEY("--help",          KEY_HELP),
                FUSE_OPT_END
        };

        if (fuse_opt_parse(&fuseArgs, &config, fsOptions, process_options) < 0)
                return 1;

        if (!config.mntPoint)
                print_usage_and_exit(fuseArgs.argv[0]);

        if (!modules[0]) {
                fprintf(stderr, "Error: Couldn't find FS module!\n");
                return 1;
        }

        fssh_status_t error = init_kernel();
        if (error != FSSH_B_OK) {
                fprintf(stderr, "Error: Initializing kernel failed: %s\n",
                        fssh_strerror(error));
                return error;
        }

        const char* fsName = modules[0]->name;
        return fssh_fuse_session(config.device, config.mntPoint, fsName, fuseArgs);
}