#include "interface/ideasx_interface.h"

static const char* TAG = "IdeasX";

MQTT_Client mqttClient;
static IdeasX_Config_t ideasX_config;
static IdeasX_Health_t ideasX_health;
static os_timer_t health_timer;
static IdeasX_Command_t command_array[NUMBER_OF_COMMANDS]; 

void ICACHE_FLASH_ATTR IdeasX_Publish_Buttons(uint32_t button_states)
{
    ESP_LOGD(TAG, "publishing button states");
    uint8_t topic[40];
    uint8_t payload[4];

    // convert uint32_t to array of uint8_t for MQTT_Publish
    uint8_t * buttonp = (uint8_t *)&button_states; 
    payload[0] = buttonp[0];
    payload[1] = buttonp[1];
    payload[2] = buttonp[2];
    payload[3] = buttonp[3];

    os_sprintf(topic, "%s%s", ideasX_config.data_topic, "button");
    MQTT_Publish(&mqttClient, topic, payload, sizeof(payload) , DATA_QOS, DATA_RETAIN);    
}

static void ICACHE_FLASH_ATTR IdeasX_SetHealthInfo(uint16_t vcell, uint16_t soc, uint16_t rssi)
{
    ideasX_health.vcell.value = vcell;
    ideasX_health.soc.value = soc;
    ideasX_health.rssi.value = rssi; 
}

static void ICACHE_FLASH_ATTR ideasX_publish_health(void)
{
    uint8_t topic[40], payload[40];
    Encoder_EnableIMUI2CInterface(true);
    ideasX_health.vcell.value = Encoder_GetVoltage();
    ideasX_health.soc.value = Encoder_GetSOC();
    ideasX_health.rssi.value = wifi_station_get_rssi();

    ESP_LOGI(TAG, "vcell: %d", Encoder_GetVoltage());
    ESP_LOGI(TAG, "soc: %d", Encoder_GetSOC());
    
    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.vcell.topic);
    os_sprintf(payload, "%d", ideasX_health.vcell.value);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.soc.topic);
    os_sprintf(payload, "%d", ideasX_health.soc.value);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.rssi.topic);
    os_sprintf(payload, "%d", ideasX_health.rssi.value);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);
}

static void ICACHE_FLASH_ATTR ideasX_connected_cb(uint32_t *args)
{
    struct station_config stationConfig;
    wifi_station_get_config(&stationConfig);
    uint8_t topic[40], payload[40];

    ESP_LOGI(TAG, "Connected to IdeasX");

    if (ideasX_config.success_cb != NULL)
        ideasX_config.success_cb();

    // subscribe to command topic 
    MQTT_Subscribe(&mqttClient, ideasX_config.command_topic, COMMAND_QOS);

    // publish static health information
    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.hw_ver.topic);
    os_sprintf(payload, "%d,%d", ideasX_health.hw_ver.major, ideasX_health.hw_ver.minor);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.fw_ver.topic);
    os_sprintf(payload, "%d,%d", ideasX_health.fw_ver.major, ideasX_health.fw_ver.minor);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.alive.topic);
    os_sprintf(payload, "%d", ideasX_health.alive.flag);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(ideasX_health.ssid.value, "%s", stationConfig.ssid);
    os_sprintf(ideasX_health.bssid.value, MACSTR, MAC2STR(stationConfig.bssid));

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.ssid.topic);
    os_sprintf(payload, "%s", ideasX_health.ssid.value);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.bssid.topic);
    os_sprintf(payload, "%s", ideasX_health.bssid.value);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.ota.topic);
    os_sprintf(payload, "%d", ideasX_health.ota.flag);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    ideasX_publish_health();

    // setup publish health timer
    os_timer_disarm(&ideasX_health.health_timer);
    os_timer_arm(&ideasX_health.health_timer, ideasX_health.health_report_rate*1000, true);   // change to system task
}

static void ICACHE_FLASH_ATTR ideasX_disconnected_cb(uint32_t *args)
{
    ESP_LOGI(TAG, "Disconnected from IdeasX");
    os_timer_disarm(&ideasX_health.health_timer);
    if (ideasX_config.fail_cb != NULL)
        ideasX_config.fail_cb();
}

static void ICACHE_FLASH_ATTR ideasX_published_cb(uint32_t *args)
{
    // subscribe to command topics
    ESP_LOGD(TAG, "Published Messaged");
}

void ICACHE_FLASH_ATTR IdeasX_Connect(void)
{
    MQTT_Connect(&mqttClient);
}

void ICACHE_FLASH_ATTR IdeasX_Disconnect(void)
{
    if (ideasX_config.fail_cb != NULL)
        ideasX_config.fail_cb();
    MQTT_Disconnect(&mqttClient);
}

void ICACHE_FLASH_ATTR ideasX_system_config_init(void)
{
    uint8_t mac_address[6];
    wifi_get_macaddr(STATION_MODE, mac_address);
    os_sprintf(ideasX_config.device_id, MACSTR, MAC2STR(mac_address));
    os_sprintf(ideasX_config.mqtt_client_id, MACSTR, MAC2STR(mac_address));

    os_sprintf(ideasX_config.command_topic, "encoder/%s/command/#", ideasX_config.device_id);
    os_sprintf(ideasX_config.health_topic, "encoder/%s/health/", ideasX_config.device_id);
    os_sprintf(ideasX_config.data_topic, "encoder/%s/data/", ideasX_config.device_id);
    os_sprintf(ideasX_config.mqtt_host, "%s", MQTT_HOST_DEFAULT);
    ideasX_config.mqtt_port = MQTT_PORT_DEFAULT;
    os_sprintf(ideasX_config.mqtt_user, "%s", "");
    os_sprintf(ideasX_config.mqtt_pass, "%s", "");

    #ifdef MQTT_USER_DEFAULT
        os_sprintf(ideasX_config.mqtt_user, "%s", MQTT_USER_DEFAULT);
        os_sprintf(ideasX_config.mqtt_pass, "%s", MQTT_PASS_DEFAULT);
    #endif
    ideasX_config.mqtt_keepalive = MQTT_KEEPALIVE_DEFAULT;

    ideasX_config.success_cb = NULL;
    ideasX_config.fail_cb = NULL;

}

void ICACHE_FLASH_ATTR ideasX_command_array_init(void)
{
    os_sprintf(command_array[SHUTDOWN_COMMAND_INDEX].topic, "%s", SHUTDOWN_COMMAND_TOPIC);
    os_sprintf(command_array[RESTART_COMMAND_INDEX].topic, "%s", RESTART_COMMAND_TOPIC); 
    os_sprintf(command_array[LOC_COMMAND_INDEX].topic, "%s", LOC_COMMAND_INDEX);
    command_array[SHUTDOWN_COMMAND_INDEX].function = &Encoder_Shutdown;
    command_array[RESTART_COMMAND_INDEX].function = &Encoder_Restart;
    command_array[LOC_COMMAND_INDEX].function = &Encoder_Find;
}

static void ICACHE_FLASH_ATTR ideasX_data_cb(uint32_t *args, const char* topic, uint32_t topic_len, const char *data, uint32_t data_len)
{
  uint8_t *topicBuf = (uint8_t*)os_zalloc(topic_len + 1),
        *dataBuf = (uint8_t*)os_zalloc(data_len + 1);

  MQTT_Client* client = (MQTT_Client*)args;
  os_memcpy(topicBuf, topic, topic_len);
  topicBuf[topic_len] = 0;
  os_memcpy(dataBuf, data, data_len);
  dataBuf[data_len] = 0;
  ESP_LOGI(TAG, "Receive topic: %s, data: %s \r\n", topicBuf, dataBuf);

  uint8_t len = os_strlen(ideasX_config.command_topic) - 1;
  uint8_t* command_topic = topicBuf + len;

  ESP_LOGD(TAG, "command topic: %s", command_topic);

    uint8_t i; 
    for (i=0; i<NUMBER_OF_COMMANDS; i++)
    {
        if (!strcmp(command_array[i].topic, command_topic))
        {
            ESP_LOGD(TAG, "Found the command: %s", command_array[i].topic);
            ideasX_function_t function =  command_array[i].function; 
            function(); 
        }
    }

  ESP_LOGD(TAG, "we made it out");
  os_free(topicBuf);
  os_free(dataBuf);
}

void ICACHE_FLASH_ATTR ideasX_health_config_init()
{
    // setup ideasX topics
    os_sprintf(ideasX_health.hw_ver.topic, "%s", HW_VERSION_HEALTH_TOPIC);
    os_sprintf(ideasX_health.fw_ver.topic, "%s", FW_VERSION_HEALTH_TOPIC);
    os_sprintf(ideasX_health.alive.topic, "%s", ALIVE_HEALTH_TOPIC);
    os_sprintf(ideasX_health.vcell.topic, "%s", VCELL_HEALTH_TOPIC);
    os_sprintf(ideasX_health.soc.topic, "%s", SOC_HEALTH_TOPIC);
    os_sprintf(ideasX_health.rom.topic, "%s", ROM_HEALTH_TOPIC);
    os_sprintf(ideasX_health.ota.topic, "%s", OTA_HEALTH_TOPIC);
    os_sprintf(ideasX_health.ssid.topic, "%s", SSID_HEALTH_TOPIC);
    os_sprintf(ideasX_health.bssid.topic, "%s", BSSID_HEALTH_TOPIC);
    os_sprintf(ideasX_health.rssi.topic, "%s", RSSI_HEALTH_TOPIC);
    ideasX_health.health_report_rate = HEALTH_REPORT_RATE_DEFAULT;

    // load default values for static items
    ideasX_health.hw_ver.minor = HW_VERSION_MINOR_DEFAULT;
    ideasX_health.hw_ver.major = HW_VERSION_MAJOR_DEFAULT;
    ideasX_health.fw_ver.minor = FW_VERSION_MINOR_DEFAULT;
    ideasX_health.fw_ver.major = FW_VERSION_MAJOR_DEFAULT;
    ideasX_health.alive.flag = true;
    ideasX_health.ota.flag = false;

    ideasX_health.health_timer = health_timer;
    os_timer_disarm(&ideasX_health.health_timer);
    os_timer_setfn(&ideasX_health.health_timer, (os_timer_func_t *)ideasX_publish_health, NULL);
}

void ICACHE_FLASH_ATTR IdeasX_UpdateBatteryStatus(uint16_t vcell, uint16_t soc)
{
    ideasX_health.soc.value = soc;
    ideasX_health.vcell.value = vcell;
}

void ICACHE_FLASH_ATTR IdeasX_SetStatusCallbacks(ideasX_function_t success, ideasX_function_t fail)
{
    ideasX_config.success_cb = success;
    ideasX_config.fail_cb = fail;
}

void ICACHE_FLASH_ATTR IdeasX_Init(void)
{
    uint8_t topic[40];
    ideasX_system_config_init();
    ideasX_health_config_init();
    ideasX_command_array_init();

    MQTT_InitConnection(&mqttClient, ideasX_config.mqtt_host, ideasX_config.mqtt_port, DEFAULT_SECURITY);
    MQTT_InitClient(&mqttClient, ideasX_config.mqtt_client_id, ideasX_config.mqtt_user, ideasX_config.mqtt_pass,
        ideasX_config.mqtt_keepalive, MQTT_CLEAN_SESSION);
    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.alive.topic);
    MQTT_InitLWT(&mqttClient, topic, "0", HEALTH_QOS, HEALTH_RETAIN);
    MQTT_OnConnected(&mqttClient, ideasX_connected_cb);
    MQTT_OnDisconnected(&mqttClient, ideasX_disconnected_cb);
    //MQTT_OnPublished(&mqttClient, mqttPublishedCb);
    MQTT_OnData(&mqttClient, ideasX_data_cb);
}