#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include "rpc.h"
#include "configm.h"


config_service_t g_config_service[] = CONFIG_SERVICE_ARRAY;

void test_big_data(rpc_conn *conn, pointer input, int input_len, void* data) {
	char buf[input_len];
	memcpy(buf, input, input_len);
	buf[input_len] = '\0';
	printf("get data is %s\n", buf);
	//sleep(15);
	rpc_return_null(conn);
}

void cm_return(rpc_conn *conn, ret_code err_code, char* err_message)
{
    cJSON *res;
    char *ret_char = NULL;

    res = cJSON_CreateObject();
    if(res == NULL)
    {
        return;
    }
    
    cJSON_AddStringToObject(res, "result", err_message);
    ret_char = cJSON_PrintUnformatted(res);
        
    cJSON_Delete(res);

    rpc_return_error(conn, err_code, ret_char);    
    rpc_free(ret_char);
    
    return;
}

config_service_t *cm_config_service_get(uint64 config_id)
{
    int len = sizeof(g_config_service) / sizeof(config_service_t);
    int config_idx;

    for(config_idx = 0; config_idx < len; config_idx++)
    {
        if(config_id == g_config_service[config_idx].config_id)
        {
            return &(g_config_service[config_idx]);
        }
    }

    return NULL;
}

ret_code cm_config_rec_pre(char **input, int *input_len, char **output, int *output_len)
{
    /*if((access(CONFIG_RECOVERY_DONE, F_OK))!=-1)   
    {   
        return RET_ERR;
    } */  
    
    *input = rpc_new(char, CM_BUFF_SIZE);    
    *output = rpc_new(char, CM_BUFF_SIZE); 
    *input_len = CM_BUFF_SIZE;
    *output_len = CM_BUFF_SIZE;
    
    if(*input == NULL 
        || *output == NULL)
    {
        return RET_NOMEM;
    }
        
    memset(*input, 0, CM_BUFF_SIZE);
    memset(*output, 0, CM_BUFF_SIZE);
    
    rpc_log_info("==>config revocery start\n");
    
    return RET_OK;
}

ret_code cm_config_rec_done(char *input, char *output)
{
    int fd;
       
    memset(input, 0, CM_BUFF_SIZE);
    memset(output, 0, CM_BUFF_SIZE);

    free(input);   
    free(output);
    
    fd = open(CONFIG_RECOVERY_DONE, O_CREAT, 0777);
    if(fd <= 0)
    {
        rpc_log_error("create recovery file error");
    }
    else
    {
        close(fd);
    }
    
    rpc_log_info("==>config revocery done!\n");

    return RET_OK;
}

ret_code cm_config_get_allconfig(uint source,
                                 config_service_t *config_svr, 
                                 char *input, int *intput_len)
{    
    ret_code ret = RET_OK;
    
    memset(input, 0, CM_BUFF_SIZE);
    
    ret = config_svr->getall_callback(source, input, intput_len);
    ASSERT_RET(ret);
    
    return ret;
}

 ret_code cm_config_config_rec(uint source,
                               config_service_t *config_svr, 
                               char *input,  int input_len,
                               char *output, int *output_len)
 {  
    int config_type = CM_CONFIG_SET;
    ret_code ret = RET_OK;
    cJSON *json_obj;
    cJSON* pArrayItem;
    char *json_str;
    char *config_buff;
    int config_len;
    int iCount = 0;
    int i = 0;

     json_obj = cJSON_Parse(input);
     if(!json_obj)
     {
         return RET_INPUTERR;
     }

     config_buff = rpc_new(char, CM_BUFF_SIZE);
     if(!config_buff)
     {
         cJSON_Delete(json_obj);
         return RET_NOMEM;
     }

    rpc_log_info("config recover: %s \n", cJSON_Print(json_obj));

    iCount = cJSON_GetArraySize(json_obj); /*获取数组长度*/

    for(i = 0; i < iCount; i++)
    {
        pArrayItem = cJSON_GetArrayItem(json_obj, i);
        if(pArrayItem)
        {
            json_str = cJSON_PrintUnformatted(pArrayItem);
            config_len = strlen(json_str) + 1;

            memset(config_buff, 0, CM_BUFF_SIZE);
            strncpy(config_buff, json_str, CM_BUFF_SIZE - 1);

            free(json_str);

            ret = config_svr->chk_callback(source, &config_type,
                                           config_buff, &config_len, 
                                           output, output_len);
            if(ret != RET_OK)
            {
                continue;
            }
            
            config_svr->proc_callback(source, config_type, 
                                      config_buff, config_len,
                                      output, output_len);
        }
    }

    rpc_free(config_buff);
    cJSON_Delete(json_obj);

    return RET_OK;
 }


/* 配置恢复 */
void cm_config_recovery()
{
    int len = sizeof(g_config_service) / sizeof(config_service_t);
    config_service_t *config_svr;    
    int input_len = 0;
    int output_len = 0;
    char *input = NULL;
    char *output = NULL;    
    ret_code ret = RET_OK;
    int config_idx;
    int recover_idx = 1,recover_phase;

    ret = cm_config_rec_pre(&input, &input_len, &output, &output_len);
    ASSERT_RET_VOID(ret);

    while(recover_idx <= 2)
    {
        if(recover_idx == 1)
        {
            recover_phase = CONFIG_FROM_RECOVER1;
        }
        else if(recover_idx == 2)
        {
            recover_phase = CONFIG_FROM_RECOVER2;
        }
        else
        {
            break;
        }
        
        for(config_idx = 0; config_idx < len; config_idx++)
        {
            config_svr = &(g_config_service[config_idx]);

            if(config_svr->recovery != TRUE)
            {
                continue;
            }
            
            if(config_svr->chk_callback == NULL 
                || config_svr->proc_callback == NULL)
            {
                continue;
            }

            cm_config_get_allconfig(recover_phase, config_svr, 
                                    input, &input_len);

            cm_config_config_rec(recover_phase, config_svr, 
                                 input, input_len, 
                                 output, &output_len);
        }
        
        recover_idx++;
    }
    
    cm_config_rec_done(input, output);
    
    return;
}

/* 配置处理入口函数，所有的配置，均在此函数中处理 */
void cm_config_process(rpc_conn *conn, pointer input, int input_len, void* data)
{        
    config_service_t *config_svr;
    config_msg_t *config_msg;
    char *cm_get_buff = NULL;
    char *cm_set_buff = NULL;
    ret_code ret = RET_OK;
    int config_len = 0;
    int buff_len = CM_BUFF_SIZE;

    if(conn == NULL || input == NULL)
    {
        cm_return(conn, RET_NULLP, "NULL pointer");
        return;
    }

    /*parse message*/
    if(input_len < sizeof(config_msg_t))
    {
        cm_return(conn, RET_NOMEM, "not enough memery");
        return;
    }
    
    config_msg = (config_msg_t *)input;
    config_len = input_len - sizeof(config_msg_t);

    rpc_log_info("recv config from %d, config type is %d config id is 0x%llx ,len is %d\r\n",
                 config_msg->source, config_msg->config_type, config_msg->config_id,
                 config_len);
    
    config_svr = cm_config_service_get(config_msg->config_id);
    if(config_svr == NULL)
    {
        cm_return(conn, RET_NULLP, "NULL pointer");
        return;
    }
    
    /*source check*/
    if(!(config_svr->config_src & config_msg->source))
    {
        cm_return(conn, RET_CHKERR, "source check error!\r\n");
        return;
    }

    cm_set_buff = rpc_new(char, buff_len);
    cm_get_buff = rpc_new(char, buff_len);
    if(cm_get_buff == NULL || cm_set_buff == NULL)
    {
        cm_return(conn, RET_NOMEM, "not enough memery");
        return;
    }
    
    memset(cm_set_buff, 0, buff_len);
    memset(cm_get_buff, 0, buff_len);

    memcpy(cm_set_buff, config_msg->config_buff, config_len);
    
    /*config check*/
    if(config_svr->chk_callback)
    {
        ret = config_svr->chk_callback(config_msg->source,
                                       &(config_msg->config_type),
                                       cm_set_buff, 
                                       &config_len, 
                                       cm_get_buff, 
                                       &buff_len);
        if(ret != RET_OK)
        {
            cm_return(conn, ret, cm_get_buff);
            goto exit;
        }
    }
    
    /*config exec*/
    switch(config_msg->config_type)
    {            
        case CM_CONFIG_GET:
            if(config_svr->get_callback)
            {
                ret = config_svr->get_callback(config_msg->source, 
                                               cm_set_buff, 
                                               config_len, 
                                               cm_get_buff, 
                                               &buff_len);
            }
            break;
            
        case CM_CONFIG_GET_ALL:
            if(config_svr->getall_callback)
            {   
                
                ret = config_svr->getall_callback(config_msg->source, 
                                                  cm_get_buff, 
                                                  &buff_len); 
            }
            break;
        case CM_CONFIG_ADD:
        case CM_CONFIG_DEL:
        case CM_CONFIG_SET:
            if(config_svr->proc_callback)
            {
                ret = config_svr->proc_callback(config_msg->source, 
                                                config_msg->config_type,
                                                cm_set_buff, 
                                                config_len, 
                                                cm_get_buff, 
                                                &buff_len);
            }
            break;
        default:
            ret = RET_INPUTERR;
            break;
            
    }
    
    if(buff_len > CM_BUFF_SIZE)
    {
        ret = RET_NOMEM;
    }
    
    if(ret != RET_OK)
    {
        cm_return(conn, ret, cm_get_buff);
        goto exit;
    }
    
    rpc_return(conn, cm_get_buff, buff_len);
    
 exit: 
    rpc_free(cm_set_buff);
    rpc_free(cm_get_buff);
    
    return;
}


int main(int argc, char **argv) 
{
	rpc_server *server;
    
	if (server= rpc_server_create_ex("ConfigManger#0")) 
    {
		rpc_log_info("start server\n");
	} 
    else 
    {
		rpc_log_error("start server error\n");
        return EXIT_FAILURE;
	}

    /* 配置恢复 */
    cm_config_recovery();

    /* 注册配置处理函数 */
	rpc_server_regservice(server, "ConfigManger#0", "cm_config_process", cm_config_process);
	//rpc_server_regservice(server, "ConfigManger#0", "test_big_data", test_big_data);
    
	for(;;)
    {
		rpc_sleep(1000);
	}
	return EXIT_SUCCESS;
}