#include "SPIFFS.h"
#include <Arduino.h>
#include <AsyncTCP.h>
#include <ETH.h>
#include <WiFi.h>
#include <HTTPUpdate.h>

#include "AsyncJson.h"
#include <ArduinoJson.h>
#include <Elog.h>

#include <ArduinoOTA.h>

#include "global_data/defines.h"
#include "global_data/global_data.h"

#include "networking/networking.h"
#include "networking/webserver.h"

#include "external_interfacing/leds.h"
#include "sensor/sensor.h"
#include "telemetry/telemetry.h"
#include "tools/tools.h"
#include <Preferences.h>
#include "networking/json_builder.h"
#include <fetchOTA.h>
#include "time.h"
#include "tools/log.h"
#include "tools/ota.h"
#include <LittleFS.h>

#include "esp_heap_caps.h"

#define MYLOG 0

Preferences prefs;

Version current_spiffs_version;

// Variable to store the current state of the system
CurrentState current_state = {
    {-999.0f, -999.0f, -999.0f},
    {-999.0f, -999.0f, -999.0f},
    {"0.0.0.0", false, -999.0f, "UNKNOWN"},  // wifiData
    {"0.0.0.0", false, -999.0f, "UNKNOWN"},  // ethernetData
    {-999.0f, -999, -999.0f},
    {false, {0, 0, 0}, {0, 0, 0}, -999, "UNKNOWN"},
    {false, false, false, false, false, false}
};

#define FORMAT_LITTLEFS_IF_FAILED true

// Queue for sending data from producers to the processor in main
QueueHandle_t dataQueue = xQueueCreate(5, sizeof(DataMessage));

// Queue for sending data from processor to different tasks
QueueHandle_t stateForWebserverQueue = xQueueCreate(2, sizeof(CurrentState));

// Queue for sending preferences from main to webserver
QueueHandle_t prefsForWebserverQueue = xQueueCreate(2, sizeof(DataMessage));

// Queue for sending preferences from main to sensor task
QueueHandle_t prefsForSensorQueue = xQueueCreate(2, sizeof(DataMessage));

void setup()
{
    Logger.registerSerial(MYLOG, ELOG_LEVEL_DEBUG, "Serial");
    LOG(ELOG_LEVEL_DEBUG, "Init Starting prefs and Serial output");
    prefs.begin("waterlevel", false);
    Serial.begin(115200);

    // Read initial preferences and send to webserver and sensor
    if (prefsForWebserverQueue != NULL || prefsForSensorQueue != NULL) {
        DataMessage prefsMessage;
        prefsMessage.type = DATA_TYPE_PREFERENCES;
        prefsMessage.data.preferencesData.level_sensor_range = prefs.getFloat(level_sensor_range_key, 200);
        prefsMessage.data.preferencesData.water_level_min = prefs.getFloat(water_level_min_key, 0);
        prefsMessage.data.preferencesData.water_level_max = prefs.getFloat(water_level_max_key, 200);
        prefsMessage.data.preferencesData.water_volume = prefs.getFloat(water_volume_key, 10000.0f);
        strncpy(prefsMessage.data.preferencesData.ssid, prefs.getString(ssid_key, "").c_str(), sizeof(prefsMessage.data.preferencesData.ssid) - 1);
        prefsMessage.data.preferencesData.ssid[sizeof(prefsMessage.data.preferencesData.ssid) - 1] = '\0';
        strncpy(prefsMessage.data.preferencesData.wifi_password, prefs.getString(wifi_password_key, "").c_str(), sizeof(prefsMessage.data.preferencesData.wifi_password) - 1);
        prefsMessage.data.preferencesData.wifi_password[sizeof(prefsMessage.data.preferencesData.wifi_password) - 1] = '\0';
        
        // Send to webserver
        if (prefsForWebserverQueue != NULL) {
            if (xQueueSend(prefsForWebserverQueue, &prefsMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
                LOG(ELOG_LEVEL_ERROR, "Failed to send initial preferences to webserver queue");
            } else {
                LOG(ELOG_LEVEL_DEBUG, "Sent initial preferences to webserver");
            }
        }
        
        // Send to sensor task
        if (prefsForSensorQueue != NULL) {
            if (xQueueSend(prefsForSensorQueue, &prefsMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
                LOG(ELOG_LEVEL_ERROR, "Failed to send initial preferences to sensor queue");
            } else {
                LOG(ELOG_LEVEL_DEBUG, "Sent initial preferences to sensor");
            }
        }
    }

    LOG(ELOG_LEVEL_DEBUG, "Beginning LittleFS");
    LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED);

    // Read the current SPIFFS version from the versions file on the spiffs
    LOG(ELOG_LEVEL_DEBUG, "Reading LittleFS version");
    File file = LittleFS.open("/version", FILE_READ);
    if (!file) {
        LOG( ELOG_LEVEL_ERROR, "Failed opening LittleFS version file");
    } else {
      String version = file.readStringUntil('\n');
      current_spiffs_version = parseVersion(version.c_str());
      LOG(ELOG_LEVEL_DEBUG, "Current LittleFS Version: %d.%d.%d", current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch);
    }
    LOG(ELOG_LEVEL_DEBUG, "LittleFS initialized");
    LOG(ELOG_LEVEL_DEBUG, "Starting main tasks");
    
    
    if (dataQueue == NULL) {
        LOG(ELOG_LEVEL_ERROR, "Failed to create data queue");
    } else {
        xTaskCreate(ethernet_task, "EthernetTask", 1024 * 4, dataQueue, 1, NULL);
        xTaskCreate(wifi_task, "WiFiTask", 1024 * 4, dataQueue, 1, NULL);
        // Create sensor queues struct
        SensorQueues sensorQueues = {
            .dataQueue = dataQueue,
            .prefsQueue = prefsForSensorQueue
        };
        xTaskCreate(read_sensor_task, "ReadSensorTask", 1024 * 4, &sensorQueues, 1, NULL);
        xTaskCreate(collect_internal_telemetry_task, "InternalTelemetryTask", 1024 * 2, dataQueue, 1, NULL);
        xTaskCreate(display_task, "DisplayTask", 1024 * 2, NULL, 1, NULL);
        xTaskCreate(get_time_task, "GetTimeTask", 1024 * 2, NULL, 1, NULL);
        xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 6, dataQueue, 1, NULL);
        // Create webserver queues struct
        WebserverQueues webserverQueues = {
            .stateQueue = stateForWebserverQueue,
            .dataQueue = dataQueue,
            .prefsQueue = prefsForWebserverQueue
        };
        xTaskCreate(webserver_task, "WebServerTask", 1024 * 4, &webserverQueues, 1, NULL);
        xTaskCreate(ota_handler_task, "OTAHandlerTask", 1024 * 4, NULL, 3, NULL);
    }
}

void loop()
{
    size_t free_heap = heap_caps_get_free_size(MALLOC_CAP_8BIT);
    Serial.println(free_heap);

    // Check if there is new data in the queue
    DataMessage dataMessage;
    if (xQueueReceive(dataQueue, &dataMessage, portMAX_DELAY) == pdTRUE) {
        // Decode the data based on its type and update the current state
        switch (dataMessage.type) {
            case DATA_TYPE_WATER:
                current_state.waterData = dataMessage.data.waterData;
                LOG(ELOG_LEVEL_DEBUG, "Received water data: level=%F, liters=%F, percentage=%F",
                    current_state.waterData.level, current_state.waterData.liters, current_state.waterData.percentage);
                break;
            case DATA_TYPE_SENSOR:
                current_state.sensorData = dataMessage.data.sensorData;
                LOG(ELOG_LEVEL_DEBUG, "Received sensor data: bus_voltage=%F, shunt_voltage=%F, shunt_current=%F",
                    current_state.sensorData.bus_voltage, current_state.sensorData.shunt_voltage, current_state.sensorData.shunt_current);
                break;
            case DATA_TYPE_WIFI:
                current_state.wifiData = dataMessage.data.networkData;
                LOG(ELOG_LEVEL_DEBUG, "Received WiFi data: ip=%s, link=%d, rssi=%F, name=%s",
                    current_state.wifiData.ip_address, current_state.wifiData.link,
                    current_state.wifiData.rssi, current_state.wifiData.network_name);
                break;
            case DATA_TYPE_ETHERNET:
                current_state.ethernetData = dataMessage.data.networkData;
                LOG(ELOG_LEVEL_DEBUG, "Received Ethernet data: ip=%s, link=%d, rssi=%F, name=%s",
                    current_state.ethernetData.ip_address, current_state.ethernetData.link,
                    current_state.ethernetData.rssi, current_state.ethernetData.network_name);
                break;
            case DATA_TYPE_TELEMETRY:
                current_state.telemetryData = dataMessage.data.telemetryData;
                LOG(ELOG_LEVEL_DEBUG, "Received telemetry data: heap=%F, uptime=%d, temperature=%F",
                    current_state.telemetryData.heap_used_percent, current_state.telemetryData.uptime_seconds,
                    current_state.telemetryData.temperature);
                break;
            case DATA_TYPE_OTA:
                current_state.otaStatus = dataMessage.data.otaStatus;
                LOG(ELOG_LEVEL_DEBUG, "Received OTA status: update_available=%d, current=%d.%d.%d, latest=%d.%d.%d",
                    current_state.otaStatus.update_available,
                    current_state.otaStatus.current_version.major, current_state.otaStatus.current_version.minor, current_state.otaStatus.current_version.patch,
                    current_state.otaStatus.latest_version.major, current_state.otaStatus.latest_version.minor, current_state.otaStatus.latest_version.patch);
                break;
            case DATA_TYPE_PREFERENCES:
                // Store preferences in flash and forward to webserver
                LOG(ELOG_LEVEL_DEBUG, "Received preference update request");
                
                // Write to preferences storage
                prefs.putFloat(level_sensor_range_key, dataMessage.data.preferencesData.level_sensor_range);
                prefs.putFloat(water_level_min_key, dataMessage.data.preferencesData.water_level_min);
                prefs.putFloat(water_level_max_key, dataMessage.data.preferencesData.water_level_max);
                prefs.putFloat(water_volume_key, dataMessage.data.preferencesData.water_volume);
                prefs.putString(ssid_key, dataMessage.data.preferencesData.ssid);
                prefs.putString(wifi_password_key, dataMessage.data.preferencesData.wifi_password);
                
                // Forward to webserver so it can update its local copy
                if (prefsForWebserverQueue != NULL) {
                    if (xQueueSend(prefsForWebserverQueue, &dataMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
                        LOG(ELOG_LEVEL_ERROR, "Failed to forward preferences to webserver queue");
                    }
                }
                
                // Forward to sensor task so it can update its local copy
                if (prefsForSensorQueue != NULL) {
                    if (xQueueSend(prefsForSensorQueue, &dataMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
                        LOG(ELOG_LEVEL_ERROR, "Failed to forward preferences to sensor queue");
                    }
                }
                LOG(ELOG_LEVEL_DEBUG, "Stored preferences and forwarded to tasks");
                break;
            default:
                LOG(ELOG_LEVEL_ERROR, "Unknown data type received");
                break;
        }
        // Send the updated current_state to the webserver queue (for non-preference messages)
        if (dataMessage.type != DATA_TYPE_PREFERENCES) {
            if (xQueueSendToBack(stateForWebserverQueue, &current_state, 250 / portTICK_PERIOD_MS) != pdTRUE) {
                LOG(ELOG_LEVEL_ERROR, "Failed to send current_state to webserver queue");
            }
        }
    } else {
        LOG(ELOG_LEVEL_WARNING, "No message received within max wait");
    }
    
    delay(1000);
}