#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>

struct SensorConfig {
  String name;
  int trigPin;
  int echoPin;
  String moduleType;
} sensors[100];

struct SensorData {
  unsigned long timestamp;
  float value;
  String name;
} data_sensors[100];

struct Module {
  String type;
  String category;
  String subCategory;
  String name;
  String pins; // Simplified as a String; adjust based on your needs
  String description; // Optional, only if a sixth part exists
};

// Maximum number of modules you can handle
const int maxModules = 25; 
Module modules[maxModules]; // Array to store modules
int moduleCount = 0; // Counter for the number of modules processed

int sensorCount = 0;
int loopCount = 0;
int dataCount = 0;

bool initWiFi();
bool waitForConnection();
void fetchAndProcessSetupData();
void processLineSetupData(const String& line);
void processSetupData(const String& payload);
void initModuleUltrasonicDistanceSensor(String name, int trigPin, int echoPin, String moduleType); // Perubahan definisi fungsi
void getModuleUltrasonicDistanceSensorData(String name);
void addSensorData(String name, float value);
void sendDataSensorToServer();;

const char* ssid = "";
const char* password = "";
String receiverHookUrl = "http://d003-103-190-47-50.ngrok-free.app/afk/test";
String setupHookUrl = "http://d003-103-190-47-50.ngrok-free.app/afk/test_setup";


void setup() {
  Serial.begin(115200);
  Serial.println("Mulai Versi: 0.0.4");
  if (!initWiFi()) {
    Serial.println("Gagal terhubung ke jaringan WiFi terbuka.");
    return;
  }
  fetchAndProcessSetupData();
}

void loop() {
  loopCount = loopCount+1;
  Serial.print("\n\nLoop Start");
  Serial.println(loopCount);
  loadDataSensors();
  sendDataSensorToServer();
  Serial.println("Loop End, waiting for 15s");
  delay(15000);
}

bool initWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);
  Serial.println("Memindai jaringan WiFi terbuka...");
  int n = WiFi.scanNetworks();
  for (int i = 0; i < n; ++i) {
    if (WiFi.encryptionType(i) == WIFI_AUTH_OPEN) {
      Serial.print("Menghubungkan ke ");
      Serial.println(WiFi.SSID(i));
      WiFi.begin(WiFi.SSID(i).c_str(), "");
      if (waitForConnection()) {
        Serial.println("Terhubung.");
        return true;
      } else {
        Serial.println("Gagal menghubungkan. Mencoba jaringan berikutnya...");
      }
    }
  }
  return false;
}

void sendDataSensorToServer() {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;


    Serial.println("Start request to: " + receiverHookUrl);
    DynamicJsonDocument doc(1024);
    JsonArray data = doc.to<JsonArray>();
    for (int i = 0; i < dataCount; i++) {
      JsonObject obj = data.createNestedObject();
      obj["name"] = data_sensors[i].name;
      obj["value"] = data_sensors[i].value;
      obj["timestamp"] = data_sensors[i].timestamp;
    }
    String output;
    serializeJson(doc, output);
    http.begin(receiverHookUrl); 
    Serial.println("Sending POST request...");
    Serial.println("Payload: " + output);
    http.addHeader("Content-Type", "application/json");
    int httpResponseCode = http.POST(output);
    if (httpResponseCode > 0) {
      String response = http.getString();
      Serial.println("Response code: " + String(httpResponseCode));
      Serial.println("Response: " + response);
    } else {
      Serial.print("Error on sending POST: ");
      Serial.println(httpResponseCode);
    }
    http.end();
    Serial.println("Data sensor telah dikirim ke server.");
  } else {
    Serial.print("Data sensor GAGAL dikirim ke server, ");
    Serial.println("WiFi not connected");
  }
}

void loadDataSensors() {
  Serial.println("Mulai load data sensors");
  for (int i = 0; i < sensorCount; i++) {
    Serial.println("Memuat data sensor: " + sensors[i].name);
    if (sensors[i].moduleType == "ultrasonic_distance_sensor") {
      Serial.println("Module type found: " + sensors[i].moduleType);
      getModuleUltrasonicDistanceSensorData(sensors[i].name);
    }else{
      Serial.println("Module type not found");
    }
  }
  Serial.println("Semua data sensor terbaru telah dimuat.");
}

bool waitForConnection() {
  Serial.println("Menunggu koneksi WiFi...");
  for (int j = 0; j < 10 && WiFi.status() != WL_CONNECTED; ++j) {
    delay(1000);
    Serial.print(".");
  }
  Serial.println(WiFi.status() == WL_CONNECTED ? "Terhubung ke WiFi." : "Gagal terhubung.");
  return WiFi.status() == WL_CONNECTED;
}

void fetchAndProcessSetupData() {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    http.begin(setupHookUrl);
    int httpCode = http.GET();
    if (httpCode > 0) {
      String payload = http.getString();
      Serial.println("Payload diterima:");
      Serial.println(payload);
      processSetupData(payload);
    } else {
      
      Serial.println("Gagal mengambil data.");
    }
    http.end();
  } else {
    Serial.println("Tidak terhubung ke WiFi.");
  }
}

void processSetupData(const String& payload) {
    /*
      Payload Sample:
      module  |sensor     | ultrasonic_distance_sensor  |ketinggian_isi   |1,2
      module  |actuator   | relay                       |motor_cuci       |3
      module  |actuator   | relay                       |motor_pompa      |4
    */
    Serial.println("Processing SetupData payload...");

    int lineStart = 0;
    int lineEnd;
    String line;

    // Loop on payload by lines
    while ((lineEnd = payload.indexOf('\n', lineStart)) != -1) {
      line = payload.substring(lineStart, lineEnd);
      processLineSetupData(line);
      lineStart = lineEnd + 1;
    }
    // Process the last line if it doesn't end with a newline character
    if (lineStart < payload.length()) {
      line = payload.substring(lineStart);
      processLineSetupData(line);
    }
}




void processLineSetupData(const String& line) {
    /*

      
      Payload Sample:
      module  |sensor     | ultrasonic_distance_sensor  |ketinggian_isi   |1,2
      module  |actuator   | relay                       |motor_cuci       |3
      module  |actuator   | relay                       |motor_pompa      |4
    */
    
  // Check if there's space for more modules
    if (moduleCount >= maxModules) {
      Serial.println("Max module limit reached.");
      return;
    }
    
    // Tokenize the line by '|'
    int partsIndex = 0;
    int lastPos = 0;
    String parts[6]; // Maximum 6 parts based on your description
    for (int i = 0; i < line.length(); i++) {
      if (line[i] == '|' || i == line.length() - 1) {
        parts[partsIndex] = line.substring(lastPos, i);
        parts[partsIndex].trim();
        partsIndex++;

        lastPos = i + 1;
      }
    }
    
    // Populate the module
    modules[moduleCount].type = parts[0];
    modules[moduleCount].category = parts[1];
    modules[moduleCount].subCategory = parts[2];
    modules[moduleCount].name = parts[3];
    modules[moduleCount].pins = parts[4];
    if (partsIndex == 6) { // Check if there was a description
      modules[moduleCount].description = parts[5];
    }
    initModuleUltrasonicDistanceSensor(modules[moduleCount]);
    Serial.println("Processed module: " + modules[moduleCount].name);
    moduleCount++; // Increment the module counter


    if (modules[moduleCount].category == "sensor") {
      Serial.println("Found sensor: " + String(modules[moduleCount].subCategory));
      if (modules[moduleCount].subCategory == "ultrasonic_distance_sensor") {
        Serial.println("Found ultrasonic_distance_sensor: " + String(subCategory));
        initModuleUltrasonicDistanceSensor(modules[moduleCount]);

      } else if (modules[moduleCount].subCategory == "turbidity_sensor") {
        Serial.println("Found turbidity_sensor: " + String(modules[moduleCount].subCategory));
        // initModuleTurbiditySensor(module);
      }else{
        Serial.println("SENSOR LAINNYA DITEMUKAN");
      }
       // Add more sensor types as needed
    } else if (modules[moduleCount].category == "actuator") {
      // Here you can handle actuators, similar to how sensors are handled
    }
}



  /*

  if (error) {
    Serial.print(F("deserializeJson() failed: "));
    Serial.println(error.f_str());
    return;
  }

  Serial.println("Processing JSON...");
  JsonArray array = doc["modules"].as<JsonArray>(); // Akses array dengan kunci "modules"
  for (JsonVariant module : array) {
    Serial.println("Processing module: " + String(module["name"].as<String>()));
    String category = module["category"];
    String subCategory = module["sub_category"];
    Serial.println("Found module: " + String(subCategory));
    
  }
  Serial.println("JSON processing complete.");
}

void initModuleRelay(JsonVariant module) {
  // Initialize Relay module here
  Serial.println("Initializing Relay Module: " + String(module["name"].as<String>()));
}

void setModuleRelayData() {
  // Code to set data for the Relay module
  Serial.println("Setting data for Relay Module.");
}

void initModuleTurbiditySensor(module) {
  // Initialize Turbidity Sensor here
  Serial.println("Initializing Turbidity Sensor: " + String(module["name"].as<String>()));
}

void getModuleTurbiditySensorData() {
  // Code to get data from the Turbidity Sensor
  Serial.println("Getting data from Turbidity Sensor.");
}
  */

void initModuleUltrasonicDistanceSensor(const Module& module) {
  String name = module["name"];
  String pins = module["pin"];
  String moduleType = module["sub_category"];
  int commaIndex = pins.indexOf(',');
  int trigPin = pins.substring(0, commaIndex).toInt();
  int echoPin = pins.substring(commaIndex + 1).toInt();

  Serial.print("Initializing ultrasonic sensor: ");
  Serial.println(name);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  sensors[sensorCount++] = {name, trigPin, echoPin, moduleType};
}

void getModuleUltrasonicDistanceSensorData(String name) {
  Serial.print("Mulai getModuleUltrasonicDistanceSensorDat: ");
  Serial.println(name);
  long duration;
  float distance;

  for (int i = 0; i < sensorCount; i++) {
    if (sensors[i].name == name) {
      digitalWrite(sensors[i].trigPin, LOW);
      delayMicroseconds(2);
      digitalWrite(sensors[i].trigPin, HIGH);
      delayMicroseconds(10);
      digitalWrite(sensors[i].trigPin, LOW);
      duration = pulseIn(sensors[i].echoPin, HIGH);
      distance = (duration * 0.0343) / 2;
      Serial.print("Distance to ");
      Serial.print(name);
      Serial.print(": ");
      Serial.print(distance);
      Serial.println(" cm");
      addSensorData(name, distance);
      return;
    }
  }
  Serial.println("Sensor named '" + name + "' not found.");
}

void addSensorData(String name, float value) {
  if (dataCount < 10) {
    data_sensors[dataCount] = {millis(), value, name};
    Serial.print("Data for ");
    Serial.print(name);
    Serial.print(" with value ");
    Serial.print(value);
    Serial.print(" stored at timestamp ");
    Serial.println(data_sensors[dataCount++].timestamp);
  } else {
    Serial.println("Data storage capacity reached.");
  }
}