/**
 * @file aiot_dynreg_api.c
 * @brief dynreg模块的API接口实现, 提供获取设备信息的能力
 *
 * @copyright Copyright (C) 2015-2020 Alibaba Group Holding Limited
 *
 */
#include "dynreg_private.h"

#include "core_string.h"
#include "core_log.h"
#include "core_auth.h"

static void _dynreg_exec_inc(dynreg_handle_t *dynreg_handle)
{
    dynreg_handle->sysdep->core_sysdep_mutex_lock(dynreg_handle->data_mutex);
    dynreg_handle->exec_count++;
    dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
}

static void _dynreg_exec_dec(dynreg_handle_t *dynreg_handle)
{
    dynreg_handle->sysdep->core_sysdep_mutex_lock(dynreg_handle->data_mutex);
    dynreg_handle->exec_count--;
    dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
}

static int32_t _dynreg_sign(dynreg_handle_t *dynreg_handle, char *random, char sign_str[65])
{
    int32_t res = STATE_SUCCESS;
    uint8_t sign_hex[32] = {0};
    char *src_fmt = "deviceName%sproductKey%srandom%s";
    char *src[] = {dynreg_handle->device_name, dynreg_handle->product_key, random};
    char *plain_text = NULL;

    res = core_sprintf(dynreg_handle->sysdep, &plain_text, src_fmt, src, sizeof(src) / sizeof(char *), DYNREG_MODULE_NAME);
    if (res < STATE_SUCCESS) {
        return res;
    }

    core_hmac_sha256((const uint8_t *)plain_text, (uint32_t)strlen(plain_text),
                     (const uint8_t *)dynreg_handle->product_secret, (uint32_t)strlen(dynreg_handle->product_secret), sign_hex);
    core_hex2str(sign_hex, 32, sign_str, 0);
	if(plain_text != NULL)
    dynreg_handle->sysdep->core_sysdep_free(plain_text);

    return STATE_SUCCESS;
}

static void _dynreg_recv_handler(void *handle, const aiot_http_recv_t *packet, void *userdata)
{
    dynreg_handle_t *dynreg_handle = (dynreg_handle_t *)userdata;

    if (dynreg_handle->recv_handler == NULL) {
        return;
    }

    switch (packet->type) {
        case AIOT_HTTPRECV_STATUS_CODE: {
            dynreg_handle->response.code = packet->data.status_code.code;
        }
        break;
        case AIOT_HTTPRECV_HEADER: {
            if ((strlen(packet->data.header.key) == strlen("Content-Length")) &&
                (memcmp(packet->data.header.key, "Content-Length", strlen(packet->data.header.key)) == 0)) {
                core_str2uint(packet->data.header.value, (uint8_t)strlen(packet->data.header.value),
                              &dynreg_handle->response.content_total_len);
            }
        }
        break;
        case AIOT_HTTPRECV_BODY: {
            uint8_t *content = dynreg_handle->sysdep->core_sysdep_malloc(dynreg_handle->response.content_len + packet->data.body.len
                               + 1,
                               CORE_HTTP_MODULE_NAME);
            if (content == NULL) {
                return;
            }
            memset(content, 0, dynreg_handle->response.content_len + packet->data.body.len + 1);
            if (content != NULL) {
                memcpy(content, dynreg_handle->response.content, dynreg_handle->response.content_len);
				if(dynreg_handle->response.content != NULL)
                	dynreg_handle->sysdep->core_sysdep_free(dynreg_handle->response.content);
            }
            memcpy(content + dynreg_handle->response.content_len, packet->data.body.buffer, packet->data.body.len);
            dynreg_handle->response.content = content;
            dynreg_handle->response.content_len = dynreg_handle->response.content_len + packet->data.body.len;
        }
        break;
        default: {

        }
        break;
    }
}

static int32_t _dynreg_device_info(dynreg_handle_t *dynreg_handle, char **device_secret)
{
    int32_t res = STATE_SUCCESS;
    char *tmp_ds = NULL, *ds_key = "deviceSecret";
    char *ds_value = NULL;
    uint32_t ds_value_len = 0;

    if (dynreg_handle->response.code != 200) {
        return STATE_DYNREG_INVALID_STATUS_CODE;
    }

    if ((res = core_json_value((char *)dynreg_handle->response.content, dynreg_handle->response.content_len, ds_key,
                               strlen(ds_key), &ds_value, &ds_value_len)) < STATE_SUCCESS) {
        return STATE_DYNREG_INVALID_DEVICE_SECRET;
    }

    tmp_ds = dynreg_handle->sysdep->core_sysdep_malloc(ds_value_len + 1, DYNREG_MODULE_NAME);
    if (tmp_ds == NULL) {
        return STATE_SYS_DEPEND_MALLOC_FAILED;
    }
    memset(tmp_ds, 0, ds_value_len + 1);
    memcpy(tmp_ds, ds_value, ds_value_len);

    *device_secret = tmp_ds;

    return STATE_SUCCESS;
}

void *aiot_dynreg_init(void)
{
    dynreg_handle_t *dynreg_handle = NULL;
    aiot_sysdep_portfile_t *sysdep = NULL;

	aiot_sysdep_set_portfile(&g_aiot_sysdep_portfile);

    sysdep = aiot_sysdep_get_portfile();
    if (sysdep == NULL) {
        return NULL;
    }

    dynreg_handle = sysdep->core_sysdep_malloc(sizeof(dynreg_handle_t), DYNREG_MODULE_NAME);
    if (dynreg_handle == NULL) {
        return NULL;
    }
    memset(dynreg_handle, 0, sizeof(dynreg_handle_t));

    dynreg_handle->sysdep = sysdep;
    dynreg_handle->response_body_len = DYNREG_RESPONSE_BODY_LEN;
    dynreg_handle->timeout_ms = DYNREG_DEFAULT_TIMEOUT_MS;
    dynreg_handle->deinit_timeout_ms = DYNREG_DEFAULT_DEINIT_TIMEOUT_MS;
    dynreg_handle->send_timeout_ms = DYNREG_DEFAULT_SEND_TIMEOUT;
    dynreg_handle->recv_timeout_ms = DYNREG_DEFAULT_RECV_TIMEOUT;
    dynreg_handle->data_mutex = dynreg_handle->sysdep->core_sysdep_mutex_init();

    dynreg_handle->exec_enabled = 1;

    return dynreg_handle;
}

int32_t aiot_dynreg_setopt(void *handle, aiot_dynreg_option_t option, void *data)
{
    int32_t res = STATE_SUCCESS;
    dynreg_handle_t *dynreg_handle = (dynreg_handle_t *)handle;

    if (dynreg_handle == NULL || data == NULL) {
        return STATE_USER_INPUT_NULL_POINTER;
    }

    if (option >= AIOT_DYNREGOPT_MAX) {
        return STATE_USER_INPUT_OUT_RANGE;
    }

    if (dynreg_handle->exec_enabled == 0) {
        return STATE_USER_INPUT_EXEC_DISABLED;
    }

    _dynreg_exec_inc(dynreg_handle);

    dynreg_handle->sysdep->core_sysdep_mutex_lock(dynreg_handle->data_mutex);
    switch (option) {
        case AIOT_DYNREGOPT_NETWORK_CRED: {
            if (dynreg_handle->cred != NULL) {
                dynreg_handle->sysdep->core_sysdep_free(dynreg_handle->cred);
                dynreg_handle->cred = NULL;
            }
            dynreg_handle->cred = dynreg_handle->sysdep->core_sysdep_malloc(sizeof(aiot_sysdep_network_cred_t), DYNREG_MODULE_NAME);
            if (dynreg_handle->cred != NULL) {
                memset(dynreg_handle->cred, 0, sizeof(aiot_sysdep_network_cred_t));
                memcpy(dynreg_handle->cred, data, sizeof(aiot_sysdep_network_cred_t));
            } else {
                res = STATE_SYS_DEPEND_MALLOC_FAILED;
            }
        }
        break;
        case AIOT_DYNREGOPT_HOST: {
            res = core_strdup(dynreg_handle->sysdep, &dynreg_handle->host, data, DYNREG_MODULE_NAME);
        }
        break;
        case AIOT_DYNREGOPT_PORT: {
            dynreg_handle->port = *(uint16_t *)data;
        }
        break;
		case AIOT_DYNREGOPT_PROFILE_IDX: {
			dynreg_handle->pdp = *(uint16_t *)data;
		}
		break;
        case AIOT_DYNREGOPT_PRODUCT_KEY: {
            res = core_strdup(dynreg_handle->sysdep, &dynreg_handle->product_key, data, DYNREG_MODULE_NAME);
        }
        break;
        case AIOT_DYNREGOPT_PRODUCT_SECRET: {
            res = core_strdup(dynreg_handle->sysdep, &dynreg_handle->product_secret, data, DYNREG_MODULE_NAME);
        }
        break;
        case AIOT_DYNREGOPT_DEVICE_NAME: {
            res = core_strdup(dynreg_handle->sysdep, &dynreg_handle->device_name, data, DYNREG_MODULE_NAME);
        }
        break;
		case AIOT_DYNREGOPT_CONNECT_TIMEOUT_MS: {
            dynreg_handle->connect_timeout_ms = *(uint32_t *)data;
        }
        break;
        case AIOT_DYNREGOPT_SEND_TIMEOUT_MS: {
            dynreg_handle->send_timeout_ms = *(uint32_t *)data;
        }
        break;
        case AIOT_DYNREGOPT_RECV_TIMEOUT_MS: {
            dynreg_handle->recv_timeout_ms = *(uint32_t *)data;
        }
        break;
        case AIOT_DYNREGOPT_RECV_HANDLER: {
            dynreg_handle->recv_handler = (aiot_dynreg_recv_handler_t)data;
        }
        break;
        case AIOT_DYNREGOPT_USERDATA: {
            dynreg_handle->userdata = data;
        }
        break;
        case AIOT_DYNREGOPT_TIMEOUT_MS: {
            dynreg_handle->timeout_ms = *(uint32_t *)data;
        }
        break;
        case AIOT_DYNREGOPT_DEINIT_TIMEOUT_MS: {
            dynreg_handle->deinit_timeout_ms = *(uint32_t *)data;
        }
        break;
        default: {
            res = STATE_USER_INPUT_UNKNOWN_OPTION;
        }
        break;
    }
    dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);

    _dynreg_exec_dec(dynreg_handle);

    return res;
}

int32_t aiot_dynreg_deinit(void **handle)
{
    uint64_t deinit_timestart = 0;
    dynreg_handle_t *dynreg_handle = NULL;
    aiot_sysdep_portfile_t *sysdep = NULL;

    if (handle == NULL || *handle == NULL) {
        return STATE_USER_INPUT_NULL_POINTER;
    }

    dynreg_handle = *(dynreg_handle_t **)handle;
    sysdep = dynreg_handle->sysdep;

    if (dynreg_handle->exec_enabled == 0) {
        return STATE_USER_INPUT_EXEC_DISABLED;
    }

    dynreg_handle->exec_enabled = 0;
    deinit_timestart = dynreg_handle->sysdep->core_sysdep_time();
    do {
        if (dynreg_handle->exec_count == 0) {
            break;
        }
        dynreg_handle->sysdep->core_sysdep_sleep(DYNREG_DEINIT_INTERVAL_MS);
    } while ((dynreg_handle->sysdep->core_sysdep_time() - deinit_timestart) < dynreg_handle->deinit_timeout_ms);

    if (dynreg_handle->exec_count != 0) {
        return STATE_DYNREG_DEINIT_TIMEOUT;
    }

    *handle = NULL;

    if (dynreg_handle->response.content != NULL) {
        sysdep->core_sysdep_free(dynreg_handle->response.content);
    }
    memset(&dynreg_handle->response, 0, sizeof(core_http_response_t));

    if (dynreg_handle->http_handle != NULL) {
        core_http_deinit(&dynreg_handle->http_handle);
    }

    if (dynreg_handle->host != NULL) {
        sysdep->core_sysdep_free(dynreg_handle->host);
    }

    if (dynreg_handle->product_key != NULL) {
        sysdep->core_sysdep_free(dynreg_handle->product_key);
    }

    if (dynreg_handle->product_secret != NULL) {
        sysdep->core_sysdep_free(dynreg_handle->product_secret);
    }

    if (dynreg_handle->device_name != NULL) {
        sysdep->core_sysdep_free(dynreg_handle->device_name);
    }

    if (dynreg_handle->cred != NULL) {
        sysdep->core_sysdep_free(dynreg_handle->cred);
    }

    sysdep->core_sysdep_mutex_deinit(&dynreg_handle->data_mutex);

    sysdep->core_sysdep_free(dynreg_handle);

    return STATE_SUCCESS;
}

int32_t aiot_dynreg_send_request(void *handle)
{
    int32_t res = STATE_SUCCESS;
    dynreg_handle_t *dynreg_handle = (dynreg_handle_t *)handle;

    if (dynreg_handle == NULL) {
        return STATE_USER_INPUT_NULL_POINTER;
    }

    if (dynreg_handle->host == NULL) {
        return STATE_USER_INPUT_MISSING_HOST;
    }

    if (dynreg_handle->product_key == NULL) {
        return STATE_USER_INPUT_MISSING_PRODUCT_KEY;
    }

    if (dynreg_handle->product_secret == NULL) {
        return STATE_USER_INPUT_MISSING_PRODUCT_SECRET;
    }

    if (dynreg_handle->device_name == NULL) {
        return STATE_USER_INPUT_MISSING_DEVICE_NAME;
    }

    if (dynreg_handle->exec_enabled == 0) {
        return STATE_USER_INPUT_EXEC_DISABLED;
    }

    _dynreg_exec_inc(dynreg_handle);

    dynreg_handle->sysdep->core_sysdep_mutex_lock(dynreg_handle->data_mutex);
    if (dynreg_handle->response.content != NULL) {
        dynreg_handle->sysdep->core_sysdep_free(dynreg_handle->response.content);
    }
    memset(&dynreg_handle->response, 0, sizeof(core_http_response_t));

    if (dynreg_handle->http_handle != NULL) {
        core_http_deinit(&dynreg_handle->http_handle);
    }

    dynreg_handle->http_handle = core_http_init();
    if (dynreg_handle->http_handle == NULL) {
        dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
        _dynreg_exec_dec(dynreg_handle);
        return STATE_SYS_DEPEND_MALLOC_FAILED;
    }

	//uart_printf("func:%s  line:%d    dynreg_handle->pdp : %d ,dynreg_handle->connect_timeout_ms: %d \r\n",__func__,__LINE__,dynreg_handle->pdp,dynreg_handle->connect_timeout_ms);
    if (((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_HOST,
                                 (void *)dynreg_handle->host)) < STATE_SUCCESS) ||
        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_PORT, (void *)&dynreg_handle->port)) < STATE_SUCCESS)
        ||
        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_PROFILE_IDX, (void *)&dynreg_handle->pdp)) < STATE_SUCCESS)
        ||
        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_NETWORK_CRED,
                                 (void *)dynreg_handle->cred)) < STATE_SUCCESS) ||
		((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_CONNECT_TIMEOUT_MS,
                                 (void *)&dynreg_handle->timeout_ms)) < STATE_SUCCESS) ||
        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_SEND_TIMEOUT_MS,
                                 (void *)&dynreg_handle->send_timeout_ms)) < STATE_SUCCESS) ||
        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_RECV_TIMEOUT_MS,
                                 (void *)&dynreg_handle->recv_timeout_ms)) < STATE_SUCCESS) ||
        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_BODY_BUFFER_MAX_LEN,
                                 (void *)&dynreg_handle->response_body_len)) < STATE_SUCCESS) ||
        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_RECV_HANDLER,
                                 (void *)_dynreg_recv_handler)) < STATE_SUCCESS) ||
        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_USERDATA, (void *)dynreg_handle)) < STATE_SUCCESS)) {
        core_http_deinit(&dynreg_handle->http_handle);
        dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
        _dynreg_exec_dec(dynreg_handle);
        return res;
    }

    res = core_http_connect(dynreg_handle->http_handle);
    if (res < STATE_SUCCESS) {
        core_http_deinit(&dynreg_handle->http_handle);
        dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
        _dynreg_exec_dec(dynreg_handle);
        return res;
    }

    {
        uint32_t random_num = 0;
        char random[11] = {0};
        char sign_str[65] = {0};
        char *content = NULL;
        char *content_fmt = "productKey=%s&deviceName=%s&random=%s&sign=%s&signMethod=hmacsha256";
        char *content_src[] = { dynreg_handle->product_key, dynreg_handle->device_name, (char *)random, sign_str };
        core_http_request_t request;

        dynreg_handle->sysdep->core_sysdep_rand((uint8_t *)&random_num, 4);
        core_uint2str(random_num, random, NULL);

        res = _dynreg_sign(dynreg_handle, (char *)random, sign_str);
        if (res < STATE_SUCCESS) {
            core_http_deinit(&dynreg_handle->http_handle);
            dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
            _dynreg_exec_dec(dynreg_handle);
            return res;
        }


        memset(&request, 0, sizeof(core_http_request_t));
        res = core_sprintf(dynreg_handle->sysdep, &content, content_fmt, content_src, sizeof(content_src) / sizeof(char *),
                           DYNREG_MODULE_NAME);
        if (res < STATE_SUCCESS) {
            core_http_deinit(&dynreg_handle->http_handle);
            dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
            _dynreg_exec_dec(dynreg_handle);
            return res;
        }
        request.method = "POST";
        request.path = DYNREG_PATH;
        request.header = "Accept: text/xml,text/javascript,text/html,application/json\r\n" \
                         "Content-Type: application/x-www-form-urlencoded\r\n";
        request.content = (uint8_t *)content;
        request.content_len = (uint32_t)strlen(content);

        res = core_http_send(dynreg_handle->http_handle, &request);
        dynreg_handle->sysdep->core_sysdep_free(content);
        if (res < STATE_SUCCESS) {
            core_http_deinit(&dynreg_handle->http_handle);
            dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
            _dynreg_exec_dec(dynreg_handle);
            return res;
        }
    }
    dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
    _dynreg_exec_dec(dynreg_handle);

    return res;
}

int32_t aiot_dynreg_recv(void *handle)
{
    int32_t res = STATE_SUCCESS;
    uint64_t timenow_ms = 0;
    dynreg_handle_t *dynreg_handle = (dynreg_handle_t *)handle;
    char *device_secret = NULL;
    aiot_dynreg_recv_t packet;

    if (dynreg_handle == NULL) {
        return STATE_USER_INPUT_NULL_POINTER;
    }

    if (dynreg_handle->http_handle == NULL) {
        return STATE_DYNREG_NEED_SEND_REQUEST;
    }

    if (dynreg_handle->exec_enabled == 0) {
        return STATE_USER_INPUT_EXEC_DISABLED;
    }

    _dynreg_exec_inc(dynreg_handle);

    dynreg_handle->sysdep->core_sysdep_mutex_lock(dynreg_handle->data_mutex);
    timenow_ms = dynreg_handle->sysdep->core_sysdep_time();
    while (1) {
        if (timenow_ms >= dynreg_handle->sysdep->core_sysdep_time()) {
            timenow_ms = dynreg_handle->sysdep->core_sysdep_time();
        }
        if (dynreg_handle->sysdep->core_sysdep_time() - timenow_ms >= dynreg_handle->timeout_ms) {
            break;
        }

        res = core_http_recv(dynreg_handle->http_handle);
        if (res < STATE_SUCCESS) {
            break;
        }
    }

    if (res < STATE_SUCCESS) {
        if (res != STATE_HTTP_READ_BODY_FINISHED) {
            if (dynreg_handle->response.content != NULL) {
                dynreg_handle->sysdep->core_sysdep_free(dynreg_handle->response.content);
                memset(&dynreg_handle->response, 0, sizeof(core_http_response_t));
            }
            dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
            _dynreg_exec_dec(dynreg_handle);
            return res;
        } else {
            res = STATE_SUCCESS;
        }
    } else {
        dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
        _dynreg_exec_dec(dynreg_handle);
        return STATE_HTTP_RECV_NOT_FINISHED;
    }

    if (dynreg_handle->recv_handler != NULL) {
        packet.type = AIOT_DYNREGRECV_STATUS_CODE;
        packet.data.status_code.code = dynreg_handle->response.code;

        dynreg_handle->recv_handler(dynreg_handle, &packet, dynreg_handle->userdata);
    }

    res = _dynreg_device_info(dynreg_handle, &device_secret);
    dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
    if (res < STATE_SUCCESS) {
        _dynreg_exec_dec(dynreg_handle);
        return res;
    }

    memset(&packet, 0, sizeof(aiot_dynreg_recv_t));
    if (dynreg_handle->recv_handler != NULL) {
        packet.type = AIOT_DYNREGRECV_DEVICE_INFO;
        packet.data.device_info.device_secret = device_secret;

        dynreg_handle->recv_handler(dynreg_handle, &packet, dynreg_handle->userdata);
    }
    dynreg_handle->sysdep->core_sysdep_free(device_secret);

    _dynreg_exec_dec(dynreg_handle);
    return STATE_SUCCESS;
}