/*
 * Copyright (C) 2015 - 2020 QXSI, all rights reserved.
 *
 * This is the demo program for the QXSI PS-SDK.
 * The implementation here is just for reference, please refer to the header file `qxwz_sdk.h`
 * for the detailed definition of the structures and APIs.
 */

#include <stdio.h>
#include <string.h>
#include "qxwz_sdk.h"
#include "HIDO_Timer.h"
#include "HIDO_Debug.h"
#include "stm32f4xx_hal.h"
#include "Uart.h"
#include "global_param.h"
#define DEMO_GGA_STR        "$GPGGA,000001,3112.518576,N,12127.901251,E,1,8,1,0,M,-32,M,3,0*4B"

#define DEMO_LOG(fmt, ...)  HIDO_Debug("[DEMO]"fmt, ##__VA_ARGS__)


static qxwz_uint32_t glob_flag = 0;
static qxwz_uint64_t glob_ts = 0;
static HIDO_BOOL l_bAuth = HIDO_FALSE;

static qxwz_uint32_t sdk_auth_flag = 0;
static qxwz_uint32_t sdk_start_flag = 0;
static qxwz_sdk_cap_info_t sdk_cap_info = {0};
static HIDO_UINT32 l_u32QXWZ_SDKTimerID = 0;

static qxwz_void_t demo_show_caps(qxwz_sdk_cap_info_t *cap_info)
{
    qxwz_int32_t loop = 0;

    DEMO_LOG("total capabilities: %d\n", cap_info->caps_num);
    for (loop = 0; loop < cap_info->caps_num; ++loop) {
        DEMO_LOG("idx: %d, cap_id: %u, state: %d, act_method: %d, expire_time: %llu\n",
            loop + 1,
            cap_info->caps[loop].cap_id,
            cap_info->caps[loop].state,
            cap_info->caps[loop].act_method,
            cap_info->caps[loop].expire_time);
    }
}
int32_t state;
static qxwz_void_t demo_on_auth(qxwz_int32_t status_code, qxwz_sdk_cap_info_t *cap_info) {
    state = status_code;
    if (status_code == QXWZ_SDK_STAT_AUTH_SUCC) {
        sdk_auth_flag = 1;
        sdk_cap_info = *cap_info;
        demo_show_caps(cap_info);
        l_bAuth = HIDO_TRUE;
    } else {
       DEMO_LOG("auth failed, code=%d\n", status_code);
    }
}

static qxwz_void_t demo_on_start(qxwz_int32_t status_code, qxwz_uint32_t cap_id) {
    DEMO_LOG("on start cap:status_code=%d, cap_id=%d\n", status_code, cap_id);
    sdk_start_flag = 1;
}


static qxwz_void_t demo_on_status(int code)
{
    DEMO_LOG(" on status code: %d\n", code);
}

static qxwz_void_t demo_on_data(qxwz_uint32_t type, const qxwz_void_t *data, qxwz_uint32_t len)
{
    DEMO_LOG(" on data: %d, ptr: %p, len: %d\n", type, data, len);

    switch (type) {
        case QXWZ_SDK_DATA_TYPE_RAW_NOSR:
            DEMO_LOG("QXWZ_SDK_DATA_TYPE_RAW_NOSR\n");
        {
            UART_HandleTypeDef *pstUartHandle = HIDO_NULL;

            Uart_GetHandle(UART_ID_GPS, (HIDO_VOID **)&pstUartHandle);
            HAL_UART_Transmit(pstUartHandle, (HIDO_UINT8 *)data, len, 1000);
            break;
        }
        default:
            DEMO_LOG("unknown type: %d\n", type);
    }
}

static HIDO_VOID qxwz_app_TimerFunc(HIDO_VOID *_pArg)
{
    int ret = 0;
    static unsigned int tick = 0;
    static HIDO_BOOL bAuth = 0;

    if(Internet_IsIPReady() == HIDO_TRUE)
    {
        if (HIDO_FALSE == bAuth)
        {
            ret = qxwz_sdk_auth();
            if (ret >= 0)
            {
                bAuth = HIDO_TRUE;
            }
            else
            {
                HIDO_Debug("call sdk auth failed\n");
            }
        }
        else
        {
            ret = qxwz_sdk_tick(HIDO_TimerGetTick64() / 1000);
            if (ret < 0)
            {
                HIDO_Debug("sdk tick failed\n");
                return;
            }

            if (sdk_auth_flag > 0)
            {
                sdk_auth_flag = 0;
                for (int i = 0; i < sdk_cap_info.caps_num; i++)
                {
                    if (sdk_cap_info.caps[i].cap_id == QXWZ_SDK_CAP_ID_NOSR
                            && sdk_cap_info.caps[i].state == QXWZ_SDK_CAP_STATE_INSERVICE)
                    {
                        qxwz_sdk_start(QXWZ_SDK_CAP_ID_NOSR); /* start LSSR capability */
                    }
                }
            }
        }
    }
}

int qxwz_app_upload_gga(HIDO_CHAR *_pGGA)
{
    if(HIDO_TRUE == l_bAuth)
    {
        qxwz_sdk_upload_gga(_pGGA, strlen(_pGGA));
    }
}
  qxwz_sdk_config_t sdk_config = { 0 };
int qxwz_app_init(void)
{
    /*
     * ** WARNING **
     * PLEASE FIRST CONFIRM THAT YOUR ACCOUNT IS AK OR DSK ?!?
     *
     * If your account is AK (usually with prefix `A`, like: `A00012dwejd`), set the `key_type` to `QXWZ_SDK_KEY_TYPE_AK`.
     * Otherwise, if it is DSK (usually with prefix `D`, like: `D0234jdwejd`), set the `key_type` to `QXWZ_SDK_KEY_TYPE_DSK`.
     * ** WARNING **
     */
  
    /* AK or DSK ? Only choose one in the following codes! */
    /** AK */
//    sdk_config.key_type = QXWZ_SDK_KEY_TYPE_AK, strcpy(sdk_config.key, "A4982bn3p5b9");//A4901osgv62b  A4982bn3p5b9
//    strcpy(sdk_config.secret, "3cb4955bf6310c95");//edc0688222100fad   3cb4955bf6310c95
//    /** DSK */
////    sdk_config.key_type = QXWZ_SDK_KEY_TYPE_DSK, strcpy(sdk_config.key, "Your DSK");
////    strcpy(sdk_config.secret, "Your DSS");

//    /* set device info */
//    strcpy(sdk_config.dev_id, "test1");
//    strcpy(sdk_config.dev_type, "KeDaFangCheng");
    sdk_config.key_type = QXWZ_SDK_KEY_TYPE_AK, strcpy(sdk_config.key, (char*)&g_com_map[QXWZ_APPKEY_INDEX]);//A4901osgv62b  A4982bn3p5b9
    strcpy(sdk_config.secret, (char*)&g_com_map[QXWZ_APPSECRET_INDEX]);//edc0688222100fad   3cb4955bf6310c95
    strcpy(sdk_config.dev_type, (char*)&g_com_map[QXWZ_DEVTYPE_INDEX]);
    strcpy(sdk_config.dev_id, (char*)&g_com_map[QXWZ_DEVID_INDEX]);
    /* set callbacks */
    sdk_config.status_cb = demo_on_status;
    sdk_config.data_cb = demo_on_data;
    sdk_config.auth_cb = demo_on_auth;
    sdk_config.start_cb = demo_on_start;

    int ret = 0;


    /*
     * init sdk
     */
    ret = qxwz_sdk_init(&sdk_config);
    if (ret < 0)
    {
        HIDO_Debug("sdk init failed\n");
        goto END;
    }

    HIDO_TimerCreate(&l_u32QXWZ_SDKTimerID);
    HIDO_TimerStart(l_u32QXWZ_SDKTimerID, HIDO_TIMER_TYPE_LOOP, HIDO_TIMER_TICK_MS(10), qxwz_app_TimerFunc, HIDO_NULL);

    return 0;

END:
    qxwz_sdk_cleanup();
    return 0;
}