AquaMasterMQTT/src/databasebackend.h

#pragma once
#include <Arduino.h>
#include <ArduinoJson.h>
#include <ESPAsyncWebServer.h>
#include <HTTPClient.h>
#include <preferencemanager.h>

const char *BACKEND_SERVER = "https://ninja.reptilfpv.de";
extern String
    licence; // Declare licence as an external variable defined elsewhere
String BACKEND_TOKEN =
    licence; // Use the licence as the token for authentication

bool backendOnline() {

  Serial.println(licence);

  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("No WiFi connection.");
    return false;
  }

  HTTPClient http;
  http.begin(String(BACKEND_SERVER) + "/v1/private/health");
  http.addHeader("Authorization", String("Bearer ") + BACKEND_TOKEN);

  int httpCode = http.GET();
  bool isOnline = (httpCode == HTTP_CODE_OK);

  if (isOnline) {
    Serial.println("Database server connection successful");
  } else {
    Serial.printf("Database server connection failed, error: %d\n", httpCode);
  }

  http.end();
  return isOnline;
}

struct UserData {
  String uid;
  String firstname;
  String lastname;
  int alter;
  bool exists;
};

// Prüft, ob ein Benutzer mit der angegebenen UID in der Datenbank existiert und
// gibt dessen Daten zurück.
UserData checkUser(const String &uid) {

  UserData userData = {"", "", "", 0, false};

  if (!backendOnline()) {
    Serial.println("No internet connection, cannot check user.");
    return userData;
  }

  HTTPClient http;
  http.begin(String(BACKEND_SERVER) + "/v1/private/users/find");
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", String("Bearer ") + BACKEND_TOKEN);

  // Create JSON payload
  StaticJsonDocument<200> requestDoc;
  requestDoc["uid"] = uid;
  String requestBody;
  serializeJson(requestDoc, requestBody);

  int httpCode = http.POST(requestBody);

  if (httpCode == HTTP_CODE_OK) {
    String payload = http.getString();
    StaticJsonDocument<512> responseDoc;
    DeserializationError error = deserializeJson(responseDoc, payload);

    if (!error) {
      userData.uid = responseDoc["uid"].as<String>();
      userData.firstname = responseDoc["firstname"].as<String>();
      userData.lastname = responseDoc["lastname"].as<String>();
      userData.alter = responseDoc["alter"] | 0;
      userData.exists = responseDoc["exists"] | false;
    }
  } else {
    Serial.printf("User check failed, HTTP code: %d\n", httpCode);
  }

  http.end();
  return userData;
}

// Holt alle Standorte aus der Datenbank und gibt sie als JSON-Dokument zurück.
JsonDocument getAllLocations() {
  JsonDocument locations; // Allocate memory for the JSON document

  if (!backendOnline()) {
    Serial.println("No internet connection, cannot fetch locations.");
    return locations; // Return an empty document
  }

  HTTPClient http;
  http.begin(String(BACKEND_SERVER) + "/v1/private/locations");
  http.addHeader("Authorization", String("Bearer ") + BACKEND_TOKEN);

  int httpCode = http.GET();

  if (httpCode == HTTP_CODE_OK) {
    String payload = http.getString();
    DeserializationError error = deserializeJson(locations, payload);

    if (error) {
      Serial.println("Failed to parse locations JSON.");
    }
  } else {
    Serial.printf("Failed to fetch locations, HTTP code: %d\n", httpCode);
  }

  http.end();
  return locations; // Return the populated JSON document
}

// Prüft, ob ein Benutzer mit der angegebenen UID existiert
// (Kompatibilitätsfunktion).
bool userExists(const String &uid) { return checkUser(uid).exists; }

// Fügt einen neuen Benutzer in die Datenbank ein
bool enterUserData(const String &uid, const String &vorname,
                   const String &nachname, const String &geburtsdatum,
                   int alter) {
  if (!backendOnline()) {
    Serial.println("No internet connection, cannot enter user data.");
    return false;
  }

  HTTPClient http;
  http.begin(String(BACKEND_SERVER) + "/v1/private/users/insert");
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", String("Bearer ") + BACKEND_TOKEN);

  // Create JSON payload
  StaticJsonDocument<512> requestDoc;
  requestDoc["uid"] = uid;
  requestDoc["firstname"] = vorname;
  requestDoc["lastname"] = nachname;
  requestDoc["geburtsdatum"] = geburtsdatum;
  requestDoc["alter"] = alter;

  String requestBody;
  serializeJson(requestDoc, requestBody);

  int httpCode = http.POST(requestBody);

  bool success = (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_CREATED);

  if (success) {
    Serial.println("User data successfully entered into database");
  } else {
    Serial.printf("Failed to enter user data, HTTP code: %d\n", httpCode);
  }

  http.end();
  return success;
}

// Richtet die HTTP-Routen für die Backend-API ein (z.B. Health-Check, User- und
// Location-Abfragen).
void setupBackendRoutes(AsyncWebServer &server) {

  server.on("/api/health", HTTP_GET, [](AsyncWebServerRequest *request) {
    DynamicJsonDocument doc(64);
    doc["status"] = backendOnline() ? "connected" : "disconnected";
    String response;
    serializeJson(doc, response);
    request->send(200, "application/json", response);
  });

  server.on("/api/users", HTTP_GET, [](AsyncWebServerRequest *request) {
    if (!backendOnline()) {
      request->send(503, "application/json",
                    "{\"error\":\"Database not connected\"}");
      return;
    }

    // Handle user retrieval logic here
  });
  // Location routes /api/location/
  server.on("/api/location/", HTTP_GET, [](AsyncWebServerRequest *request) {
    String result;
    serializeJson(getAllLocations(), result);
    request->send(200, "application/json", result);
  });

  server.on("/api/set-local-location", HTTP_POST,
            [](AsyncWebServerRequest *request) {
              Serial.println("/api/set-local-location called");
              String locationId;
              if (request->hasParam("locationId", true)) {
                locationId = request->getParam("locationId", true)->value();
              }
              if (locationId.length() > 0) {
                saveLocationIdToPrefs(locationId);
                DynamicJsonDocument doc(64);
                doc["success"] = true;
                String result;
                serializeJson(doc, result);
                request->send(200, "application/json", result);
              } else {
                request->send(400, "application/json", "{\"success\":false}");
              }
            });

  server.on("/api/get-local-location", HTTP_GET,
            [](AsyncWebServerRequest *request) {
              String locationId = getLocationIdFromPrefs();
              DynamicJsonDocument doc(64);
              doc["locationId"] = locationId;
              String result;
              serializeJson(doc, result);
              request->send(200, "application/json", result);

              // Andere Logik wie in getBestLocs
            });

  // Add more routes as needed
}