#include "spdk/event.h"
#include "spdk/blob.h"
#include "spdk/bdev.h"
#include "spdk/blob_bdev.h"

#define     BUFFER_SIZE     512

typedef struct zv1ianfs_ctx_s {
    struct spdk_blob_store *blobstore;
    uint64_t unit_size;
    spdk_blob_id blob_id;
    struct spdk_blob *blob;
    uint64_t free_cluster_count;
    uint64_t num_cluster;
    uint8_t  *write_buffer;
    uint8_t  *read_buffer;
    struct spdk_io_channel *channel;
} zv1ianfs_ctx_t;

void zv1ianfs_spdk_bs_unload_cb(void *cb_arg, int bserrno);
void zv1ianfs_spdk_delete_blob_cb(void *cb_arg, int bserrno);
void zv1ianfs_spdk_blob_close_cb(void *cb_arg, int bserrno);
void zv1ianfs_spdk_blob_io_read_cb(void *cb_arg, int bserrno);
void zv1ianfs_spdk_blob_io_write_cb(void *cb_arg, int bserrno);
void zv1ianfs_spdk_blob_sync_cb(void *cb_arg, int bserrno);
void zv1ianfs_spdk_blob_resize(void *cb_arg, int bserrno);
void zv1ianfs_spdk_bs_open_blob_cb(void *cb_arg, struct spdk_blob *blb, int bserrno);
void zv1ianfs_spdk_bs_create_blob_cb(void *cb_arg, spdk_blob_id blobid, int bserrno);
void zv1ianfs_spdk_bs_init_cb(void *cb_arg, struct spdk_blob_store *bs, int bserrno);
void zv1ianfs_spdk_bdev_event_cb (enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *event_ctx);
void zv1ianfs_do_mount(void *ctx); 

void zv1ianfs_spdk_bs_unload_cb(void *cb_arg, int bserrno){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)cb_arg;
    spdk_app_stop(0);

    spdk_free(ctx->write_buffer);
    spdk_free(ctx->read_buffer);
    free(ctx);
}

void zv1ianfs_spdk_delete_blob_cb(void *cb_arg, int bserrno){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)cb_arg;
    if(ctx->blobstore) {
        if(ctx->channel) {
            spdk_bs_free_io_channel(ctx->channel);
        }
        spdk_bs_unload(ctx->blobstore, zv1ianfs_spdk_bs_unload_cb, ctx);
    }    
}

void zv1ianfs_spdk_blob_close_cb(void *cb_arg, int bserrno){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)cb_arg;
    spdk_bs_delete_blob(ctx->blobstore, ctx->blob_id, zv1ianfs_spdk_delete_blob_cb, ctx);
}

void zv1ianfs_spdk_blob_io_read_cb(void *cb_arg, int bserrno){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)cb_arg;
    SPDK_NOTICELOG("READ BUFFER : %s\n", ctx->read_buffer);

    spdk_blob_close(ctx->blob, zv1ianfs_spdk_blob_close_cb ,ctx);
}

void zv1ianfs_spdk_blob_io_write_cb(void *cb_arg, int bserrno){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)cb_arg;
    SPDK_NOTICELOG("WRITE COMPLETE\n");

    uint8_t *rbuffer = spdk_malloc(512, 0x1000, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
    if(rbuffer == NULL){
        spdk_app_stop(-1);
        return ;   
    }
    memset(rbuffer, 0x0, BUFFER_SIZE);
    ctx->read_buffer = rbuffer;

    spdk_blob_io_read(ctx->blob, ctx->channel, rbuffer, 0, 1, zv1ianfs_spdk_blob_io_read_cb, ctx);
}

void zv1ianfs_spdk_blob_sync_cb(void *cb_arg, int bserrno){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)cb_arg;
    uint8_t *wbuffer = spdk_malloc(512, 0x1000, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
    if(wbuffer == NULL){
        spdk_app_stop(-1);
        return ;
    }
    memset(wbuffer, 'A', BUFFER_SIZE);
    *(wbuffer+BUFFER_SIZE-1) = '\0';
    ctx->write_buffer = wbuffer;
    
    ctx->channel = spdk_bs_alloc_io_channel(ctx->blobstore);
    if(ctx->channel == NULL){
        spdk_app_stop(-1);
    }

    spdk_blob_io_write(ctx->blob, ctx->channel, wbuffer, 0, 1, zv1ianfs_spdk_blob_io_write_cb, ctx);
}

void zv1ianfs_spdk_blob_resize(void *cb_arg, int bserrno){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)cb_arg;

    uint64_t total = spdk_blob_get_num_clusters(ctx->blob);
    ctx->num_cluster = total;

    SPDK_NOTICELOG("resize blob : %"PRIu64"\n", total);

    spdk_blob_sync_md(ctx->blob, zv1ianfs_spdk_blob_sync_cb, ctx);
}

void zv1ianfs_spdk_bs_open_blob_cb(void *cb_arg, struct spdk_blob *blb, int bserrno){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)cb_arg;
    ctx->blob = blb;

    uint64_t free_cluster = spdk_bs_free_cluster_count(ctx->blobstore);
    ctx->free_cluster_count = free_cluster;

    SPDK_NOTICELOG("free_cluster : %"PRIu64"\n", free_cluster);
    spdk_blob_resize(blb, free_cluster, zv1ianfs_spdk_blob_resize, ctx);
}

void zv1ianfs_spdk_bs_create_blob_cb(void *cb_arg, spdk_blob_id blobid, int bserrno){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)cb_arg;
    ctx->blob_id = blobid;

    SPDK_NOTICELOG("blobid : %"PRIu64"\n", blobid);
    spdk_bs_open_blob(ctx->blobstore, blobid, zv1ianfs_spdk_bs_open_blob_cb, ctx);
}

void zv1ianfs_spdk_bs_init_cb(void *cb_arg, struct spdk_blob_store *bs, int bserrno){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)cb_arg;
    ctx->blobstore = bs;

    uint64_t io_unit_size = spdk_bs_get_io_unit_size(bs);
    ctx->unit_size = io_unit_size;

    SPDK_NOTICELOG("io_unit_size: %"PRIu64"\n", io_unit_size);
    spdk_bs_create_blob(bs, zv1ianfs_spdk_bs_create_blob_cb, ctx);
}

void zv1ianfs_spdk_bdev_event_cb (enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *event_ctx){
    SPDK_NOTICELOG("zv1ianfs_spdk_bdev_event_cb called\n");    
}
                      
void zv1ianfs_do_mount(void *arg){
    zv1ianfs_ctx_t *ctx = (zv1ianfs_ctx_t *)arg;

    struct spdk_bs_dev *bs_dev = NULL;

    int rc = spdk_bdev_create_bs_dev_ext("Malloc0", zv1ianfs_spdk_bdev_event_cb, NULL, &bs_dev);
    if(rc != 0){
        SPDK_NOTICELOG("错误: 无法创建 bs_dev, 错误码 = %d\n", rc);
        spdk_app_stop(-1);
        return;
    }

    spdk_bs_init(bs_dev, NULL, zv1ianfs_spdk_bs_init_cb, ctx);

    SPDK_NOTICELOG("zv1ianfs_entry called\n");
}


int main(int argc, char *argv[]){
    
    struct spdk_app_opts opts = {};

    spdk_app_opts_init(&opts, sizeof(opts));
    opts.name = "zv1ianfs";
    opts.json_config_file = argv[1];

    zv1ianfs_ctx_t *ctx = calloc(1, sizeof(zv1ianfs_ctx_t));

    spdk_app_start(&opts, zv1ianfs_do_mount, ctx);

    SPDK_NOTICELOG("hello spdk\n");
}