#include "turing_iot.h"
#include "turing_mqtt.h"
#include "http/http_cli.h"
#include "json_c/json.h"
#include "json_c/json_tokener.h"
#include "os/os_api.h"
#include "server/ai_server.h"

struct turing_info {
    httpcli_ctx ctx;
    const char *api_key;
    const char *device_id;
    u8   auth_flag;
    char client_id[65];
    char topic[129];
    char res_media_id[65];
    int  song_id;
    char song_url[1024];
    char song_title[256];
};

static OS_MUTEX iot_mutex;
static u8 turing_iot_close_flag = 1;

static int __http_post_mothed(const char *url, char *buffer, u32 length, int (*cb)(char *, void *), void *priv)
{
    int error = 0;
    http_body_obj http_body_buf;
    struct turing_info *f = (struct turing_info *)priv;
    httpcli_ctx *ctx = &f->ctx;

    log_d("url->%s\n", url);

    memset(&http_body_buf, 0x0, sizeof(http_body_obj));
    http_body_buf.recv_len = 0;
    http_body_buf.buf_len = 4 * 1024;
    http_body_buf.buf_count = 1;
    http_body_buf.p = (char *) malloc(http_body_buf.buf_len * sizeof(char));
    if (http_body_buf.p == NULL) {
        return -1;
    }

    os_mutex_pend(&iot_mutex, 0);
    if (turing_iot_close_flag) {
        free(http_body_buf.p);
        os_mutex_post(&iot_mutex);
        return -1;
    }
    memset(ctx, 0x0, sizeof(httpcli_ctx));
    ctx->url = url;
    ctx->priv = &http_body_buf;
    ctx->post_data = buffer;
    ctx->data_len  = length;
    ctx->data_format  = "application/json";
    ctx->connection = "close";
    ctx->timeout_millsec = 6000;

    error = httpcli_post(ctx);
    os_mutex_post(&iot_mutex);
    if (error == HERROR_OK) {
        log_d("recv : %s\n", http_body_buf.p);
        if (cb) {
            error = cb(http_body_buf.p, priv);
        }
    } else {
        error = -1;
    }

    if (http_body_buf.p) {
        free(http_body_buf.p);
    }

    return error;
}

int turing_iot_set_key(void *priv, const char *api_key, const char *device_id)
{
    struct turing_info *f = (struct turing_info *)priv;
    f->api_key = api_key;
    f->device_id = device_id;
    f->auth_flag = 1;
    return 0;
}

void *turing_iot_init(void)
{
    struct turing_info *f = (struct turing_info *)calloc(sizeof(struct turing_info), 1);
    if (!f) {
        return NULL;
    }

    if (!os_mutex_valid(&iot_mutex)) {
        os_mutex_create(&iot_mutex);
    }
    turing_iot_close_flag = 0;

    return f;
}

int turing_iot_uninit(void *priv)
{
    free(priv);
    return 0;
}

int turing_iot_qiut_notify(void *priv)
{
    int err;
    struct turing_info *f = (struct turing_info *)priv;
    turing_iot_close_flag = 1;

    if (!f) {
        return -1;
    }

    do {
        http_cancel_dns(&f->ctx);
        err = os_mutex_pend(&iot_mutex, 10);
        if (!err) {
            break;
        }
    } while (1);
    os_mutex_post(&iot_mutex);

    return 0;
}

__attribute__((weak)) const char *get_turing_version_code(void)
{
    return "0.0.0";
}

//49965
#define AUSTR "{\"apiKey\":\"%s\",\"productId\":\"%d\",\"devices\":[{\"deviceId\":\"%s\",\"mac\":\"%s\"}]}"

int turing_iot_authorize(void *priv, int product_id, const char *mac)
{
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;
    char buffer[512];

    int length = snprintf(buffer, sizeof(buffer), AUSTR, f->api_key, product_id, f->device_id, mac);

    ret = __http_post_mothed(IOT_ADDR"/vendor/new/authorize", buffer, length, NULL, priv);

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
        return -1;
    }

    return ret;
}

#define CHAUSTR "{\"apiKey\":\"%s\",\"deviceId\":\"%s\"}"

int turing_iot_check_authorize(void *priv)
{
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;
    char buffer[256];

    int length = snprintf(buffer, sizeof(buffer), CHAUSTR, f->api_key, f->device_id);

    ret = __http_post_mothed(IOT_ADDR"/vendor/new/device/status", buffer, length, NULL, priv);

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
        return -1;
    }

    return ret;
}

/************************************************************/

/*获取微信accessToke*/

/************************************************************/

static int get_topic_callback(char *data, void *priv)
{
    struct turing_info *f = (struct turing_info *)priv;
    int err = -1;
    json_object *new_obj = NULL;
    json_object *data1 = NULL;
    json_object *clientId = NULL;
    json_object *topic = NULL;

    new_obj = json_tokener_parse(data);
    if (!json_object_object_get_ex(new_obj, "payload", &data1)) {
        goto __result_exit;
    }

    if (!json_object_object_get_ex(data1, "clientId", &clientId)) {
        goto __result_exit;
    }

    if (!json_object_get_string(clientId) || !json_object_get_string_len(clientId)) {
        goto __result_exit;
    }

    if (!json_object_object_get_ex(data1, "topic", &topic)) {
        goto __result_exit;
    }

    if (!json_object_get_string(topic) || !json_object_get_string_len(topic)) {
        goto __result_exit;
    }

    strncpy(f->client_id, json_object_get_string(clientId), sizeof(f->client_id));
    f->client_id[sizeof(f->client_id) - 1] = 0;
    strncpy(f->topic, json_object_get_string(topic), sizeof(f->topic));
    f->topic[sizeof(f->topic) - 1] = 0;

    err = 0;

__result_exit:

    json_object_put(new_obj);

    return err;
}

#define GETOSTR "{\"apiKey\":\"%s\",\"deviceId\":\"%s\"}"

int turing_iot_get_topic(void *priv)
{
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;
    char buffer[256];

    int length = snprintf(buffer, sizeof(buffer), GETOSTR, f->api_key, f->device_id);

    ret = __http_post_mothed(IOT_ADDR"/iot/mqtt/topic", buffer, length, get_topic_callback, priv);

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
    }

    return ret;
}

#define NOSTSTR "{\"apiKey\":\"%s\",\"deviceId\":\"%s\",\"type\":%d,\"status\":{%s}}"

int turing_iot_notify_status(void *priv, u8 type, const char *status_buffer)
{
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;

    char *buffer = malloc(1024);
    if (!buffer) {
        return -1;
    }

    int length = snprintf(buffer, 1024, NOSTSTR, f->api_key, f->device_id, type, status_buffer);

    ret = __http_post_mothed(IOT_ADDR"/iot/status/notify", buffer, length, NULL, priv);

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
    }

    free(buffer);
    return ret;
}

/************************************************************/
#define BOUNDARY        			"--jieli&boundary&e3#due*hf$n"
static const char http_head_tab[] =
    "POST /resources/file/upload?apiKey=%s HTTP/1.1\r\n"
    "Host: iot-ai.tuling123.com\r\n"
    "User-Agent: */*\r\n"
    "Cache-Control: no-cache\r\n"
    "Connection: close\r\n"
    "Content-type: multipart/form-data; boundary="BOUNDARY"\r\n"
    "Content-Length: %d\r\n"
    "\r\n";

static const char http_data_f[] =
    "--"BOUNDARY"\r\n"
    "Content-Disposition: form-data; name=\"speech\"; filename=\"%s\"\r\n"
    "Content-Type: %s\r\n"
    "\r\n";

static const char http_data_b[] =
    "\r\n--"BOUNDARY"--\r\n";

static int __post_resources(const char *url, u8 *buffer, u32 length, int (*cb)(char *, void *), void *priv)
{
    int error = 0;
    int url_buf_len = 2048;
    char *url_buf = NULL;
    http_body_obj http_body_buf;

    struct turing_info *f = (struct turing_info *)priv;
    httpcli_ctx *ctx = &f->ctx;

    char *http_body_before_buf = NULL;
    int http_body_before_len = 0;

    memset(&http_body_buf, 0x0, sizeof(http_body_obj));

    url_buf = calloc(1, url_buf_len + sizeof(http_data_f) + 64);
    if (!url_buf) {
        goto __checkin_exit;
    }
    http_body_before_buf = url_buf + url_buf_len;

    http_body_buf.recv_len = 0;
    http_body_buf.buf_len = 1024;
    http_body_buf.buf_count = 1;
    http_body_buf.p = (char *) malloc(http_body_buf.buf_len * sizeof(char));
    if (http_body_buf.p == NULL) {
        goto __checkin_exit;
    }

    http_body_before_len = snprintf(http_body_before_buf, sizeof(http_data_f) + 64, http_data_f, "voice.amr", "application/octet-stream");
    if (http_body_before_len >= sizeof(http_data_f) + 64) {
        goto __checkin_exit;
    }

    int http_more_data_addr[3];
    int http_more_data_len[3 + 1];
    http_more_data_addr[0] = (int)(http_body_before_buf);
    http_more_data_addr[1] = (int)(buffer);
    http_more_data_addr[2] = (int)(http_data_b);
    http_more_data_len[0] = http_body_before_len;
    http_more_data_len[1] = length;
    http_more_data_len[2] = strlen(http_data_b);
    http_more_data_len[3] = 0;

    memset(ctx, 0x0, sizeof(httpcli_ctx));
    ctx->more_data = http_more_data_addr;
    ctx->more_data_len = http_more_data_len;
    ctx->timeout_millsec = 8000;

    ctx->url = url;
    ctx->priv = &http_body_buf;

    snprintf(url_buf, url_buf_len, http_head_tab, f->api_key, (int)(http_body_before_len + length + strlen(http_data_b)));
    ctx->user_http_header = url_buf;

    error = httpcli_post(ctx);
    if (error == HERROR_OK) {
        if (cb) {
            error = cb(http_body_buf.p, priv);
        }
    } else {
        error = -1;
    }

__checkin_exit:
    if (url_buf) {
        free(url_buf);
    }
    if (http_body_buf.p) {
        free(http_body_buf.p);
    }

    return error;
}

static int post_res_callback(char *data, void *priv)
{
    struct turing_info *f = (struct turing_info *)priv;
    int err = -1;
    json_object *new_obj = NULL;
    json_object *data1 = NULL;

    new_obj = json_tokener_parse(data);
    if (!json_object_object_get_ex(new_obj, "payload", &data1)) {
        goto __result_exit;
    }

    if (!json_object_get_string(data1) || !json_object_get_string_len(data1)) {
        goto __result_exit;
    }

    strncpy(f->res_media_id, json_object_get_string(data1), sizeof(f->res_media_id));
    f->res_media_id[sizeof(f->res_media_id) - 1] = 0;

    log_d("f->res_media_id=%s\n", f->res_media_id);

    err = 0;

__result_exit:

    json_object_put(new_obj);

    return err;
}

/*不使用 toUser参数*/
#define MESSSTR "{\"apiKey\":\"%s\",\"deviceId\":\"%s\",\"type\":%d,\"message\":{\"mediaId\":\"%s\"}}"

int turing_iot_send_message(void *priv, u8 type)
{
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;
    char buffer[512];

    int length = snprintf(buffer, sizeof(buffer), MESSSTR, f->api_key, f->device_id, type, f->res_media_id);

    ret = __http_post_mothed(IOT_ADDR"/iot/message/send", buffer, length, NULL, priv);

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
        return -1;
    }

    return ret;
}

int turing_iot_post_res(u8 *buf, u32 len)
{
    int ret = 0;
    char buffer[256];

    struct turing_info *f = get_turing_iot_hdl();

    if (!f || turing_iot_close_flag || !f->auth_flag) {
        return -1;
    }

    os_mutex_pend(&iot_mutex, 0);	//find xueyong
    if (turing_iot_close_flag) {
        os_mutex_post(&iot_mutex);
        return -1;
    }

    int length = snprintf(buffer, sizeof(buffer), IOT_ADDR"/resources/file/upload?apiKey=%s", f->api_key);

    ret = __post_resources(buffer, buf, len, post_res_callback, f);

    if (ret) {
        log_e("%s  http_post res fail\n", __func__);
        goto exit;
    }

    length = snprintf(buffer, sizeof(buffer), MESSSTR, f->api_key, f->device_id, 0, f->res_media_id);

    ret = __http_post_mothed(IOT_ADDR"/iot/message/send", buffer, length, NULL, f);

    if (ret) {
        log_e("%s  http_post send message fail\n", __func__);
    }

exit:
    os_mutex_post(&iot_mutex);

    return ret;
}

/************************************************************/
static int get_music_res_callback(char *data, void *priv)
{
    struct turing_info *f = (struct turing_info *)priv;
    int err = -1;
    json_object *new_obj = NULL;
    json_object *data1 = NULL;
    json_object *url = NULL;
    json_object *title = NULL;
    json_object *id = NULL;
    json_object *tip = NULL;
    char buf[128];

    new_obj = json_tokener_parse(data);
    if (!json_object_object_get_ex(new_obj, "payload", &data1)) {
        goto __result_exit;
    }

    if (!json_object_object_get_ex(data1, "url", &url)) {
        goto __result_exit;
    }

    if (!json_object_get_string(url) || !json_object_get_string_len(url)) {
        goto __result_exit;
    }

    if (!json_object_object_get_ex(data1, "name", &title)) {
        goto __result_exit;
    }

    if (!json_object_get_string(title) || !json_object_get_string_len(title)) {
        goto __result_exit;
    }

    if (!json_object_object_get_ex(data1, "id", &id)) {
        goto __result_exit;
    }

    strncpy(f->song_url, json_object_get_string(url), sizeof(f->song_url));
    f->song_url[sizeof(f->song_url) - 1] = 0;
    strncpy(f->song_title, json_object_get_string(title), sizeof(f->song_title));
    f->song_title[sizeof(f->song_title) - 1] = 0;
    f->song_id = json_object_get_int(id);

    snprintf(buf, sizeof(buf), "\"title\":\"%s\",\"mediaId\":%d,\"play\":1", json_object_get_string(title), json_object_get_int(id));

    if (0 == turing_iot_notify_status(f, MUSIC_STATE, buf)) {
        err = 0;
    }

__result_exit:

    json_object_put(new_obj);

    return err;
}

/*不使用 toUser参数*/
#define AURESTR "{\"apiKey\":\"%s\",\"deviceId\":\"%s\",\"type\":%d}"

int turing_iot_get_music_res(void *priv, u8 type)
{
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;
    char buffer[256];

    int length = snprintf(buffer, sizeof(buffer), AURESTR, f->api_key, f->device_id, type);

    ret = __http_post_mothed(IOT_ADDR"/v2/iot/audio", buffer, length, get_music_res_callback, priv);

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
    }

    return ret;
}

#define COLLECT "{\"apiKey\":\"%s\",\"deviceId\":\"%s\",\"id\":%d}"
#define PLAY_COLLECT "{\"apiKey\":\"%s\",\"deviceId\":\"%s\",\"type\":0}"

int turing_iot_collect_resource(void *priv, int album_id, u8 is_play)
{
    int length = 0;
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;
    char buffer[256];

    if (is_play) {
        length = snprintf(buffer, sizeof(buffer), PLAY_COLLECT, f->api_key, f->device_id);
        ret = __http_post_mothed(IOT_ADDR"/v2/iot/collect", buffer, length, get_music_res_callback, priv);
    } else {
        length = snprintf(buffer, sizeof(buffer), COLLECT, f->api_key, f->device_id, album_id);
        ret = __http_post_mothed(IOT_ADDR"/v2/iot/audio/collect", buffer, length, NULL, priv);
    }

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
    }

    return ret;
}

#define INITVER "{\"apiKey\":\"%s\",\"deviceId\":\"%s\",\"currentVersion\":\"%s\"}"

int turing_iot_report_version(void *priv)
{
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;
    char buffer[256];

    int length = snprintf(buffer, sizeof(buffer), INITVER, f->api_key, f->device_id, get_turing_version_code());

    ret = __http_post_mothed(IOT_ADDR"/iot/v2/ota/initVersion", buffer, length, NULL, priv);

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
    }

    return ret;
}

#define UPDATESUCC "{\"apiKey\":\"%s\",\"deviceId\":\"%s\",\"id\":%d,\"updateStatus\":1}"

static int turing_iot_update_success(void *priv, int version_id)
{
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;
    char buffer[256];

    int length = snprintf(buffer, sizeof(buffer), UPDATESUCC, f->api_key, f->device_id, version_id);

    ret = __http_post_mothed(IOT_ADDR"/iot/v2/ota/updateStatus", buffer, length, NULL, priv);

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
    }

    return ret;
}

static int ota_update_version_info(void *priv, const char *buf)
{
    json_object *new_obj = NULL;
    json_object *payload = NULL;
    json_object *data = NULL;
    json_object *data2 = NULL;
    int id = 0;
    int ret = -1;

    new_obj = json_tokener_parse(buf);
    if (!new_obj) {
        return -1;
    }
    if (!json_object_object_get_ex(new_obj, "payload", &payload)) {
        goto __result_exit;
    }
    if (!json_object_object_get_ex(payload, "updateStatus", &data)) {
        goto __result_exit;
    }

    if (0 != json_object_get_int(data)) {
        goto __result_exit;
    }
    if (!json_object_object_get_ex(payload, "agree", &data)) {
        goto __result_exit;
    }
    if (1 != json_object_get_int(data)) {
        goto __result_exit;
    }
    if (!json_object_object_get_ex(payload, "id", &data)) {
        goto __result_exit;
    }
    id = json_object_get_int(data);
    if (0 == id) {
        goto __result_exit;
    }
    if (!json_object_object_get_ex(payload, "nextVersion", &data2)) {
        goto __result_exit;
    }
    if (NULL == json_object_get_string(data2) || 0 == json_object_get_string_len(data2)) {
        goto __result_exit;
    }
    if (!json_object_object_get_ex(payload, "currentVersion", &data)) {
        goto __result_exit;
    }
    if (NULL == json_object_get_string(data) || 0 == json_object_get_string_len(data)) {
        goto __result_exit;
    }
    if (strcmp(json_object_get_string(data), get_turing_version_code())) {
        goto __result_exit;
    }
    if (!strcmp(json_object_get_string(data2), json_object_get_string(data))) {
        goto __result_exit;
    }
    if (!json_object_object_get_ex(payload, "firmwareUrl", &data)) {
        goto __result_exit;
    }
    if (NULL == json_object_get_string(data) || 0 == json_object_get_string_len(data)) {
        goto __result_exit;
    }

    extern void turing_upgrade_notify(int event, void *arg);
    turing_upgrade_notify(AI_SERVER_EVENT_UPGRADE, NULL);

    extern int get_update_data(const char *url);
    ret = get_update_data(json_object_get_string(data));
    if (!ret) {
        ret = turing_iot_update_success(priv, id);
        char *msg = NULL;
        msg = (char *)malloc(json_object_get_string_len(data2) + 1);
        if (msg) {
            strcpy(msg, json_object_get_string(data2));
        }
        turing_upgrade_notify(AI_SERVER_EVENT_UPGRADE_SUCC, msg);
    } else {
        turing_upgrade_notify(AI_SERVER_EVENT_UPGRADE_FAIL, NULL);
    }

__result_exit:

    if (new_obj) {
        json_object_put(new_obj);
    }

    return ret;
}

int turing_iot_check_update(void *priv)
{
    int error = 0;
    http_body_obj http_body_buf;
    struct turing_info *f = (struct turing_info *)priv;
    httpcli_ctx *ctx = &f->ctx;
    char url[128];

    memset(&http_body_buf, 0x0, sizeof(http_body_obj));
    http_body_buf.recv_len = 0;
    http_body_buf.buf_len = 4 * 1024;
    http_body_buf.buf_count = 1;
    http_body_buf.p = (char *) malloc(http_body_buf.buf_len * sizeof(char));
    if (http_body_buf.p == NULL) {
        return -1;
    }

    os_mutex_pend(&iot_mutex, 0);
    if (turing_iot_close_flag) {
        free(http_body_buf.p);
        os_mutex_post(&iot_mutex);
        return -1;
    }

    snprintf(url, sizeof(url), "http://iot-ai.tuling123.com/iot/v2/ota/version?apiKey=%s&deviceId=%s", f->api_key, f->device_id);
    memset(ctx, 0x0, sizeof(httpcli_ctx));
    ctx->url = url;
    ctx->priv = &http_body_buf;
    ctx->connection = "close";

    error = httpcli_get(ctx);
    os_mutex_post(&iot_mutex);
    if (error == HERROR_OK) {
        log_d("ota recv : %s\n", http_body_buf.p);
        error = ota_update_version_info(priv, http_body_buf.p);
    }

    if (http_body_buf.p) {
        free(http_body_buf.p);
    }

    return error;
}

#define BT_CFG_BIND "[{\"apiKey\":\"%s\",\"deviceId\":\"%s\",\"openId\":\"%s\"}]"

int turing_iot_bt_cfg_bind(void *priv, const char *openid)
{
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;
    char buffer[256];

    int length = snprintf(buffer, sizeof(buffer), BT_CFG_BIND, f->api_key, f->device_id, openid);

    ret = __http_post_mothed(IOT_ADDR"/open/device/bind-wechat-user", buffer, length, NULL, priv);

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
    }

    return ret;
}

#define SINVOICE_CFG_BIND "{\"apiKey\":\"%s\",\"deviceId\":\"%s\",\"openId\":\"%s\"}"

int turing_iot_sinvoice_cfg_bind(void *priv, const char *openid)
{
    int ret = 0;
    struct turing_info *f = (struct turing_info *)priv;
    char buffer[256];

    int length = snprintf(buffer, sizeof(buffer), SINVOICE_CFG_BIND, f->api_key, f->device_id, openid);

    ret = __http_post_mothed(IOT_ADDR"/iot/bind_from_sinvoice", buffer, length, NULL, priv);

    if (ret) {
        log_e("%s  http_post fail\n", __func__);
    }

    return ret;
}


/************************************************************/
char *turing_iot_get_client_id(void *priv)
{
    struct turing_info *f = (struct turing_info *)priv;
    return f->client_id;
}

char *turing_iot_get_topic_uuid(void *priv)
{
    struct turing_info *f = (struct turing_info *)priv;
    return f->topic;
}

char *turing_iot_get_url(void *priv)
{
    struct turing_info *f = (struct turing_info *)priv;
    return f->song_url;
}

int turing_iot_get_song_title(void *priv, char *title, int *id)
{
    struct turing_info *f = (struct turing_info *)priv;
    strcpy(title, f->song_title);
    *id = f->song_id;
    return 0;
}