#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <limits.h>
#include <string.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <glusterfs/api/glfs.h>
#include <glusterfs/api/glfs-handles.h>

#define LOG_ERR(msg) do { \
        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
        } while (0)

/*This test tests that shard xlator handles offset in appending writes
 * correctly. This test performs writes of 1025 bytes 1025 times, in 5 threads
 * with different threads. The buffer to be written is same character repeated
 * 1025 times in the buffer for a thread. At the end it reads the buffer till
 * end of file and tests that the read of 1025 bytes is always same character
 * and the content read is 5*1025*1025 size. 1025 bytes is chosen because it
 * will lead to write on more than one shard at some point when the size is
 * going over the initial shard*/
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int thread_data = '1';

glfs_t *
init_glfs (const char *hostname, const char *volname,
           const char *logfile)
{
        int     ret     = -1;
        glfs_t *fs      = NULL;

        fs = glfs_new (volname);
        if (!fs) {
                LOG_ERR ("glfs_new failed");
                return NULL;
        }

        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
        if (ret < 0) {
                LOG_ERR ("glfs_set_volfile_server failed");
                goto out;
        }

        ret = glfs_set_logging (fs, logfile, 7);
        if (ret < 0) {
                LOG_ERR ("glfs_set_logging failed");
                goto out;
        }

        ret = glfs_init (fs);
        if (ret < 0) {
                LOG_ERR ("glfs_init failed");
                goto out;
        }

        ret = 0;
out:
        if (ret) {
                glfs_fini (fs);
                fs = NULL;
        }

        return fs;
}

void*
write_data (void *data)
{
        char           buf[1025] = {0};
        glfs_fd_t      *glfd = NULL;
        glfs_t         *fs       = data;
        int            i     = 0;

        pthread_mutex_lock (&lock);
        {
                memset(buf, thread_data, sizeof(buf));
                thread_data++;
        }
        pthread_mutex_unlock (&lock);

        for (i = 0; i < 1025; i++) {
                glfd = glfs_creat(fs, "parallel-write.txt", O_WRONLY | O_APPEND,
                                   S_IRUSR | S_IWUSR | O_SYNC);
                if (!glfd) {
                        LOG_ERR ("Failed to create file");
                        exit(1);
                }

                if (glfs_write (glfd, buf, sizeof(buf), 0) < 0) {
                        LOG_ERR ("Failed to write to file");
                        exit(1);
                }
                if (glfs_close(glfd) != 0) {
                        LOG_ERR ("Failed to close file");
                        exit(1);
                }
        }
        return NULL;
}

int
main (int argc, char *argv[])
{
        pthread_t  tid[5] = {0};
        char       buf[1025] = {0};
        char       cmp_buf[1025] = {0};
        int         ret      = 0;
        char       *hostname = NULL;
        char       *volname  = NULL;
        char       *logfile  = NULL;
        glfs_t     *fs       = NULL;
        glfs_fd_t  *glfd     = NULL;
        ssize_t     bytes_read = 0;
        ssize_t     total_bytes_read = 0;
        int i = 0;

        if (argc != 4) {
                fprintf (stderr, "Invalid argument\n");
                exit(1);
        }

        hostname = argv[1];
        volname = argv[2];
        logfile = argv[3];

        fs = init_glfs (hostname, volname, logfile);
        if (fs == NULL) {
                LOG_ERR ("init_glfs failed");
                return -1;
        }

        for (i = 0; i < 5; i++) {
                pthread_create(&tid[i], NULL, write_data, fs);
        }

        for (i = 0; i < 5; i++) {
                pthread_join(tid[i], NULL);
        }
        glfd = glfs_open(fs, "parallel-write.txt", O_RDONLY);
        if (!glfd) {
                LOG_ERR ("Failed to open file for reading");
                exit(1);
        }

        while ((bytes_read = glfs_read (glfd, buf, sizeof(buf), 0)) > 0) {
                if (bytes_read != sizeof(buf)) {
                        fprintf (stderr, "Didn't read complete data read: %zd "
                                 "expected: %lu", bytes_read, sizeof(buf));
                        exit(1);
                }

                total_bytes_read += bytes_read;
                if (buf[0] < '1' || buf[0] >= thread_data) {
                        fprintf(stderr, "Invalid character found: %c", buf[0]);
                        exit(1);
                }
                memset(cmp_buf, buf[0], sizeof(cmp_buf));
                if (memcmp(cmp_buf, buf, sizeof(cmp_buf))) {
                        LOG_ERR ("Data corrupted");
                        exit(1);
                }
                memset(cmp_buf, 0, sizeof(cmp_buf));
        }

        if (total_bytes_read != 5*1025*1025) {
                fprintf(stderr, "Failed to read what is written, read; %zd, "
                        "expected %zu", total_bytes_read, 5*1025*1025);
                exit(1);
        }

        if (glfs_close(glfd) != 0) {
                LOG_ERR ("Failed to close");
                exit(1);
        }
        return 0;
}