#include "heltec.h"
#include <WiFi.h>

#define DISPLAY_WIDTH 128
#define DISPLAY_HEIGHT 64
#define IMPULSE_DURATION 1000 // Dauer des Impulses in Millisekunden (1000ms)
#define IMPULSE_OUTPUT 2      // GPIO-Pin für den Impuls
#define POTI_PIN 1            // GPIO-Pin für das Poti
#define MEASUREMENT_DELAY 500 // Verzögerung für die Messung von min und max RSSI in Millisekunden
#define RESET_DELAY 500       // Verzögerung für das Zurücksetzen der minimalen und maximalen RSSI-Werte

const char* ssid = "Mugen MBX8";
const char* password = "12345678";

int rssiValues[DISPLAY_WIDTH] = {0}; // Array für RSSI-Werte
int currentIndex = 0;                // Aktuelle Position im Array
int potiValue = 0;                   // Aktueller Wert des Potis
int thresholdY = DISPLAY_HEIGHT / 2; // Initialer Schwellenwert (Mitte des Displays)
bool impulseTriggered = false;       // Variable, um Impuls-Auslösung anzuzeigen
int minRSSI = -100;                 // Setze den anfänglichen minimalen Wert auf das Minimum
int maxRSSI = -20;                  // Setze den anfänglichen maximalen Wert auf das Maximum
unsigned long measurementStartTime;  // Zeitstempel für den Beginn der Messung
unsigned long resetTime;            // Zeitstempel für das Zurücksetzen der min und max RSSI-Werte
bool wifiConnected = false;         // Flag, um den WLAN-Verbindungszustand zu speichern
int prevRSSI = 0;                   // Vorheriger RSSI-Wert
unsigned long lastImpulseTime = 0;  // Zeitstempel für den letzten Impuls
unsigned long impulseTime = 0;      // Zeit zwischen den Impulsen

void setup() {
  Heltec.begin(true /* DisplayEnable Enable */, false /* LoRa Disable */, true /* Serial Enable */);

  // Verzögerte Verbindung zum WLAN
  //delay(5000); // Warten Sie 5 Sekunden
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(10);
  }
  wifiConnected = true;

  pinMode(IMPULSE_OUTPUT, OUTPUT); // Setze GPIO 2 als Ausgang für den Impuls
  analogReadResolution(12);       // Auflösung für den Analogwert des Potis

  Heltec.display->init();
  Heltec.display->flipScreenVertically();
  Heltec.display->clear();
  Heltec.display->display();

  measurementStartTime = millis(); // Speichere den Startzeitpunkt für die Messung
  resetTime = millis() + RESET_DELAY; // Zeitpunkt für das Zurücksetzen der min und max RSSI-Werte
}

void loop() {
  // Messung der minimalen und maximalen RSSI-Werte nach 5 Sekunden
  if (millis() - measurementStartTime >= MEASUREMENT_DELAY) {
    int rssi = WiFi.RSSI();
    minRSSI = min(minRSSI, rssi);
    maxRSSI = max(maxRSSI, rssi);
  }

  // Überprüfung und Zurücksetzen der min und max RSSI-Werte
  if (wifiConnected and millis() >= resetTime) {
    minRSSI = -20;
    maxRSSI = -100;
    wifiConnected = false;
  }

  // Abfrage des aktuellen RSSI-Werts und Hinzufügen zum Array
  int rssi = WiFi.RSSI();
  rssiValues[currentIndex] = rssi;
  currentIndex = (currentIndex + 1) % DISPLAY_WIDTH;

  // Lese den aktuellen Wert des Potis
  potiValue = analogRead(POTI_PIN);

  // Berechne den angepassten Schwellenwert basierend auf dem Poti-Wert
  int adjustedThreshold = map(potiValue, 0, 4095, -100, -20);

  // Lösche den Bildschirm
  Heltec.display->clear();

  // Zeichne die RSSI-Linie
  int x = 0;
  int y_prev = DISPLAY_HEIGHT - map(rssiValues[currentIndex], -100, -20, 0, DISPLAY_HEIGHT);
  for (int i = currentIndex; i != (currentIndex - 1 + DISPLAY_WIDTH) % DISPLAY_WIDTH; i = (i + 1) % DISPLAY_WIDTH) {
    int y = DISPLAY_HEIGHT - map(rssiValues[i], -100, -20, 0, DISPLAY_HEIGHT);
    Heltec.display->drawLine(x, y_prev, x + 1, y);
    x++;
    y_prev = y;
  }

  // Zeichne die horizontale Linie für den Schwellenwert
  Heltec.display->drawLine(0, DISPLAY_HEIGHT - map(adjustedThreshold, -100, -20, 0, DISPLAY_HEIGHT), DISPLAY_WIDTH, DISPLAY_HEIGHT - map(adjustedThreshold, -100, -20, 0, DISPLAY_HEIGHT));

  // Zeichne die Y-Achsen-Markierungen
  for (int y = 0; y <= DISPLAY_HEIGHT; y += 10) {
    Heltec.display->drawLine(0, y, 3, y);
  }

  // Zeichne den aktuellen RSSI-Wert oben links
  Heltec.display->drawString(5, 5, "SW " + String(adjustedThreshold) + "");

  // Zeichne den aktuellen RSSI-Wert unten links
  Heltec.display->drawString(5, DISPLAY_HEIGHT - 20, "RSSI: " + String(rssi) + "");

  // Zeichne den minimalen und maximalen RSSI-Wert unterhalb des Schwellenwerts
  Heltec.display->drawString(5, DISPLAY_HEIGHT - 10, "Min: " + String(minRSSI) + "");
  Heltec.display->drawString(DISPLAY_WIDTH - 75, DISPLAY_HEIGHT - 10, "Max: " + String(maxRSSI) + "");

  // Überprüfe, ob der RSSI-Wert den Schwellenwert erreicht hat (fallende Flanke)
  if (rssi < adjustedThreshold and prevRSSI >= adjustedThreshold) {
    // Schalte den Impuls-Ausgang ein
    digitalWrite(IMPULSE_OUTPUT, HIGH);
    impulseTriggered = true;
    delay(IMPULSE_DURATION); // Halten Sie das Signal für 1000 ms (1 Sekunde) aktiv.
    digitalWrite(IMPULSE_OUTPUT, LOW); // Setzen Sie das Signal nach 1000 ms zurück.

    // Berechne die Zeit zwischen den Impulsen
    unsigned long currentTime = millis();
    impulseTime = currentTime - lastImpulseTime;
    lastImpulseTime = currentTime;
  }

  prevRSSI = rssi; // Speichere den aktuellen RSSI-Wert für den nächsten Durchlauf

  // Zeichne die Impuls-Auslösung (X) unten rechts
  if (impulseTriggered) {
    Heltec.display->drawString(DISPLAY_WIDTH - 20, DISPLAY_HEIGHT - 10, "X");
    impulseTriggered = false; // Zurücksetzen der Impuls-Auslösungsvariable.
  }

  // Zeichne die Zeit zwischen den Impulsen oben rechts im Format "t:sec.ms"
  unsigned long seconds = impulseTime / 1000; // Sekunden
  unsigned long hundredths = (impulseTime % 1000) / 10; // Hundertstel-Sekunden

  String timeStr = "t:" + String(seconds);
  if (hundredths < 10) timeStr += "0";
  timeStr += "," + String(hundredths);

  int textWidth = Heltec.display->getStringWidth(timeStr);
  Heltec.display->drawString(DISPLAY_WIDTH - textWidth - 5, 5, timeStr);

  // Zeichne die Achse
  Heltec.display->drawLine(0, 0, 0, DISPLAY_HEIGHT);

  Heltec.display->display();
  delay(20); // Aktualisierungsrate des Diagramms
}