#include <stdio.h>
#include <string.h>
#include "eventsManager.h"
#include "esp_log.h"
#include "mqtt_client.h"
#include "obtain_time.h"
#include <time.h>
#include "meteofrance.h"
#if CONFIG_IDF_TARGET_ESP32P4
    #include "audio.h"
#endif

EventGroupHandle_t domotic_event_group;
QueueHandle_t ihm_queue;
extern esp_mqtt_client_handle_t client;

static const char *TAG = "evtMgr";

void startEvtManager(){
    domotic_event_group = xEventGroupCreate();
    ihm_queue = getIHMQueueHandle();

    /* Tache updateTime */
    BaseType_t ret2 = xTaskCreate(&updateTime, "updateTimeTask", 3 * 1024, NULL, 5, NULL);
    if (ret2 != pdPASS)
    {
        ESP_LOGE(TAG, "Impossiblke de creer la tache updateTimeTask %i", ret2);
    }
    /* Tache updateTime - FIN*/
}

const char * domo_event_to_str(domo_events evt)
{
    switch (evt) {
        case EVT_WIFI_CONNECTED:   return "WIFI_CONNECTED";
        case EVT_TIME_SETTED:      return "TIME_SETTED";
        case EVT_BTN_VOLET:        return "BTN_VOLET";
        case EVT_PUISSANCE_RECUE:  return "PUISSANCE_RECUE";
        case EVT_ETAT_MACHINE:     return "ETAT_MACHINE";
        case EVT_HAUTEUR_CUVE:     return "HAUTEUR_CUVE";
        case EVT_METEO_RECUE:      return "METEO_RECUE";
        case EVT_TEMP_EXT:         return "TEMP_EXT";
        case EVT_TEMP_INT:         return "TEMP_INT";
        case EVT_FIN_MACHINE:      return "FIN_MACHINE";
        default:                   return "EVT_UNKNOWN";
    }
}

const char * ihm_event_to_str(eIHMEvent_t evt)
{
    switch (evt) {
        case IHM_EVT_WIFI_STATUS:      return "IHM_WIFI_STATUS";
        case IHM_EVT_TIME_SETTED:      return "IHM_TIME_SETTED";
        case IHM_EVT_OTA_STARTED:      return "IHM_OTA_STARTED";
        case IHM_EVT_OTA_PROGRESS:     return "IHM_OTA_PROGRESS";
        case IHM_EVT_HUMID_TEMP:       return "IHM_HUMID_TEMP";
        case IHM_EVT_PUISSANCE_EMISE:  return "IHM_PUISSANCE_EMISE";
        case IHM_EVT_ETAT_MACHINE:     return "IHM_ETAT_MACHINE";
        case IHM_EVT_HAUTEUR_CUVE:     return "IHM_HAUTEUR_CUVE";
        case IHM_EVT_METEO_RECUE:      return "IHM_METEO_RECUE";
        case IHM_EVT_TEMP_RECUE:       return "IHM_TEMP_RECUE";
        default:                       return "IHM_EVT_UNKNOWN";
    }
}

void send_event(domo_events evt, void* pDatas) {
    ESP_LOGI(TAG, "EventManager: On est dans l'event handler %s", domo_event_to_str(evt));

    xIHMEvent_t *ihmEvt = malloc(sizeof(xIHMEvent_t));
    if (!ihmEvt) {
        ESP_LOGE(TAG, "malloc failed for event struct");
        return;
    }

    switch (evt) {
        case EVT_WIFI_CONNECTED: {
            xEventGroupSetBits(domotic_event_group, WIFI_CONNECTED_BIT);
            ESP_LOGI(TAG, "connected to AP SSID");

            bool *wifiStatus = malloc(sizeof(bool));
            if (!wifiStatus) {
                ESP_LOGE(TAG, "malloc failed for wifiStatus");
                free(ihmEvt);
                return;
            }
            *wifiStatus = true;

            ihmEvt->eEventType = IHM_EVT_WIFI_STATUS;
            ihmEvt->pvData = wifiStatus;
            ihmEvt->bNeedToFreeData = true;
            break;
        }

        case EVT_TIME_SETTED:
            struct tm *msg = (struct tm *)pDatas;
            struct tm *msg_copy = malloc(sizeof(struct tm));
            if (!msg_copy)
            {
                ESP_LOGE(TAG, "malloc failed for message string");
                free(ihmEvt);
                return;
            }
            // Vérifier que msg n'est pas NULL avant de copier
            if (msg == NULL)
            {
                fprintf(stderr, "msg est NULL !\n");
                free(msg_copy);
                return;
            }


            *msg_copy = *msg;
            ihmEvt->eEventType = IHM_EVT_TIME_SETTED;
            ihmEvt->pvData = msg_copy;
            ihmEvt->bNeedToFreeData = true;
            break;

        case EVT_BTN_VOLET:
            esp_mqtt_client_publish(client, "volets", pDatas, 0, 0, 0);
            free(ihmEvt);  // rien à envoyer à l'IHM
            ihmEvt = NULL;
            return;

        case EVT_PUISSANCE_RECUE:
            ESP_LOGI(TAG, "Puissance recue %i", *(int*)pDatas);
            int *data = malloc(sizeof(int));
            if (!data) {
                ESP_LOGE(TAG, "malloc failed for puissance_5mn");
                free(ihmEvt);
                return;
            }
            *data = *(int *)pDatas;
           ihmEvt->eEventType = IHM_EVT_PUISSANCE_EMISE;
            ihmEvt->pvData = data;
            ihmEvt->bNeedToFreeData = true;
            break;

        case EVT_ETAT_MACHINE:
            const char *msg2 = (const char *)pDatas;
            char *msg_copy2 = malloc(strlen(msg2) + 1);
            if (!msg_copy2) {
                ESP_LOGE(TAG, "malloc failed for message string");
                free(ihmEvt);
                return;
            }
            strcpy(msg_copy2, msg2);
            ihmEvt->eEventType = IHM_EVT_ETAT_MACHINE;
            ihmEvt->pvData = msg_copy2;
            ihmEvt->bNeedToFreeData = true;
            break;

        case EVT_TEMP_EXT:
            const char *msg3 = (const char *)pDatas;
            char *msg_copy3 = malloc(strlen(msg3) + 1);
            if (!msg_copy3) {
                ESP_LOGE(TAG, "malloc failed for message string");
                free(ihmEvt);
                return;
            }
            strcpy(msg_copy3, msg3);
            ihmEvt->eEventType = IHM_EVT_TEMP_RECUE;
            ihmEvt->pvData = msg_copy3;
            ihmEvt->bNeedToFreeData = true;
            break;

        case EVT_TEMP_INT:
            const char *msg4 = (const char *)pDatas;
            char *msg_copy4 = malloc(strlen(msg4) + 1);
            if (!msg_copy4) {
                ESP_LOGE(TAG, "malloc failed for message string");
                free(ihmEvt);
                return;
            }
            strcpy(msg_copy4, msg4);
            ihmEvt->eEventType = IHM_EVT_HUMID_TEMP;
            ihmEvt->pvData = msg_copy4;
            ihmEvt->bNeedToFreeData = true;
            break;

        case EVT_HAUTEUR_CUVE: {
            float *data = malloc(sizeof(float));
            if (!data) {
                ESP_LOGE(TAG, "malloc failed for hauteur_cuve");
                free(ihmEvt);
                return;
            }
            *data = *(float *)pDatas;
            ESP_LOGE(TAG, "EVENT_HANDLER -> On a recu %f", *data);
            ihmEvt->eEventType = IHM_EVT_HAUTEUR_CUVE;
            ihmEvt->pvData = data;
            ihmEvt->bNeedToFreeData = true;
            break;
        }

        case EVT_METEO_RECUE:{
            meteo_event_payload_t *incoming = (meteo_event_payload_t *) pDatas;
            meteo_event_payload_t *payload = malloc(sizeof(meteo_event_payload_t));
            if (payload == NULL) {
                // gérer l’erreur
                return;
            }

            memcpy(payload->daily, incoming->daily, sizeof(incoming->daily));
            memcpy(payload->forecast, incoming->forecast, sizeof(incoming->forecast));
            ihmEvt->eEventType = IHM_EVT_METEO_RECUE;
            ihmEvt->pvData = payload;
            ihmEvt->bNeedToFreeData = true;
            break;
        }

        case EVT_FIN_MACHINE:{
            #if CONFIG_IDF_TARGET_ESP32P4
            playSound();
            #endif
            free(ihmEvt);  // rien à envoyer à l'IHM
            ihmEvt = NULL;
            break;
        }

        default:
            ESP_LOGE(TAG, "Unhandled event type");
            free(ihmEvt);
            ihmEvt = NULL;
            return;
    }
    if( ihm_queue != NULL && ihmEvt){
        ESP_LOGI(TAG, "Suite %s : Envoi d'un evt %s (%i) a l'IHM", domo_event_to_str(evt), ihm_event_to_str(ihmEvt->eEventType),ihmEvt->eEventType);
        if (xQueueSendToFront(ihm_queue, &ihmEvt, pdMS_TO_TICKS(10)) != pdPASS)
        {
            ESP_LOGE(TAG, "La queue est pleine");
            if (ihmEvt->bNeedToFreeData && ihmEvt->pvData)
            {
                free(ihmEvt->pvData);
            }
            free(ihmEvt);
        }
    }else{
        ESP_LOGI(TAG, "Suite %s : on n'envoie rien a l'IHM", domo_event_to_str(evt));

    }
}