#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/xattr.h>
#include <errno.h>

#include "bit-rot-object-version.h"

/* NOTE: no size discovery */
int
brstub_validate_version(char *bpath, unsigned long version)
{
    int ret = 0;
    int match = 0;
    size_t xsize = 0;
    br_version_t *xv = NULL;

    xsize = sizeof(br_version_t);

    xv = calloc(1, xsize);
    if (!xv) {
        match = -1;
        goto err;
    }

    ret = getxattr(bpath, "trusted.bit-rot.version", xv, xsize);
    if (ret < 0) {
        if (errno == ENODATA)
            match = -2;
        goto err;
    }

    if (xv->ongoingversion != version) {
        match = -3;
        fprintf(stderr, "ongoingversion: %lu\n", xv->ongoingversion);
    }
    free(xv);

err:
    return match;
}

int
brstub_write_validation(char *filp, char *bpath, unsigned long startversion)
{
    int fd1 = 0;
    int fd2 = 0;
    int ret = 0;
    char *string = "string\n";

    /* read only check */
    fd1 = open(filp, O_RDONLY);
    if (fd1 < 0)
        goto err;
    close(fd1);

    ret = brstub_validate_version(bpath, startversion);
    if (ret != -2)
        goto err;

    /* single open (write/) check */
    fd1 = open(filp, O_RDWR);
    if (fd1 < 0)
        goto err;

    ret = write(fd1, string, strlen(string));
    if (ret <= 0)
        goto err;
    /**
     * Fsync is done so that the write call has properly reached the
     * disk. For fuse mounts write-behind xlator would have held the
     * writes with itself and for nfs, client would have held the
     * write in its cache. So write fop would not have triggered the
     * versioning as it would have not reached the bit-rot-stub.
     */
    fsync(fd1);
    ret = brstub_validate_version(bpath, startversion);
    if (ret != 0)
        goto err;
    ret = write(fd1, string, strlen(string));
    if (ret <= 0)
        goto err;
    fsync(fd1); /* let it reach the disk */

    ret = brstub_validate_version(bpath, startversion);
    if (ret != 0)
        goto err;

    close(fd1);

    /**
     * Well, this is not a _real_ test per se . For this test to pass
     * the inode should not get a forget() in the interim. Therefore,
     * perform this test asap.
     */

    /* multi open (write/) check */
    fd1 = open(filp, O_RDWR);
    if (fd1 < 0)
        goto err;
    fd2 = open(filp, O_WRONLY);
    if (fd1 < 0)
        goto err;

    ret = write(fd1, string, strlen(string));
    if (ret <= 0)
        goto err;

    ret = write(fd2, string, strlen(string));
    if (ret <= 0)
        goto err;

    /* probably do a syncfs() */
    fsync(fd1);
    fsync(fd2);

    close(fd1);
    close(fd2);

    /**
     * incremented once per write()/write().../close()/close() sequence
     */
    ret = brstub_validate_version(bpath, startversion);
    if (ret != 0)
        goto err;

    return 0;

err:
    return -1;
}

int
brstub_new_object_validate(char *filp, char *brick)
{
    int ret = 0;
    char *fname = NULL;
    char bpath[PATH_MAX] = {
        0,
    };

    fname = basename(filp);
    if (!fname)
        goto err;

    (void)snprintf(bpath, PATH_MAX, "%s/%s", brick, fname);

    printf("Validating initial version..\n");
    ret = brstub_validate_version(bpath, 2);
    if (ret != -2) /* version _should_ be missing */
        goto err;

    printf("Validating version on modifications..\n");
    ret = brstub_write_validation(filp, bpath, 2);
    if (ret < 0)
        goto err;

    return 0;

err:
    return -1;
}

int
main(int argc, char **argv)
{
    int ret = 0;
    char *filp = NULL;
    char *brick = NULL;

    if (argc != 3) {
        printf("Usage: %s <path> <brick>\n", argv[0]);
        goto err;
    }

    filp = argv[1];
    brick = argv[2];

    printf("Validating object version [%s]\n", filp);
    ret = brstub_new_object_validate(filp, brick);
    if (ret < 0)
        goto err;

    return 0;

err:
    return -1;
}