/* retoor <retoor@molodetz.nl> */

#define FUSE_USE_VERSION 31
#define _GNU_SOURCE

#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <fuse3/fuse.h>
#include "operations.h"
#include "webdav.h"
#include "cache.h"
#include "utils.h"

static webdav_context_t *g_ctx = NULL;

static webdav_context_t *get_context(void) {
    return g_ctx;
}

static int fusedav_getattr(const char *path, struct stat *stbuf,
                           struct fuse_file_info *fi) {
    (void)fi;

    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    memset(stbuf, 0, sizeof(struct stat));

    if (path_is_root(path)) {
        stbuf->st_mode = S_IFDIR | 0755;
        stbuf->st_nlink = 2;
        stbuf->st_uid = getuid();
        stbuf->st_gid = getgid();
        return 0;
    }

    return webdav_get_stat(ctx, path, stbuf);
}

static int fusedav_readdir(const char *path, void *buf,
                           fuse_fill_dir_t filler,
                           off_t offset, struct fuse_file_info *fi,
                           enum fuse_readdir_flags flags) {
    (void)offset;
    (void)fi;
    (void)flags;

    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    filler(buf, ".", NULL, 0, 0);
    filler(buf, "..", NULL, 0, 0);

    dir_listing_t listing = {0};
    int result = webdav_list_directory(ctx, path, &listing);

    if (result != 0) {
        return result;
    }

    for (int i = 0; i < listing.count; i++) {
        struct stat st = {0};
        st.st_mode = listing.entries[i].is_directory ?
                     (S_IFDIR | 0755) : (S_IFREG | 0644);
        st.st_size = listing.entries[i].size;
        st.st_mtime = listing.entries[i].mtime;
        st.st_atime = listing.entries[i].mtime;
        st.st_ctime = listing.entries[i].mtime;
        st.st_uid = getuid();
        st.st_gid = getgid();
        st.st_nlink = listing.entries[i].is_directory ? 2 : 1;

        if (filler(buf, listing.entries[i].name, &st, 0, 0) != 0) {
            break;
        }
    }

    for (int i = 0; i < listing.count; i++) {
        free(listing.entries[i].name);
    }
    free(listing.entries);

    return 0;
}

static int fusedav_open(const char *path, struct fuse_file_info *fi) {
    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    struct stat st;
    int result = webdav_get_stat(ctx, path, &st);

    if (result != 0) {
        if ((fi->flags & O_CREAT) && result == -ENOENT) {
            result = webdav_create_file(ctx, path);
            if (result != 0) return result;
        } else {
            return result;
        }
    }

    if (S_ISDIR(st.st_mode)) {
        return -EISDIR;
    }

    file_handle_t *fh = file_handle_create(path);
    if (!fh) return -ENOMEM;

    fh->file_size = st.st_size;
    fh->last_modified = st.st_mtime;

    fi->fh = (uint64_t)(uintptr_t)fh;
    return 0;
}

static int fusedav_create(const char *path, mode_t mode,
                          struct fuse_file_info *fi) {
    (void)mode;

    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    int result = webdav_create_file(ctx, path);
    if (result != 0) return result;

    file_handle_t *fh = file_handle_create(path);
    if (!fh) return -ENOMEM;

    fh->file_size = 0;
    fh->last_modified = time(NULL);

    fi->fh = (uint64_t)(uintptr_t)fh;
    return 0;
}

static int fusedav_read(const char *path, char *buf, size_t size,
                        off_t offset, struct fuse_file_info *fi) {
    (void)path;

    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    file_handle_t *fh = (file_handle_t *)(uintptr_t)fi->fh;
    const char *read_path = fh ? fh->path : path;

    ssize_t result = webdav_read_file(ctx, read_path, offset, size,
                                      (uint8_t *)buf);
    return (int)result;
}

static int fusedav_write(const char *path, const char *buf, size_t size,
                         off_t offset, struct fuse_file_info *fi) {
    (void)path;

    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    file_handle_t *fh = (file_handle_t *)(uintptr_t)fi->fh;
    if (!fh) return -EBADF;

    if (fh->write_buffer_pos + size > fh->write_buffer_size) {
        int result = file_handle_flush(ctx, fh);
        if (result != 0) return result;

        if (size > fh->write_buffer_size) {
            ssize_t written = webdav_write_file(ctx, fh->path, offset,
                                                size, (uint8_t *)buf);
            return (int)written;
        }
    }

    memcpy(fh->write_buffer + fh->write_buffer_pos, buf, size);
    fh->write_buffer_pos += size;
    fh->dirty = 1;

    off_t new_end = offset + (off_t)size;
    if (new_end > fh->file_size) {
        fh->file_size = new_end;
    }

    return (int)size;
}

static int fusedav_flush(const char *path, struct fuse_file_info *fi) {
    (void)path;

    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    file_handle_t *fh = (file_handle_t *)(uintptr_t)fi->fh;
    if (!fh) return 0;

    return file_handle_flush(ctx, fh);
}

static int fusedav_fsync(const char *path, int isdatasync,
                         struct fuse_file_info *fi) {
    (void)isdatasync;
    return fusedav_flush(path, fi);
}

static int fusedav_release(const char *path, struct fuse_file_info *fi) {
    (void)path;

    webdav_context_t *ctx = get_context();
    file_handle_t *fh = (file_handle_t *)(uintptr_t)fi->fh;

    if (fh) {
        if (ctx && fh->dirty) {
            file_handle_flush(ctx, fh);
        }
        file_handle_destroy(fh);
    }

    fi->fh = 0;
    return 0;
}

static int fusedav_mkdir(const char *path, mode_t mode) {
    (void)mode;

    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    return webdav_mkdir(ctx, path);
}

static int fusedav_unlink(const char *path) {
    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    return webdav_delete(ctx, path);
}

static int fusedav_rmdir(const char *path) {
    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    return webdav_delete(ctx, path);
}

static int fusedav_rename(const char *from, const char *to,
                          unsigned int flags) {
    (void)flags;

    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    return webdav_rename(ctx, from, to);
}

static int fusedav_truncate(const char *path, off_t size,
                            struct fuse_file_info *fi) {
    (void)fi;

    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    return webdav_truncate(ctx, path, size);
}

static int fusedav_statfs(const char *path, struct statvfs *stbuf) {
    (void)path;

    stbuf->f_bsize = 4096;
    stbuf->f_frsize = 4096;
    stbuf->f_blocks = 1000000000;
    stbuf->f_bfree = 500000000;
    stbuf->f_bavail = 500000000;
    stbuf->f_files = 1000000;
    stbuf->f_ffree = 500000;
    stbuf->f_favail = 500000;
    stbuf->f_fsid = 0;
    stbuf->f_flag = 0;
    stbuf->f_namemax = 255;

    return 0;
}

static int fusedav_utimens(const char *path, const struct timespec tv[2],
                           struct fuse_file_info *fi) {
    (void)path;
    (void)tv;
    (void)fi;
    return 0;
}

static int fusedav_access(const char *path, int mask) {
    (void)mask;

    webdav_context_t *ctx = get_context();
    if (!ctx) return -EIO;

    if (path_is_root(path)) {
        return 0;
    }

    struct stat st;
    return webdav_get_stat(ctx, path, &st);
}

static void *fusedav_init(struct fuse_conn_info *conn,
                          struct fuse_config *cfg) {
    (void)conn;
    cfg->kernel_cache = 1;
    cfg->auto_cache = 1;
    cfg->entry_timeout = 30.0;
    cfg->attr_timeout = 30.0;
    cfg->negative_timeout = 5.0;
    return NULL;
}

static void fusedav_destroy(void *private_data) {
    (void)private_data;

    webdav_context_t *ctx = get_context();
    if (ctx) {
        cache_clear(ctx->metadata_cache);
        cache_clear(ctx->dir_cache);
    }
}

struct fuse_operations fusedav_operations = {
    .getattr    = fusedav_getattr,
    .readdir    = fusedav_readdir,
    .open       = fusedav_open,
    .create     = fusedav_create,
    .read       = fusedav_read,
    .write      = fusedav_write,
    .flush      = fusedav_flush,
    .fsync      = fusedav_fsync,
    .release    = fusedav_release,
    .mkdir      = fusedav_mkdir,
    .unlink     = fusedav_unlink,
    .rmdir      = fusedav_rmdir,
    .rename     = fusedav_rename,
    .truncate   = fusedav_truncate,
    .statfs     = fusedav_statfs,
    .utimens    = fusedav_utimens,
    .access     = fusedav_access,
    .init       = fusedav_init,
    .destroy    = fusedav_destroy,
};

void operations_init(webdav_context_t *ctx) {
    g_ctx = ctx;
}