#include <string.h>
#include <stdio.h>
#include "esp8266.h"
#include "main.h"
#include "onenet.h"
#include "mqttkit.h"
#include "oled.h"
#include "stm32f1xx_hal_gpio.h"
#include "cJSON.h"

#define PRODUCT_ID "zzS53oqy5l"
#define DEVICE_ID "ESP_67EAF3"
#define SIGNATURE "version=2018-10-31&res=products%2FzzS53oqy5l%2Fdevices%2FESP_67EAF3&et=1766658508&method=md5&sign=r2rPhQdTZ3vpkxJTbgN5NQ%3D%3D"


extern unsigned char esp8266_buf[128];

_Bool OneNet_DevLink(void)
{
    MQTT_PACKET_STRUCTURE mqttPacket = {NULL, 0, 0, 0};

    _Bool status = 1;

    if (MQTT_PacketConnect(PRODUCT_ID, SIGNATURE, DEVICE_ID, 256, 1, MQTT_QOS_LEVEL0, NULL, NULL, 0, &mqttPacket) == 0)
    {
        ESP8266_SendData(mqttPacket._data, mqttPacket._len);

        unsigned char* dataPtr = ESP8266_GetIPD(250);
        if (dataPtr != NULL)
        {
            if (MQTT_UnPacketRecv(dataPtr) == MQTT_PKT_CONNACK)
            {
                switch (MQTT_UnPacketConnectAck(dataPtr))
                {
                case 0:
                    status = 0;
                    break;

                case 1:
                    // Invalid protocol version
                case 2:
                    // Invalid client-id
                case 3:
                    // Failed to connect to broker
                case 4:
                    // Wrong username or password
                case 5:
                    // Not authorized
                default:
                    break;
                }
            }
        }

        MQTT_DeleteBuffer(&mqttPacket);
    }

    return status;
}


unsigned char OneNet_FillBuf(char* buf)
{
    cJSON* packet = cJSON_CreateObject();

    char packet_id[16];
    sprintf(packet_id, "%d", uwTick);
    cJSON_AddItemToObject(packet, "id", cJSON_CreateString(packet_id));

    cJSON* params = cJSON_CreateObject();
    cJSON* valueObj = cJSON_CreateObject();

    cJSON_AddItemToObject(valueObj, "value", cJSON_CreateNumber(IM_Volt * 0.0001));
    cJSON_AddItemToObject(params, "volt", valueObj);

    valueObj = cJSON_CreateObject();
    cJSON_AddItemToObject(valueObj, "value", cJSON_CreateNumber(IM_Curr * 0.0001));
    cJSON_AddItemToObject(params, "current", valueObj);

    valueObj = cJSON_CreateObject();
    cJSON_AddItemToObject(valueObj, "value", cJSON_CreateNumber(IM_Power * 0.0001));
    cJSON_AddItemToObject(params, "watt_P", valueObj);

    valueObj = cJSON_CreateObject();
    cJSON_AddItemToObject(valueObj, "value", cJSON_CreateNumber(IM_Energy * 0.0001));
    cJSON_AddItemToObject(params, "energy", valueObj);

    valueObj = cJSON_CreateObject();
    cJSON_AddItemToObject(valueObj, "value", cJSON_CreateString(IC_CARD_ID));
    cJSON_AddItemToObject(params, "ic_id", valueObj);

    valueObj = cJSON_CreateObject();
    cJSON_AddItemToObject(valueObj, "value", cJSON_CreateBool(HAL_GPIO_ReadPin(RELAY1_GPIO_Port, RELAY1_Pin) == GPIO_PIN_RESET));
    cJSON_AddItemToObject(params, "output", valueObj);

    cJSON_AddItemToObject(packet, "params", params);

    const char* json_str = cJSON_Print(packet);
    strcpy(buf, json_str);

    cJSON_Delete(packet);

    return strlen(buf);
}

void OneNet_SendData(void)
{
    MQTT_PACKET_STRUCTURE mqttPacket = {NULL, 0, 0, 0};

    char buf[256];

    short body_len = 0, i = 0;
    memset(buf, 0, sizeof(buf));

    body_len = OneNet_FillBuf(buf);

    if (body_len)
    {
        if (MQTT_PacketSaveData(DEVICE_ID, body_len, NULL, 5, &mqttPacket) == 0)
        {
            for (; i < body_len; i++)
            {
                mqttPacket._data[mqttPacket._len++] = buf[i];
            }
            ESP8266_SendData(mqttPacket._data, mqttPacket._len);
            MQTT_DeleteBuffer(&mqttPacket);
        }
        else;
    }
}

void OneNET_Subscribe(void)
{
    MQTT_PACKET_STRUCTURE mqtt_packet = {NULL, 0, 0, 0};

    char topic_buf[56];
    const char* topic = topic_buf;

    snprintf(topic_buf, sizeof(topic_buf), "$sys/%s/%s/thing/property/set", PRODUCT_ID, DEVICE_ID);

    if (MQTT_PacketSubscribe(MQTT_SUBSCRIBE_ID, MQTT_QOS_LEVEL0, &topic, 1, &mqtt_packet) == 0)
    {
        ESP8266_SendData(mqtt_packet._data, mqtt_packet._len);

        MQTT_DeleteBuffer(&mqtt_packet);
    }
}

void OneNet_RevPro(unsigned char* cmd)
{
    char* req_payload = NULL;
    char* cmdid_topic = NULL;

    unsigned short topic_len = 0;
    unsigned short req_len = 0;

    unsigned char qos = 0;
    static unsigned short pkt_id = 0;

    unsigned char type = 0;

    short result = 0;

    type = MQTT_UnPacketRecv(cmd);
    switch (type)
    {
    case MQTT_PKT_PUBLISH:

        result = MQTT_UnPacketPublish(cmd, &cmdid_topic, &topic_len, &req_payload, &req_len, &qos, &pkt_id);
        if (result == 0)
        {
            cJSON* root = cJSON_Parse(req_payload);
            if (root == NULL) return;

            const cJSON* id = cJSON_GetObjectItem(root, "id");
            if (id == NULL) return;

            cJSON* params = cJSON_GetObjectItem(root, "params");
            if (params == NULL)
            {
                cJSON_Delete(root);
                return;
            }

            // params process
            const cJSON* energy = cJSON_GetObjectItem(params, "energy");
            const cJSON* output = cJSON_GetObjectItem(params, "output");

            if (energy != NULL)
            {
                char disp[64];
                sprintf(disp, "set eng=%d", energy->valueint);
                OLED_ShowString(0, 8, disp, 12);
            }

            if (output != NULL)
            {
                HAL_GPIO_WritePin(RELAY1_GPIO_Port, RELAY1_Pin, output->valueint ? GPIO_PIN_RESET : GPIO_PIN_SET);
            }

            MQTT_PACKET_STRUCTURE mqtt_packet = {NULL, 0, 0, 0};

            cJSON* reply = cJSON_CreateObject();
            cJSON_AddItemToObject(reply, "id", cJSON_CreateString(id->valuestring));
            cJSON_AddItemToObject(reply, "code", cJSON_CreateNumber(200));
            cJSON_AddItemToObject(reply, "msg", cJSON_CreateString("success"));

            const char* reply_str = cJSON_Print(reply);
            if (MQTT_PacketPublish(MQTT_PUBLISH_ID, strcat(cmdid_topic, "_reply"),
                                   reply_str,
                                   strlen(reply_str), MQTT_QOS_LEVEL0, 0, 1, &mqtt_packet) == 0)
            {
                ESP8266_SendData(mqtt_packet._data, mqtt_packet._len);
                MQTT_DeleteBuffer(&mqtt_packet);
            }

            cJSON_Delete(reply);
            cJSON_Delete(root);
        }
        break;

    case MQTT_PKT_PUBACK:
        if (MQTT_UnPacketPublishAck(cmd) == 0)
            break;
    case MQTT_PKT_SUBACK:
        if (MQTT_UnPacketSubscribe(cmd) == 0)
            break;
    default:
        result = -1;
        break;
    }

    ESP8266_Clear();

    if (result == -1)
        return;

    if (type == MQTT_PKT_CMD || type == MQTT_PKT_PUBLISH)
    {
        MQTT_FreeBuffer(cmdid_topic);
        MQTT_FreeBuffer(req_payload);
    }
}

uint8_t onenet_state()
{
    return OneNet_DevLink();
}