#include <Wire.h>
#include <U8g2lib.h>

#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <ESPAsync_WiFiManager.h>
#include <ElegantOTA.h>

#include <FS.h>
#include <SPIFFS.h>
#include <ArduinoJson.h>

#define FORMAT_SPIFFS_IF_FAILED true

#define PIN_LED_GREEN 14
#define PIN_LED_RED 33
#define PIN_LED_YELLOW 32
#define PIN_BTN_PLUS 15
#define PIN_BTN_MINUS 13
#define PIN_BTN_ENTER 25

#define I2C_SDA 17
#define I2C_SCL 16

#define DBM_ADDR 0x48
#define DBM_REG_DECIBEL 0x0A
#define DBM_REG_VERSION 0x00

#define HTTP_PORT 80

#define MAX_CHARATERS 30

const char* config_filename = "/config.json";

String user;
const char* username = "admin";
String pass;
const char* password = "admin";

const char* hostName = "FONOMETRO";

int num_schermate = 5;
int menu_btn = 0;
uint8_t db = 0;
uint8_t th_val_low = 60;
uint8_t th_val_high = 65;

int8_t brightness = 20;

char buffer[45];

U8G2_SSD1306_128X64_NONAME_F_HW_I2C display(U8G2_R0, /* reset=*/U8X8_PIN_NONE);

TwoWire dbmeter = TwoWire(1);

AsyncWebServer server(HTTP_PORT);
AsyncDNSServer dns;

void setup() {
  Serial.begin(115200);
  Serial.println("Starting...");

  Wire.setClock(10000);
  Wire.begin();
  display.begin();

  display.setFont(u8g2_font_helvR14_tf);
  display.drawStr(0, 15, "Fonometro");
  display.sendBuffer();

  ESPAsync_WiFiManager wifiManager(&server, &dns, hostName);

  if (!wifiManager.autoConnect("ESP32-Config-AP")) {
    Serial.println("Failed to connect to WiFi, restarting...");
    delay(3000);
    ESP.restart();
  }

  Serial.print("Connected successfully to network ");
  Serial.println(WiFi.SSID());

  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());

  if (!SPIFFS.begin(FORMAT_SPIFFS_IF_FAILED)) {
    Serial.println("\nSPIFFS mount failed");
    return;
  }

  Serial.println("\nSPIFFS mounted successfully");

  if (!SPIFFS.exists(config_filename)) writeDefaultConfig(config_filename);
  loadConfiguration();

  ElegantOTA.begin(&server);

  init_server();
  Serial.println(F("\nHTTP server started"));

  pinMode(PIN_BTN_PLUS, INPUT_PULLUP);
  pinMode(PIN_BTN_MINUS, INPUT_PULLUP);
  pinMode(PIN_BTN_ENTER, INPUT_PULLUP);

  pinMode(PIN_LED_GREEN, OUTPUT);
  pinMode(PIN_LED_YELLOW, OUTPUT);
  pinMode(PIN_LED_RED, OUTPUT);

  digitalWrite(PIN_LED_RED, 1);
  digitalWrite(PIN_LED_YELLOW, 1);
  digitalWrite(PIN_LED_GREEN, 1);

  delay(1000);

  digitalWrite(PIN_LED_RED, 0);
  digitalWrite(PIN_LED_YELLOW, 0);
  digitalWrite(PIN_LED_GREEN, 0);

  delay(3000);

  dbmeter.begin (I2C_SDA, I2C_SCL, 10000);
}

void loop() {

  if (WiFi.status() != WL_CONNECTED) ESP.restart();

  ElegantOTA.loop();

  display.clearBuffer();

  db = dbmeter_readreg(&dbmeter, DBM_REG_DECIBEL);

  if (digitalRead(PIN_BTN_ENTER) == 0) {
    menu_btn++;
    if (menu_btn > num_schermate) menu_btn = 0;
  }

  if (menu_btn == 0) {
    display.drawStr(0, 15, "Value:");
    snprintf(buffer, sizeof(buffer), "%d dB", db);
    display.drawStr(0, 45, buffer);
    display.sendBuffer();
    delay(100);
  } else if (menu_btn == 1) {
    display.drawStr(0, 15, "Low_th_val:");
    snprintf(buffer, sizeof(buffer), "%d dB", th_val_low);
    display.drawStr(0, 45, buffer);
    display.sendBuffer();
    delay(100);

    if (digitalRead(PIN_BTN_PLUS) == 0) th_val_low++;
    else if (digitalRead(PIN_BTN_MINUS) == 0) th_val_low--;

  } else if (menu_btn == 2) {
    display.drawStr(0, 15, "High_th_val:");
    snprintf(buffer, sizeof(buffer), "%d dB", th_val_high);
    display.drawStr(0, 45, buffer);
    display.sendBuffer();
    delay(100);

    if (digitalRead(PIN_BTN_PLUS) == 0) th_val_high++;
    else if (digitalRead(PIN_BTN_MINUS) == 0) th_val_high--;

  } else if (menu_btn == 3) {
    display.drawStr(0, 15, "Brightness:");
    snprintf(buffer, sizeof(buffer), "%d %", brightness);
    display.drawStr(0, 45, buffer);
    display.sendBuffer();
    delay(100);

    if (digitalRead(PIN_BTN_PLUS) == 0) {
      brightness++;
      if (brightness > 100) brightness = 100;
    } else if (digitalRead(PIN_BTN_MINUS) == 0) {
      brightness--;
      if (brightness < 1) brightness = 1;
    }
  } else if (menu_btn == 4) {
    display.drawStr(0, 15, "IP Address: ");
    snprintf(buffer, sizeof(buffer), "%s", WiFi.localIP().toString().c_str());
    display.drawStr(0, 45, buffer);
    display.sendBuffer();
    delay(100);
  } else if (menu_btn == 5) {
    display.drawStr(0, 15, "Do you want to save to memory?");
    display.drawStr(0, 45, "Press ENTER to confirm");
    display.sendBuffer();
    delay(100);
    if (digitalRead(PIN_BTN_ENTER) == 0) {
      saveConfiguration();
      printConfigFile(config_filename);
      delay(1000);
      menu_btn = 0;
    }

  }

  uint8_t pwm_value = map(brightness, 0, 100, 0, 255);

  if (db <= th_val_low) {
    analogWrite(PIN_LED_RED, pwm_value);
    analogWrite(PIN_LED_YELLOW, 0);
    analogWrite(PIN_LED_GREEN, 0);
  } else if (db <= th_val_high) {
    analogWrite(PIN_LED_RED, 0);
    analogWrite(PIN_LED_YELLOW, pwm_value);
    analogWrite(PIN_LED_GREEN, 0);
  } else {
    analogWrite(PIN_LED_RED, 0);
    analogWrite(PIN_LED_YELLOW, 0);
    analogWrite(PIN_LED_GREEN, pwm_value);
  }

}

uint8_t dbmeter_readreg (TwoWire *dev, uint8_t regaddr)
{
  dev->beginTransmission (DBM_ADDR);
  dev->write (regaddr);
  dev->endTransmission();
  dev->requestFrom (DBM_ADDR, 1);
  delay (10);
  return dev->read();
}

void loadConfiguration() {
  File file = SPIFFS.open(config_filename, "r");
  if (!file) {
    Serial.print(F("Error opening file: unable to open "));
    Serial.println(config_filename);
    return;
  }

  StaticJsonDocument<2048> doc;
  DeserializationError error = deserializeJson(doc, file);
  if (error) {
    Serial.println(F("Error reading file: "));
    Serial.println(error.c_str());
  }
  file.close();

  JsonObject root = doc.as<JsonObject>();
  user = root["Username"].as<String>();
  pass = root["Password"].as<String>();
  username = user.c_str();
  password = pass.c_str();

  th_val_low = root["LowThreshold"].as<int>();
  th_val_high = root["HighThreshold"].as<int>();
  brightness = root["Brightness"].as<int>();

  Serial.print(F("\nUsername: "));
  Serial.println(username);
  Serial.print(F("Password: "));
  Serial.println(password);
  Serial.print(F("Low Threshold: "));
  Serial.println(th_val_low);
  Serial.print(F("High Threshold: "));
  Serial.println(th_val_high);
  Serial.print(F("Brightness: "));
  Serial.println(brightness);

  Serial.println(F("\nConfiguration loaded!"));
}

void writeDefaultConfig(const char *filename) {
  Serial.println(F("Loading default configuration..."));

  File file = SPIFFS.open(filename, "w");

  if (!file) {
    Serial.println(F("Error opening file"));
    return;
  }

  String defaultConfig = "{"
                         "\"Username\": \"admin\","
                         "\"Password\": \"admin\","
                         "\"LowThreshold\": 60,"
                         "\"HighThreshold\": 65,"
                         "\"Brightness\": 20"
                         "}";

  file.print(defaultConfig);
  file.close();

  Serial.println(F("Loaded default configuration!"));
}

String FS_readConfig() {
  File file = SPIFFS.open(config_filename, "r");
  if (!file) {
    Serial.println(F("Error reading file"));
    return "";
  }
  String fileContent = file.readString();
  file.close();
  return fileContent;
}

void printConfigFile(const char *filename) {
  File file = SPIFFS.open(filename, "r");
  if (!file) {
    Serial.println(F("Error reading file"));
    return;
  }

  while (file.available()) {
    Serial.print((char)file.read());
  }
  Serial.println();
  file.close();
}

void saveConfiguration() {
  StaticJsonDocument<2048> doc;
  JsonObject root = doc.to<JsonObject>();

  root["Username"] = user;
  root["Password"] = pass;
  root["LowThreshold"] = th_val_low;
  root["HighThreshold"] = th_val_high;
  root["Brightness"] = brightness;

  File file = SPIFFS.open(config_filename, "w");
  if (!file) {
    Serial.println(F("Error opening file"));
    return;
  }

  serializeJson(doc, file);
  file.close();

  Serial.println(F("Configuration saved!"));
}

void init_server() {

  server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) {
    if (!request->authenticate(username, password))
      return request->requestAuthentication();
    AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/index.html", "text/html");
    response->addHeader("Cache-Control", "max-age=3600");
    request->send(response);
  });

  server.on("/style.css", HTTP_GET, [](AsyncWebServerRequest * request) {
    AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/style.css", "text/css");
    response->addHeader("Cache-Control", "max-age=3600");
    request->send(response);
  });

  server.on("/script.js", HTTP_GET, [](AsyncWebServerRequest * request) {
    AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/script.js", "application/javascript");
    response->addHeader("Cache-Control", "max-age=3600");
    request->send(response);
  });

  server.on("/upload", HTTP_POST, [](AsyncWebServerRequest * request) {
  }, NULL, [](AsyncWebServerRequest * request, uint8_t *data, size_t len, size_t index, size_t total) {
    String jsondata;
    for (size_t i = 0; i < len; i++) {
      jsondata += (char)data[i];
    }

    DynamicJsonDocument doc(2048);
    deserializeJson(doc, jsondata);
    th_val_low = doc["LowThreshold"];
    th_val_high = doc["HighThreshold"];
    brightness = doc["Brightness"];

    Serial.println("\nSaving data into variables");
    Serial.print(F("Low Threshold: "));
    Serial.println(th_val_low);
    Serial.print(F("High Threshold: "));
    Serial.println(th_val_high);
    Serial.print(F("Brightness: "));
    Serial.println(brightness);

    request->send(200);
  });

  server.on("/saveToMemory", HTTP_POST, [](AsyncWebServerRequest * request) {
  }, NULL, [](AsyncWebServerRequest * request, uint8_t *data, size_t len, size_t index, size_t total) {
    String new_config;
    for (size_t i = 0; i < len; i++) {
      new_config += (char)data[i];
    }

    Serial.println(F("\nWriting new configuration..."));
    Serial.println(new_config);

    if (SPIFFS.begin()) {
      File f = SPIFFS.open(config_filename, "w"); // Assicurati che il nome del file sia corretto
      if (f) {
        f.print(new_config);
        f.close();
        request->send(200, "text/plain", "Configuration loaded successfully");
        delay(1000);
        ESP.restart();  // da vedere se riavviare
      } else {
        request->send(500, "text/plain", "Error during attempt to save configuration");
      }
    }
  });

  server.on("/getStartupConfig", HTTP_GET, [](AsyncWebServerRequest * request) {
    String configData = FS_readConfig();
    if (configData.length() > 0) {
      request->send(200, "application/json", configData);
    } else {
      request->send(500, "text/plain", "Error during attempt to read the configuration");
    }
  });

  server.on("/getRunningConfig", HTTP_GET, [](AsyncWebServerRequest * request) {
    StaticJsonDocument<2048> doc;

    JsonObject object = doc.to<JsonObject>();
    object["Username"] = username;
    object["Password"] = password;
    object["LowThreshold"] = th_val_low;
    object["HighThreshold"] = th_val_high;
    object["Brightness"] = brightness;

    String response;
    serializeJson(object, response);

    request->send(200, "application/json", response);
  });

  server.on("/restart", HTTP_GET, [](AsyncWebServerRequest * request) {
    AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/index.html", "text/html");
    request->send(response);
    delay(1000);
    ESP.restart();
  });

  server.begin();

}