#include "tp_cmd_process.h"
#include "ate_at_process.h"
#include "ate_cmd_manager.h"
#include "common_def.h"
#include "securec.h"
#include "soc_errno.h"
#include "soc_osal.h"
#include "tp_api.h"
#include "rtc.h"

#define ARRAY_COUNT(array) (sizeof(array) / sizeof(array[0]))

tp_at_cmd_api *g_tp_process_api = NULL;

void tp_cmd_process_init(void)
{
    if (g_tp_process_api == NULL) {
        g_tp_process_api = (tp_at_cmd_api *)tjd_driver_tp_get_at_cmd_api();
    }
}

result_t get_chipid(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    uint16_t chip_id;
    result.code = g_tp_process_api->get_chipid(&chip_id);
    if (result.code == EXT_ERR_SUCCESS) {
        result.len = snprintf((char *)result.msg, ATE_MSG_MAX_LEN, "0x%x", chip_id);
    }
    return result;
}

result_t get_version(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    uint16_t version;
    result.code = g_tp_process_api->get_version(&version);
    if (result.code == EXT_ERR_SUCCESS) {
        result.len = snprintf((char *)result.msg, ATE_MSG_MAX_LEN, "%d", version);
    }
    return result;
}

result_t get_rawdata(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    uint8_t rawdata;
    result.code = g_tp_process_api->get_rawdata(&rawdata);
    if (result.code == EXT_ERR_SUCCESS) {
        result.len = snprintf((char *)result.msg, ATE_MSG_MAX_LEN, "0x%x", rawdata);
    }
    return result;
}

static void update_task(void *param)
{
    result_t result = {0};
    result.code = g_tp_process_api->fwupg_auto_upgrade();
    process_at_cmd_ret(result);
}

result_t test_update(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    result.out_time = 5000;
    result.callback = update_task;
    return result;
}

result_t set_open(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    if (para_len < 1) {
        result.code = EXT_ERR_INVALID_PARAM;
        return result;
    }
    int32_t argc = 0;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);

    if (IS_ON(argv[0])) {
        result.code = g_tp_process_api->set_open(true);
    } else if (IS_OFF(argv[0])) {
        result.code = g_tp_process_api->set_open(false);
    } else {
        result.code = EXT_ERR_INVALID_PARAM;
    }
    free_argv(argv, argc);

    return result;
}

result_t test_touch(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    return result;
}

result_t set_power(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    if (para_len < 1) {
        result.code = EXT_ERR_INVALID_PARAM;
        return result;
    }
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);

    if (strnlen((const char *)argv[0], 2) != 1) {
        result.code = EXT_ERR_INVALID_PARAM;
        return result;
    }
    switch (argv[0][0]) {
    case '0': /*work*/
        g_tp_process_api->set_power_mode(0);
        break;
    case '1': /*idle*/
        g_tp_process_api->set_power_mode(1);
        break;
    case '2': /*sleep*/
        g_tp_process_api->set_power_mode(2);
        break;
    default:
        result.code = EXT_ERR_INVALID_PARAM;
        break;
    }
    free_argv(argv, argc);
    return result;
}