// hook start =========
void *kvs_malloc(size_t size)
{
    return malloc(size);
}
void kvs_free(void* ptr)
{
    free(ptr);
}
// hook end ===========



/*
redis协议：
3\r\n # 3个token
3\r\n # 下一行3个字符
SET\r\n 
3\r\n # 下一行3个字符
KEY\r\n 
5\r\n # 下一行5个字符
VALUE\r\n
*/

// array, rbtree, btree, hash, skiptable

typedef enum kvs_cmd_e {
    // array
    KVS_CMD_START = 0, // 方便写循环
    KVS_CMD_SET = KVS_CMD_START,
    KVS_CMD_GET,
    KVS_CMD_COUNT,
    KVS_CMD_DELETE,
    KVS_CMD_EXIST,
    // rbtree
    KVS_CMD_RSET,
    KVS_CMD_RGET,
    KVS_CMD_RCOUNT,
    KVS_CMD_RDELETE,
    KVS_CMD_REXIST,
    // btree
    KVS_CMD_BSET,
    KVS_CMD_BGET,
    KVS_CMD_BCOUNT,
    KVS_CMD_BDELETE,
    KVS_CMD_BEXIST,
    // hash
    KVS_CMD_HSET,
    KVS_CMD_HGET,
    KVS_CMD_HCOUNT,
    KVS_CMD_HDELETE,
    KVS_CMD_HEXIST,
    // skiptable
    KVS_CMD_ZSET,
    KVS_CMD_ZGET,
    KVS_CMD_ZCOUNT,
    KVS_CMD_ZDELETE,
    KVS_CMD_ZEXIST,
    // cmd
    KVS_CMD_ERROR,
    KVS_CMD_QUIT,
    KVS_CMD_TOTAL,
    KVS_CMD_END,
} kvs_cmd_t;

const char * commands[] = {
    "SET", "GET", "COUNT", "DELETE", "EXIST",
    "RSET", "RGET", "RCOUNT", "RDELETE", "REXIST",
    "BSET", "BGET", "BCOUNT", "BDELETE", "BEXIST",
    "HSET", "HGET", "HCOUNT", "HDELETE", "HEXIST",
    "ZSET", "ZGET", "ZCOUNT", "ZDELETE", "ZEXIST",
}

typedef enum kvs_result_e{
    KVS_RESULT_OK,
    KVS_RESULT_FAILED,
}kvs_result_t;

const char* result[] = {
    "OK",
    "ERROR"
};

 
// array start ===================

typedef struct kvs_array_item_s{
    void *_;
    char* key;
    char* value;
}kvs_array_item_t;

##define KVS_ARRAY_ITEM_SIZE 1024

// kvs_array_item_t array_table[KVS_ARRAY_ITEM_SIZE] = {0};
kvs_array_item_t *array_table;
int array_count = 0;
kvs_array_item_t* kvs_array_search_item(const char *key){
    if(!key) return NULL;
    
    return NULL;
}

int kvs_array_set(const char* key, const char *value)
{
    if(key == NULL || value == NULL || array_count == KVS_ARRAY_ITEM_SIZE -1 ) return -1;
    if(kvs_array_exit(key)) return -1;
    char *kcopy = kvs_malloc(strlen(key) + 1);
    if(kcopy == NULL) return -1;
    strncpy(kcopy, key, strlen(key) + 1);
    char *vcopy = kvs_malloc(strlen(key) + 1);
    if(vcopy == NULL) return -1;
    strncpy(vcopy, key, strlen(key) + 1);
    kvs_array_item_t *item = memp_alloc(&mem);
    item->key = kcopy;
    item->value = vcopy;
    array_count++;
    return 0;
}

char* kvs_array_get(const char* key){
    kvs_array_item_t* item = kvs_array_search_item(key);
    if(item){
        return item->value;
    }
    return NULL;
}

int kvs_array_exit(const char* key)
{
    kvs_array_item_t* item = kvs_array_search_item(key);
    if(item != NULL) return 1;
    else return 0;
}

int kvs_array_count(void)
{
    return array_count;
}

int kvs_array_delete(char *key)
{
    if(key == NULL){
        return -1;
    }
    kvs_array_item_t *item = kvs_array_search_item(key);
    if(item == NULL)
    {
        return -1;
    }
    if(item->key){
        kvs_free(item->key);
        item->key = NULL;
    }
    if(item->key){
        kvs_free(item->value);
        item->value = NULL;
    }
    return 0;
}

/**
    引入固定大小内存池，解决数组删除问题
*/
// mem pool start =======================
##define MEM_PAGE_SIZE (KVS_ARRAY_ITEM_SIZE * sizeof(kvs_array_item_t)) // 4k

typedef struct mempool_s{
    int block_size; // 每块大小
    int free_count; // 剩余有多少块

    char *free_ptr; // 分配起始位置，使用char*可以每次方便向后移动1byte
    char *mem; // 整体起始位置
} mempool_t;

int memp_init(mempool_t* m, int block_size){
    if(!m) return -2;
    m->block_size = block_size;
    m->free_count = MEM_PAGE_SIZE / block_size;
    m->free_ptr = (char*)malloc(MEM_PAGE_SIZE);
    if(!m->free_ptr) return -1;
    m->mem = m->free_ptr;

    /* ！为了方便内存空洞处理，将每一块的头4个字节指向下一块的开头（隐链表），这样当一块释放的时候就将该块指向整体的开头（头插法） */
    int i = 0; 
    char *ptr = m->free_ptr;
    for(i = 0 ; i < m->free_count ; i++){
        // ptr指向一块，**ptr是该内容当做指针指向的位置即希望每块的前4bytes指向下一块的开头
        *(char**)ptr = ptr + block_size; 
        ptr += block_size;
    }
    *(char**)ptr = NULL;
    return 0;
}

// 注意这里不带大小，说明该方案解决不了分配大于32bytes的问题
void* memp_alloc(mempool_t* m)
{
    if(!m || m->free_count == 0) return NULL;
    char *ptr = m->free_ptr;
    m->free_ptr = *(char **)ptr;
    m->free_count--;

    return ptr;
}

void *memp_free(mempool_t* m, void *ptr)
{
   *(char**)ptr = m->free_ptr;
   m->free_ptr = (char*)ptr;
   m->free_count++;
}
// mem pool end =======================

mempool_t mem;

void init_array_table(void)
{
    memp_init(&mem, sizeof(kvs_array_item_t));

}

// array end ===================


##define MAX_TOKENS 32

int kvs_parser_protocol(char* msg, char** tokens, int count)
{
    if(tokens==NULL || tokens[0]==NULL || count==0) return KVS_CMD_ERROR;
    int cmd = KVS_CMD_START;
    for(cmd = KVS_CMD_START ; cmd < KVS_CMD_END ; cmd++){
        if(0 == strcmp(tokens[0], commands[cmd]))
            break;
    }
    switch(cmd){
    case KVS_CMD_SET:{
        assert(count == 3);
        int ret = kvs_array_set(tokens[1], tokens[2]);
        if(!ret){
             memset(msg, 0, CLIENTS_MSG_LENGTH);
             ret = snprintf(msg, CLIENTS_MSG_LENGTH, "OK\r\n");
        }else{
            memset(msg, 0, CLIENTS_MSG_LENGTH);
            ret = snprintf(msg, CLIENTS_MSG_LENGTH, "FAILED\r\n");
        }
        return ret;
    }    
    break;
    case KVS_CMD_GET:{
        char* value = kvs_array_get(tokens[1]);
        int ret = 0;
        if(value)
        {
            memset(msg, 0, CLIENTS_MSG_LENGTH);
            ret = snprintf(msg, CLIENTS_MSG_LENGTH, "%s\r\n",value);
        }
        else{
            memset(msg, 0, CLIENTS_MSG_LENGTH);
            ret = snprintf(msg, CLIENTS_MSG_LENGTH, "FAILED\r\n");
        }
        return ret;
    }  
    break;
    case KVS_CMD_COUNT:{
        int res = kvs_array_count();
        memset(msg, 0, CLIENTS_MSG_LENGTH);
        int ret = snprintf(msg, CLIENTS_MSG_LENGTH, "%d\r\n",res);
        return ret;
    }
    break;
    case KVS_CMD_DELETE:break;
    case KVS_CMD_EXIST:{
        int res = kvs_array_exist(tokens[1]);
        memset(msg, 0, CLIENTS_MSG_LENGTH);
        int ret = snprintf(msg, CLIENTS_MSG_LENGTH, "%d\r\n",res);
        return ret;
    }
    break;
    // rbtree
    case KVS_CMD_RSET:break;
    case KVS_CMD_RGET:break;
    case KVS_CMD_RCOUNT:break;
    case KVS_CMD_RDELETE:break;
    case KVS_CMD_REXIST:break;
    // btree
    case KVS_CMD_BSET:break;
    case KVS_CMD_BGET:break;
    case KVS_CMD_BCOUNT:break;
    case KVS_CMD_BDELETE:break;
    case KVS_CMD_BEXIST:break;
    // hash
    case KVS_CMD_HSET:break;
    case KVS_CMD_HGET:break;
    case KVS_CMD_HCOUNT:break;
    case KVS_CMD_HDELETE:break;
    case KVS_CMD_HEXIST:break;
    // skiptable
    case KVS_CMD_ZSET:break;
    case KVS_CMD_ZGET:break;
    case KVS_CMD_ZCOUNT:break;
    case KVS_CMD_ZDELETE:break;
    case KVS_CMD_ZEXIST:break;
    // cmd
    case KVS_CMD_ERROR:break;
    case KVS_CMD_QUIT:break;
    case KVS_CMD_TOTAL:break;
    }
}

int kvs_split_tokens(char** tokens, char* msg)
{
    int count = 0;
    char *token = strtok(msg, " ");
    while(token != NULL){
        tokens[count++] = token;
        token = strtok(NULL, " ");
    }   
    return count;
}

int kvs_protocol(char* msg, int length)
{
    char * tokens[MAX_TOKENS] = {0};
    int count = kvs_split_tokens(tokens, msg);
    return kvs_parser_protocol(tokens, count);
}