#include <stdio.h>
#include <spdk/event.h>
#include <spdk/blob.h>
#include <spdk/bdev.h>
#include <spdk/env.h>
#include <spdk/blob_bdev.h>

#include <unistd.h>
#include <sys/syscall.h>



#define FILENAME_LENGTH		1024

typedef struct zfs_ctx_s {

	struct spdk_bs_dev *bsdev;
	struct spdk_blob_store *bs;
	spdk_blob_id blobid;
	struct spdk_blob *blob;
	struct spdk_io_channel *channel;

	uint8_t *write_buff;
	uint8_t *read_buff;

	uint64_t io_unit_size;
	bool finished;

} zfs_ctx_t;

typedef struct zvfs_file_s {

	char filename[FILENAME_LENGTH];

	struct spdk_blob *blob; 
	spdk_blob_id blobid;

	struct zvfs_s *fs;

	uint8_t *write_buff; //
	uint8_t *read_buff;  //

	bool finished;

} zvfs_file_t;


typedef struct zvfs_file_operation_s {
	int (*open)(void);
	int (*write)(void);
	int (*read)(void);
	int (*close)(void);
} zvfs_file_operation_t;


typedef struct zvfs_s {

	struct spdk_bs_dev *bsdev;
	struct spdk_blob_store *bs;
	struct spdk_io_channel *channel;
	uint64_t io_unit_size;

	bool finished;
	
} zvfs_t;


typedef struct zvfs_operation_s {
	int (*load)(zvfs_t *fs);
	int (*unload)(zvfs_t *fs);
} zvfs_operation_t;



struct spdk_thread *global_thread;
zvfs_t *fs;


static void zvfs_spdk_bdev_complete(enum spdk_bdev_event_type type, struct spdk_bdev *bdev,
				     void *event_ctx) {

	printf("blobstore create success\n");
	
}

static void zvfs_spdk_bs_unload_complete(void *arg, int bserrno) {

	zvfs_t *ctx = arg;
#if 0
	if (ctx->read_buff) {
		spdk_free(ctx->read_buff);
		ctx->read_buff = NULL;
	}
	if (ctx->write_buff) {
		spdk_free(ctx->write_buff);
		ctx->write_buff = NULL;
	}
#endif

	ctx->finished = true;
}


static void zvfs_spdk_bs_destroy_complete(void *arg, int bserrno) {

	zvfs_t *ctx = arg;
	if (ctx->bs) {
		if (ctx->channel) {
			spdk_bs_free_io_channel(ctx->channel);
		}
		spdk_bs_unload(ctx->bs, zvfs_spdk_bs_unload_complete, ctx);
	}
	
}


static void zvfs_spdk_blob_close_complete(void *arg, int bserrno) {

	zvfs_file_t *file = arg;

	
#if 1
	if (file->read_buff) {
		spdk_free(file->read_buff);
		file->read_buff = NULL;
	}
	if (file->write_buff) {
		spdk_free(file->write_buff);
		file->write_buff = NULL;
	}
#endif
	file->finished = true;
	
}


static void zvfs_spdk_blob_read_complete(void *arg, int bserrno) {

	zvfs_file_t *file = arg;

	//SPDK_NOTICELOG("read : %s\n", file->read_buff);
#if 0
	int match_res = memcmp(file->write_buff, file->read_buff,
			   file->fs->io_unit_size);
	if (!match_res) {
		SPDK_NOTICELOG("read SUCCESS and data matches!\n");
	}
#endif

	file->finished  = true;

}


static void zvfs_spdk_blob_write_complete(void *arg, int bserrno) {

	zvfs_file_t *file = arg;


	file->finished = true;
	//SPDK_NOTICELOG("ctx->finished = true\n");

}


static void zvfs_spdk_blob_sync_complete(void *arg, int bserrno)  {

	zvfs_file_t *file = arg;
#if 1
	file->write_buff = spdk_malloc(file->fs->io_unit_size, 0x1000, NULL,
					SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
	if (file->write_buff == NULL) {
		return ;
	}

	file->read_buff = spdk_malloc(file->fs->io_unit_size, 0x1000, NULL,
					SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
	if (file->read_buff == NULL) {
		return ;
	}
#endif

	file->finished = true;

	//SPDK_NOTICELOG("ctx->finished = true\n");

}



static void zvfs_spdk_bdev_resize_blob_complete(void *arg, int bserrno) {

	zvfs_file_t *file = arg;

	spdk_blob_sync_md(file->blob, zvfs_spdk_blob_sync_complete, file);

}



static void zvfs_spdk_bdev_open_blob_complete(void *arg, struct spdk_blob *blb, int bserrno) {

	zvfs_file_t *file = arg;
	file->blob = blb;

	uint64_t numfreed = spdk_bs_free_cluster_count(file->fs->bs);
	
	//SPDK_NOTICELOG("numfreed: %"PRIu64"\n", numfreed);
	spdk_blob_resize(blb, numfreed, zvfs_spdk_bdev_resize_blob_complete, file);
	
}

// create
// open

static void zvfs_spdk_bdev_create_blob_complete(void *arg, spdk_blob_id blobid, int bserrno) {

	//SPDK_NOTICELOG("spdk_blob_id: %"PRIu64"\n", blobid);

	zvfs_file_t *file = arg;

	file->blobid = blobid;
	
#if 1
	spdk_bs_open_blob(file->fs->bs, blobid,  zvfs_spdk_bdev_open_blob_complete, file);
#endif	
}



static void zvfs_spdk_bdev_init_complete(void *arg, struct spdk_blob_store *bs,
		int bserrno) {

	
	zvfs_t *ctx = arg;
	ctx->bs = bs;
	ctx->io_unit_size = spdk_bs_get_io_unit_size(bs);

#if 1
	ctx->channel = spdk_bs_alloc_io_channel(ctx->bs);
	if (ctx->channel == NULL) {
		return ;
	}
	
#endif

	//SPDK_NOTICELOG("io_unit_size --> %" PRIu64 "\n", ctx->io_unit_size);

	ctx->finished = true;
}


// zvfs
static void zvfs_do_load(void *arg) {

	zvfs_t *ctx = arg;
	struct spdk_bs_dev *bsdev = NULL;

	const char * bdev_name = "Malloc0";
	int res = spdk_bdev_create_bs_dev_ext(bdev_name, zvfs_spdk_bdev_complete, NULL, &bsdev);
	if (res != 0) {
		spdk_app_stop(-1);
		return ;
	}

	ctx->bsdev = bsdev;
	spdk_bs_init(bsdev, NULL, zvfs_spdk_bdev_init_complete, ctx);

	return ;
}



// unload
static void zvfs_do_unload(void *arg) {

	zvfs_t *ctx = arg;
	//spdk_bs_delete_blob(ctx->bs, ctx->blobid, zvfs_spdk_bs_delete_complete, ctx);
	spdk_bs_destroy(ctx->bs, zvfs_spdk_bs_destroy_complete, ctx);

	return ;
}



/// zvfs file api
// 

static const int POLLER_MAX_TIME = 100000;


static bool poller(struct spdk_thread *thread, spdk_msg_fn start_fn, void *ctx, bool *finished) {


	spdk_thread_send_msg(thread, start_fn, ctx);
	int poller_count = 0;
	
	do {
		spdk_thread_poll(thread, 0, 0);

		poller_count ++;
	} while (!(*finished) && poller_count < POLLER_MAX_TIME);

	
	if (!(*finished) && poller_count >= POLLER_MAX_TIME) { //timeout
		return false;
	}
	
	return true;
}


/// 
static void zvfs_do_open(void *arg) {

	zvfs_file_t *ctx = arg;
#if 0
	spdk_bs_open_blob(ctx->fs->bs, ctx->blobid,  zvfs_spdk_bdev_open_blob_complete, ctx);
#else
	spdk_bs_create_blob(ctx->fs->bs, zvfs_spdk_bdev_create_blob_complete, ctx);
#endif
	return ;
}



static void zvfs_do_write(void *arg) {

	
	zvfs_file_t *file = arg;
#if 0
	ctx->write_buff = spdk_malloc(ctx->io_unit_size, 0x1000, NULL,
					SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
	if (ctx->write_buff == NULL) {
		return ;
	}
	
	memset(ctx->write_buff, 'K', ctx->io_unit_size);
	ctx->write_buff[ctx->io_unit_size-1] = '\0';
#endif	
	
	
	spdk_blob_io_write(file->blob, file->fs->channel, file->write_buff, 0, 1, zvfs_spdk_blob_write_complete, file);
	

	return ;
}

static void zvfs_do_read(void *arg)  {

	zvfs_file_t *file = arg;
#if 0
	ctx->read_buff = spdk_malloc(ctx->io_unit_size, 0x1000, NULL,
					SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
	if (ctx->read_buff == NULL) {
		return ;
	}
#endif
	spdk_blob_io_read(file->blob, file->fs->channel, file->read_buff, 0, 1, zvfs_spdk_blob_read_complete, file);

	return ;
}

static void zvfs_do_close(void *arg) {
	zvfs_file_t *file = arg;
	spdk_blob_close(file->blob, zvfs_spdk_blob_close_complete, file);
	return ;
}


// errno  
// 1. 
//  strerr
//

////   zvfs_file_open   
static int zvfs_file_open(zvfs_file_t *file) {

	file->finished = false;
	if (!poller(global_thread, zvfs_do_open, file, &file->finished)) {
		return -1;
	}
	return 0;
}


static int zvfs_file_close(zvfs_file_t *file) {

	file->finished = false;
	if (!poller(global_thread, zvfs_do_close, file, &file->finished)) {
		return -1;
	}
	return 0;
}

static int zvfs_file_write(zvfs_file_t *file, const void *buf, size_t size) {

	file->finished = false;

	memcpy(file->write_buff, buf, size); //
	
	if (!poller(global_thread, zvfs_do_write, file, &file->finished)) {
		return -1;
	}
	return 0;
}


static int zvfs_file_read(zvfs_file_t *file, void *buf, size_t size) {

	file->finished = false;
	if (!poller(global_thread, zvfs_do_read, file, &file->finished)) {
		return -1;
	}

	memcpy(buf, file->read_buff, size);
	
	return 0;
	
}




////  zvfs

static int zvfs_load(zvfs_t *fs) {

	fs->finished = false;
	if (!poller(global_thread, zvfs_do_load, fs, &fs->finished)) {
		return -1;
	}

	return 0;
}

static int zvfs_unload(zvfs_t *fs) {

	fs->finished = false;
	if (!poller(global_thread, zvfs_do_unload, fs, &fs->finished)) {
		return -1;
	}
	return 0;
}



// fd

#define MAX_FD_COUNT		1024
#define DEFAULT_FD_NUM		3


static unsigned char fd_table[MAX_FD_COUNT / 8] = {0};
zvfs_file_t *files[MAX_FD_COUNT] = {0};


static int get_fd_frombitmap(void) {

	int fd = DEFAULT_FD_NUM;
	for ( ;fd < MAX_FD_COUNT;fd ++) {
		if ((fd_table[fd/8] & (0x1 << (fd % 8))) == 0) {
			fd_table[fd/8] |= (0x1 << (fd % 8));
			return fd;
		}
	}

	return -1;
	
}

static int set_fd_frombitmap(int fd) {

	if (fd >= MAX_FD_COUNT) return -1;

	fd_table[fd/8] &= ~(0x1 << (fd % 8));

	return 0;
}


static int zvfs_open(const char *filename, int flag) {

	zvfs_file_t *file = (zvfs_file_t*)malloc(sizeof(zvfs_file_t));
	if (file == NULL) return -1;

	int fd = get_fd_frombitmap();
	file->fs = fs;
	files[fd] = file;

	zvfs_file_open(file);

	return fd;
	
}

static int zvfs_write(int fd,const void *buf, size_t count) {

	zvfs_file_t *file = files[fd];
	zvfs_file_write(file, buf, count);

	return 0;
}

static int zvfs_read(int fd, void *buf, size_t count) {
	zvfs_file_t *file = files[fd];
	zvfs_file_read(file, buf, count);


	return strlen(buf);
}

static int zvfs_close(int fd) {

	zvfs_file_t *file = files[fd];
	zvfs_file_close(file);
	set_fd_frombitmap(fd);

	free(file);

	return 0;
}

///  hook 
#if 0
typedef int (*open_t)(const char *pathname, int flags);
open_t open_f = NULL;

typedef ssize_t (*write_t)(int fd, const void *buf, size_t n);
write_t write_f = NULL;

typedef ssize_t (*read_t)(int fd, void *buf, size_t n);
read_t read_f = NULL;

typedef int (*close_t)(int fd);
close_t close_f;


int zvfs_initilize = false;

static int zvfs_setup(void);

int open(const char *pathname, int flags, ...) {
	int ret = 0;
	
	ret = syscall(__NR_open, pathname, flags);

	return ret;
}


ssize_t write(int fd, const void *buf, size_t n) {

	int ret = 0;

	ret = syscall(__NR_write, buf, n);

	return ret;
}

ssize_t read(int fd, void *buf, size_t n) {

	int ret = 0;

	ret = syscall(__NR_read, buf, n);

	return ret;
}

int close (int fd) {

	int ret = 0;

	ret = syscall(__NR_close, fd);

	return ret;

}


#else 


#include <dlfcn.h>


#define DEBUG_ENABLE	1

#if DEBUG_ENABLE
#define dblog(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define dblog(fmt, ...)
#endif

typedef int (*open_t)(const char *pathname, int flags);
open_t open_f = NULL;

typedef ssize_t (*write_t)(int fd, const void *buf, size_t n);
write_t write_f = NULL;

typedef ssize_t (*read_t)(int fd, void *buf, size_t n);
read_t read_f = NULL;

typedef int (*close_t)(int fd);
close_t close_f = NULL;

int open(const char *pathname, int flags, ...) {

	if (!open_f) {
		open_f = dlsym(RTLD_NEXT, "open");
	}

	dblog("open.. %s\n", pathname);

	return open_f(pathname, flags);
}

ssize_t read(int fd, void *buf, size_t count) {

	ssize_t ret;

	if (!read_f) {
		read_f = dlsym(RTLD_NEXT, "read");
	}

	ret = read_f(fd, buf, count);
	dblog("read.. : %ld, %ld\n", ret, count);

	return ret;
}

ssize_t write(int fd, const void *buf, size_t count) {

	if (!write_f) {
		write_f = dlsym(RTLD_NEXT, "write");
	}

	dblog("write.. : %ld\n", count);

	return write_f(fd, buf, count);

}

int close(int fd) {

	if (!close_f) {
		close_f = dlsym(RTLD_NEXT, "close");
	}

	dblog("close..\n");

	return close_f(fd);

}
#endif

#if 1


static const char *json_file = "/home/king/share/spdk/examples/mysql/hello_blob.json";

static void json_app_load_done(int rc, void *ctx) {

	bool *done = ctx;
	*done = true;
//	SPDK_NOTICELOG("json_app_load_done\n");
	
}


static void zvfs_json_load_fn(void *arg) {

	spdk_subsystem_init_from_json_config(json_file, SPDK_DEFAULT_RPC_ADDR,
					     json_app_load_done, arg, true);
	
}


static int zvfs_env_setup(void) {
	struct spdk_env_opts opts;
	spdk_env_opts_init(&opts);

	if (spdk_env_init(&opts) != 0) {
		return -1;
	}

	spdk_log_set_print_level(SPDK_LOG_NOTICE);
	spdk_log_set_level(SPDK_LOG_NOTICE);
	spdk_log_open(NULL);

	spdk_thread_lib_init(NULL, 0);
	global_thread = spdk_thread_create("global", NULL);
	spdk_set_thread(global_thread);

	bool done = false;
	poller(global_thread, zvfs_json_load_fn, &done, &done);

	return 0;
}

// blob --> json

static int zvfs_setup(void) {
	zvfs_env_setup();

	zvfs_t *ctx = calloc(1, sizeof(zvfs_t));
	zvfs_load(ctx);
	fs = ctx;

	return 0;
}

#if 0

int main(int argc, char *argv[]) {
	printf("zvfs_env_setup111\n");
	
#if 0
	zvfs_env_setup();
	// load	--> bs_init, blob_create, blob_open, blob_resize
	zfs_ctx_t *ctx = calloc(1, sizeof(zfs_ctx_t));
	ctx->finished = false;
	poller(global_thread, zvfs_do_load, ctx, &ctx->finished);

	// open
	ctx->finished = false;
	poller(global_thread, zvfs_do_open, ctx, &ctx->finished);

	// write
	ctx->finished = false;
	poller(global_thread, zvfs_do_write, ctx, &ctx->finished);

	// read
	ctx->finished = false;
	poller(global_thread, zvfs_do_read, ctx, &ctx->finished);

	// close
	ctx->finished = false;
	poller(global_thread, zvfs_do_close, ctx, &ctx->finished);
	
	// unload
	ctx->finished = false;
	poller(global_thread, zvfs_do_unload, ctx, &ctx->finished);

#elif 0
	zvfs_env_setup();

	zvfs_t *ctx = calloc(1, sizeof(zvfs_t));
	zvfs_load(ctx);
	fs = ctx;

	zvfs_file_t *file = calloc(1, sizeof(zvfs_file_t));
	file->fs = ctx;
	zvfs_file_open(file);

	char *buffer = "zvoice.king";
	zvfs_file_write(file, buffer, strlen(buffer));

	char rbuffer[1024] = {0};
	zvfs_file_read(file, rbuffer, 1024);

	printf("rbuffer: %s\n", rbuffer);

	zvfs_file_close(file);

	
	zvfs_unload(ctx);

#elif 0

	zvfs_t *ctx = calloc(1, sizeof(zvfs_t));
	zvfs_load(ctx);
	fs = ctx;

	int fd = zvfs_open("king.txt", 0x666);

	char *buffer = "zvoice.king";
	zvfs_write(fd, buffer, strlen(buffer));

	char rbuffer[1024] = {0};
	zvfs_read(fd, rbuffer, 1024);
	printf("rbuffer: %s\n", rbuffer);

	zvfs_close(fd);
	
	zvfs_unload(ctx);

#else

	printf("zvfs_env_setup\n");
	//zvfs_t *ctx = calloc(1, sizeof(zvfs_t));
	//zvfs_load(ctx);
	//fs = ctx;
	printf("zvfs_load\n");

	int fd = open("/home/king/share/spdk/examples/mysql/a.txt", O_RDWR | O_CREAT);

	printf("fd: %d, %s\n", fd, strerror(errno));
	char *buffer = "zvoice.king";
	int ret = write(fd, buffer, strlen(buffer));

	lseek(fd, 0, SEEK_SET);

	char rbuffer[1024] = {0};
	ret = read(fd, rbuffer, 1024);
	printf("ret : %d, rbuffer: %s\n", ret, rbuffer);

	close(fd);


	//zvfs_unload(fs);

	return 0;
#endif

}

#endif

#elif 0


int main() {

	int fd = open("./a.txt", RW);

	char *buffer = "zvoice.king";
	write(fd, buffer, strlen(buffer));

	char rbuffer[1024] = {0};
	read(fd, rbuffer, 1024);

	close(fd);

}

#else

int main(int argc, char *argv[]) {

	if (argc < 2) {
		return -1;
	}

	struct spdk_app_opts opts= {0};
	spdk_app_opts_init(&opts, sizeof(opts));
	opts.name = "zvfs";
	opts.json_config_file = argv[1];

	printf("spdk_set_thread --> \n");

	zfs_ctx_t *ctx = calloc(1, sizeof(zfs_ctx_t));
	spdk_app_start(&opts, zvfs_entry, ctx);

	spdk_app_fini();

	free(ctx);

	return 0;
}


#endif