#include <Arduino.h>
#include "tools.h"
#include <Elog.h>
#include "../global_data/defines.h"
#include <Preferences.h>
#include <fetchOTA.h>
#include <AsyncWebSocket.h>
#include "log.h"

extern Preferences prefs;
extern OTAStatus ota_status;
// extern AsyncWebSocket webSocket;

extern Version current_spiffs_version;

bool is_error(ActiveErrors active_errors) {
    return active_errors.current_high || active_errors.current_low || active_errors.level_high || active_errors.level_low || active_errors.voltage_high || active_errors.voltage_low;
}

String processor(const String& var)
{
  if (var == level_sensor_range_key) {
    return String(prefs.getFloat(level_sensor_range_key, -1));
  } else if (var == water_level_min_key) {
    return String(prefs.getFloat(water_level_min_key, -1));
  } else if (var == water_level_max_key) {
    return String(prefs.getFloat(water_level_max_key, -1));
  } else if (var == water_volume_key) {
    return String(prefs.getFloat(water_volume_key, -1));
  } else if (var == ssid_key) {
    return String(prefs.getString(ssid_key, ""));
  }
    
  return String("");
}

// OTA Callbacks
void update_started() {
  LOG(ELOG_LEVEL_DEBUG, "OTA Update started");
  ota_status.update_progress = 0;
}

void update_finished() {
  LOG(ELOG_LEVEL_DEBUG, "OTA Update finished");
  ota_status.update_progress = -1;
  // webSocket.textAll(String(-1).c_str());
}

void update_progress(int cur, int total) {
  ota_status.update_progress = 0;
  if (cur != 0 ) {
    ota_status.update_progress = int(float(cur)/float(total)*100);
    LOG(ELOG_LEVEL_DEBUG, "OTA Update progress: %d/%d, %i", cur, total, ota_status.update_progress);
  }
  // webSocket.textAll(String(ota_status.update_progress).c_str());
  LOG(ELOG_LEVEL_DEBUG, "OTA Update progress: %d/%d", cur, total);
}

void update_error(int err) {
  LOG(ELOG_LEVEL_ERROR, "OTA Update error: %d", err);
  ota_status.update_progress = -2;
}

void check_update_task(void* parameter) {
  ota_status.current_version = current_software_version;
  ota_status.update_progress = -1;
  #ifdef USE_INA226
  OTA ota("https://iot.tobiasmaier.me/firmware/waterlevel", current_software_version, "INA226");
  #else
  OTA ota("https://iot.tobiasmaier.me/firmware/waterlevel", current_software_version, "INA233");
  #endif
  OTA spiffs_fs("https://iot.tobiasmaier.me/filesystem/waterlevel", REQUIRED_SPIFFS_VERSION, "generic");
  

  // Init SPIFFS update and check for update
  // If there is a SPIFSS update it will be ran automatically, as SPIFFS is necessary for the firmware to run
  Firmware latest_spiff_version = spiffs_fs.getLatestVersionOnServer();

  LOG(ELOG_LEVEL_DEBUG, "Required SPIFFS Version: %d.%d.%d; Current SPIFFS version: %d.%d.%d; Server SPIFFS Version: %d.%d.%d", REQUIRED_SPIFFS_VERSION.major, REQUIRED_SPIFFS_VERSION.minor, REQUIRED_SPIFFS_VERSION.patch, current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch, latest_spiff_version.version.major, latest_spiff_version.version.minor, latest_spiff_version.version.patch);

  if (latest_spiff_version.valid) {
    if (isVersionNewer(current_spiffs_version, REQUIRED_SPIFFS_VERSION)) {
      // If Required SPIFFS version is newer than current version, update
      LOG(ELOG_LEVEL_DEBUG, "New SPIFFS version, running update now");
      run_ota_spiffs_update(latest_spiff_version.url, update_started, update_finished, update_progress, update_error);
      // Reboot just to be safe
      ESP.restart();
    } else if (isVersionNewer(REQUIRED_SPIFFS_VERSION, latest_spiff_version.version)) {
      // If Server has new SPIFFS version but it's not required
      LOG(ELOG_LEVEL_DEBUG, "New SPIFFS version available: %d.%d.%d, current version: %d.%d.%d but not necessary to update", latest_spiff_version.version.major, latest_spiff_version.version.minor, latest_spiff_version.version.patch, REQUIRED_SPIFFS_VERSION.major, REQUIRED_SPIFFS_VERSION.minor, REQUIRED_SPIFFS_VERSION.patch);
    } else {
      LOG(ELOG_LEVEL_DEBUG, "No new SPIFFS version available");
    }
  }


  while (true) {
    Firmware fw = ota.getLatestVersionOnServer();
    if (fw.valid) {
      LOG(ELOG_LEVEL_DEBUG, "New firmware available: %d.%d.%d, current version: %d.%d.%d", fw.version.major, fw.version.minor, fw.version.patch, current_software_version.major, current_software_version.minor, current_software_version.patch);
      ota_status.latest_version = fw.version;
      ota_status.update_url = fw.url;
      if (isVersionNewer(current_software_version, fw.version)) {
        LOG(ELOG_LEVEL_DEBUG, "Remote version is newer than current version");
        ota_status.update_available = true;
      } else {
        ota_status.update_available = false;
      }
    } else {
      if (fw.version.major != 0 && fw.version.minor != 0 && fw.version.patch != 0) {
        ota_status.latest_version = fw.version;
        ota_status.update_available = false;
      }
      
      LOG(ELOG_LEVEL_DEBUG, "No new firmware available");
    }
    delay(1000 * 60 * 1);
  }
}



void run_ota_update_task(void* parameter) {
  TaskArgs_t *args = (TaskArgs_t *) parameter;
  LOG(ELOG_LEVEL_DEBUG, "Running OTA upgrade now with URL: %s", args->ota_status.update_url.c_str());
  run_ota_update(args->ota_status.update_url, update_started, update_finished, update_progress, update_error);
  vTaskDelete(NULL);
}

// void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type,
//   void *arg, uint8_t *data, size_t len) {
//   if (type == WS_EVT_CONNECT) {
//   Serial.println("WebSocket client connected");
//   } else if (type == WS_EVT_DISCONNECT) {
//   Serial.println("WebSocket client disconnected");
//   } else if (type == WS_EVT_DATA) {
//   // Optionally process data received from the client
//   }
// }