#include <Arduino.h>
#include <types.h>
#include <display_ui.h>

const char* ssid     = "Stockfeld";
const char* password = "70691554384740972413";
const char* DISCORD_WEBHOOK = "https://discord.com/api/webhooks/1552818996582285372/ChwhTOdajIwIVbdIpweSorYauwGHJTjjzWNGCjzPw1mh31-snlynh0ZW1InSar_aV8IB";

// NTP-Server & Zeitzone für Deutschland
const char* ntpServer = "pool.ntp.org";
const char* tzInfo    = "CET-1CEST,M3.5.0,M10.5.0/3";

FastAccelStepperEngine engine = FastAccelStepperEngine();
FastAccelStepper *stepper = NULL;

// ################ Variabeln ################
const uint32_t MAX_SPEED_HZ = 106000;
const int32_t COLDTEMP_C = 70;
const int32_t MIKROSTEPS = 1600;

bool clickPlus = 0;
bool clickMinus = 0;
bool clickStop = 0;
bool holdPlus = 0;
bool holdMinus = 0;
bool holdStop = 0;

bool shouldRun = true;
int lastSpeed = 0;

int32_t lastControl = 0;
uint32_t lastPlotTime = 0;

bool autoStop = false;
bool bSettings = false;
uint32_t curTemp = 0;
bool send = false;

bool stopMove = false;

struct tm timeinfo;

TimeEditStep timeEditStep = EDIT_NONE;

// fest in den Speicher schreiben
Preferences prefs;

SystemSettings settings;

//#####################################
//########### Hilfsfunktion ###########
//#####################################

// Überladung des Präfix-Operators (++timeEditStep)
TimeEditStep& operator++(TimeEditStep& step) {
  step = (step == EDIT_SPEED) ? EDIT_NONE : static_cast<TimeEditStep>(step + 1);
  return step;
}

// Werte aus dem Flash speicher laden 
void loadSettings() {
  // Namespace öffnen (Name max. 15 Zeichen, "true" = read-only)
  prefs.begin("timer_cfg", true);

  // Werte auslesen
  settings.startHour    = prefs.getUChar("s_hour", 0);
  settings.startMin     = prefs.getUChar("s_min", 0);
  settings.endHour      = prefs.getUChar("e_hour", 0);
  settings.endMin       = prefs.getUChar("e_min", 0);
  settings.timerEnabled = prefs.getBool("t_on", false);
  settings.maxTemp      = prefs.getShort("max_temp", 70);  
  settings.accelRate    = prefs.getInt("accel_rate", 20000);

  prefs.end();
  Serial.println("[NVS] Einstellungen erfolgreich geladen.");
}

// Save Settings in Flash Speichern 
void saveSettings() {
  prefs.begin("timer_cfg", false); // "false" = Read/Write

  prefs.putUChar("s_hour", settings.startHour);
  prefs.putUChar("s_min", settings.startMin);
  prefs.putUChar("e_hour", settings.endHour);
  prefs.putUChar("e_min", settings.endMin);
  prefs.putBool("t_on", settings.timerEnabled);
  prefs.putShort("max_temp", settings.maxTemp);  
  prefs.putInt("accel_rate", settings.accelRate);

  prefs.end();
  Serial.println("[NVS] Einstellungen im Flash gespeichert.");
}

void initWiFiAndTime() {
  WiFi.begin(ssid, password);
  
  // Zeitzone und NTP-Server setzen
  configTzTime(tzInfo, ntpServer);

  // Warten auf Verbindung (optional mit Timeout)
  int retries = 0;
  while (WiFi.status() != WL_CONNECTED && retries < 20) {
    delay(500);
    retries++;
  }
}

void sendDiscordNotification(const String& message) {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("[Discord] Nicht verbunden mit WiFi.");
    return;
  }

  WiFiClientSecure client;
  client.setInsecure(); // Überspringt die rechenintensive Zertifikatsketten-Prüfung

  HTTPClient http;
  if (http.begin(client, DISCORD_WEBHOOK)) {
    http.addHeader("Content-Type", "application/json");

    // JSON-Payload: {"content": "Deine Nachricht"}
    String payload = "{\"content\": \"" + message + "\"}";

    int httpResponseCode = http.POST(payload);
    if (httpResponseCode == 204 || httpResponseCode == 200) {
      Serial.println("[Discord] Nachricht erfolgreich gesendet.");
    } else {
      Serial.printf("[Discord] Fehler beim Senden: HTTP %d\n", httpResponseCode);
    }
    http.end();
  }
}

//#######################################################
//####################### Setup #########################
//#######################################################
void setup() {
  Serial.begin(115200);
  delay(1000); // Zeit für USB-CDC-Verbindung geben

  // Daten aus Flash speicher laden
  loadSettings();

  engine.init();
  stepper = engine.stepperConnectToPin(stepPinStepper);
  
  if (stepper) {
    stepper->setDirectionPin(dirPinStepper);
    stepper->setEnablePin(enablePinStepper, true);
    stepper->setAutoEnable(true);
    stepper->setSpeedInHz(MAX_SPEED_HZ);
  }

  // Pin Config
  pinMode(buttonPlus, INPUT_PULLUP);
  pinMode(buttonMinus, INPUT_PULLUP);
  pinMode(buttonStop, INPUT_PULLUP);

  initWiFiAndTime();

  initDisplay();

  // Start Animation 
}

bool getCurrentTime(int &hour, int &minute, int &second) {
  if (!getLocalTime(&timeinfo, 50)) { // 50ms Timeout
    return false; // Noch keine NTP-Zeit synchronisiert
  }
  hour   = timeinfo.tm_hour;
  minute = timeinfo.tm_min;
  second = timeinfo.tm_sec;
  return true;
}

// Rückgabe von Flanken (Klick) und Pegel (Halten)
void getInputs(bool &clickPlus, bool &clickMinus, bool &clickStop, 
               bool &holdPlus,  bool &holdMinus,  bool &holdStop) {
  
  // Physische Pegel einlesen (Active-Low)
  bool curPlus  = (digitalRead(buttonPlus) == LOW);
  bool curMinus = (digitalRead(buttonMinus) == LOW);
  bool curStop  = (digitalRead(buttonStop) == LOW);

  // Speicher für vorherigen Durchlauf
  static bool lastPlus  = false;
  static bool lastMinus = false;
  static bool lastStop  = false;

  // Nur bei Veränderung true (Sperre)
  clickPlus  = (curPlus  && !lastPlus);
  clickMinus = (curMinus && !lastMinus);
  clickStop  = (curStop  && !lastStop);

  // Dauerzustand (für Stepper-Handbetrieb)
  holdPlus  = curPlus;
  holdMinus = curMinus;
  holdStop  = curStop;

  // Zustand für nächsten Durchlauf merken
  lastPlus  = curPlus;
  lastMinus = curMinus;
  lastStop  = curStop;
}

// Liefert die Aktuelle Temperatur in °C
int getTempInC(uint8_t senTemp){
  int milliVolt = analogReadMilliVolts(senTemp);
  return ((milliVolt - 500)/10);
}

int getFilteredTemp(int rawSensorPin) {
  constexpr uint8_t FILTER_SAMPLES = 10; // Puffergröße (10 Messwerte)
  static int readings[FILTER_SAMPLES];
  static uint8_t readIndex = 0;
  static int32_t total = 0;
  static int average = 0;
  static bool initialized = false;
  static uint32_t lastSampleTime = 0;

  // Abtastrate: Alle 100 ms einen neuen Messwert erfassen
  if (millis() - lastSampleTime >= 100 || !initialized) {
    lastSampleTime = millis();

    int rawVal = getTempInC(rawSensorPin); // Messwert in mV

    // Kaltstart: Puffer beim ersten Aufruf vollflächig vorbefüllen
    if (!initialized) {
      for (uint8_t i = 0; i < FILTER_SAMPLES; i++) {
        readings[i] = rawVal;
      }
      total = (int32_t)rawVal * FILTER_SAMPLES;
      average = rawVal;
      initialized = true;
      return average;
    }

    // Ältesten Wert abziehen, neuen Wert einfügen und addieren
    total -= readings[readIndex];
    readings[readIndex] = rawVal;
    total += rawVal;

    // Index weiterschalten
    readIndex = (readIndex + 1) % FILTER_SAMPLES;

    // Ganzzahlige Division mit kaufmännischer Rundung (+ 5 bei 10 Werten)
    if (total >= 0) {
      average = (total + (FILTER_SAMPLES / 2)) / FILTER_SAMPLES;
    } else {
      average = (total - (FILTER_SAMPLES / 2)) / FILTER_SAMPLES;
    }
  }

  return average;
}

// Liefert true wenn der Timer aktuell Active ist und false wenn nicht aktiv
bool isTimerActiveNow(int curH, int curM, int startH, int startM, int endH, int endM) {
  int current = curH * 60 + curM;
  int start   = startH * 60 + startM;
  int end     = endH * 60 + endM;

  // Fall A: Zeitfenster am selben Tag (z. B. 08:00 bis 16:00)
  if (start <= end) {
    return (current >= start && current < end);
  }
  // Fall B: Zeitfenster über Mitternacht (z. B. 22:00 bis 04:00)
  else {
    return (current >= start || current < end);
  }
}

// Die Funktion behandelt das gesammte Einstellungs menu
void setting(){
  //######### Timer Edit #########
  if (timeEditStep != EDIT_NONE) {
    //PLUS GEDRÜCKT: Wert erhöhen
    if (clickPlus) {
      switch (timeEditStep) {
        case EDIT_START_HOUR:
          settings.startHour = (settings.startHour + 1) % 24;
          break;
        case EDIT_START_MIN:
          settings.startMin = (settings.startMin + 5) % 60;
          break;
        case EDIT_END_HOUR:
          settings.endHour = (settings.endHour + 1) % 24;
          break;
        case EDIT_END_MIN:
          settings.endMin = (settings.endMin + 5) % 60;
          break;
        case EDIT_SPEED:
          if(settings.autoSpeed < ((MAX_SPEED_HZ * 60)/MIKROSTEPS) - 50){
            settings.autoSpeed += 50;
          }
          break;
        default: break;
      }
    }

    // MINUS GEDRÜCKT: Wert verringern
    if (clickMinus) {
      switch (timeEditStep) {
        case EDIT_START_HOUR:
          settings.startHour = (settings.startHour == 0) ? 23 : settings.startHour - 1;
          break;
        case EDIT_START_MIN:
          settings.startMin = (settings.startMin < 5) ? 55 : settings.startMin - 5;
          break;
        case EDIT_END_HOUR:
          settings.endHour = (settings.endHour == 0) ? 23 : settings.endHour - 1;
          break;
        case EDIT_END_MIN:
          settings.endMin = (settings.endMin < 5) ? 55 : settings.endMin - 5;
          break;
        case EDIT_SPEED:
          if(settings.autoSpeed >= 50){
            settings.autoSpeed -= 50;
          }
          break;
        default: break;
      }
    }

    // STOP GEDRÜCKT: Zum nächsten Wert springen
    if (clickStop) {
      ++timeEditStep;
    }

    return; // Wichtig: Rest der Funktion überspringen, solange editiert wird!
  }

  //######### Max Temp Edit #########
if (settings.editMaxTemp) {
    // PLUS: Bis maximal 150
    if (clickPlus) {
      if (settings.maxTemp <= 145) {
        settings.maxTemp += 5;
      }
    }

    // MINUS: Bis minimal -20
    if (clickMinus) {
      if (settings.maxTemp >= -15) {
        settings.maxTemp -= 5;
      }
    }

    if (clickStop) {
      settings.coldTemp = settings.maxTemp - 20;
      settings.editMaxTemp = false;
    }
    return; // Wichtig: Rest der Funktion überspringen, solange editiert wird!
  }

  //######### Beschleunigung Edit #########
if (settings.editAcc) {
    // PLUS: Erhöhen in 1000er-Schritten bis max 20.000
    if (clickPlus) {
      if (settings.accelRate <= 19000) {
        settings.accelRate += 1000;
      }
    }

    // MINUS: Verringern in 1000er-Schritten bis min 1.000 (niemals 0!)
    if (clickMinus) {
      if (settings.accelRate >= 2000) {
        settings.accelRate -= 1000;
      }
    }

    // STOP: Speichern / Verlassen
    if (clickStop) {
      settings.editAcc = false;
      stepper->setAcceleration(settings.accelRate); // Direkt am Stepper aktualisieren
    }
    return; // Wichtig: Rest der Funktion überspringen, solange editiert wird!
  }
  

  //######### Menü #########
  // Menü bewegen
  if(clickPlus){
   if(settings.settingIdx <= 3){
      settings.settingIdx++; 
    }
  }
  if(clickMinus){
    if(settings.settingIdx >=1){
      settings.settingIdx--;
    }
  }

  // Stop zum bestätigen 
  if (clickStop) {
    if (settings.settingIdx == 0) {
      // Zeitschaltuhr-Einstellung starten
      timeEditStep = EDIT_START_HOUR;
    } 
    else if (settings.settingIdx == 1) {
      // Zeitschaltuhr ON/OFF
      settings.timerEnabled = !settings.timerEnabled;
    }else if (settings.settingIdx == 2) {
      // Temperatur Grenze einstellen
      settings.editMaxTemp = true;
    }else if (settings.settingIdx == 3) {
      // Beschleunigung
      settings.editAcc = true;
    }else if (settings.settingIdx == 4) {
      // Menü verlassen
      bSettings = false;
      // Einstellungen Speichern
      saveSettings();
    }
  }
}

void printStatus(FastAccelStepper *stepper, int speed, int clickPlus, int clickMinus){
  // Plotter-Ausgabe alle 50 ms (überflutet den Bus nicht)
  if (millis() - lastPlotTime >= 50) {
      lastPlotTime = millis();
    
    int32_t currentSpeed_HZ = stepper->getCurrentSpeedInUs() == 0 ? 0 : (1000000 / stepper->getCurrentSpeedInUs());
    int32_t currentSpeed = (currentSpeed_HZ * 60)/1600;
    // Format kompatibel für den Arduino Serial Plotter
    Serial.print("Current_Speed_U/Min:");
    Serial.print((60*currentSpeed)/3200);
    Serial.print(" Accel_Control:");
    Serial.print(speed);
    Serial.print(" Btn_Up:");
    Serial.print(clickPlus ? 5000 : 0);
    Serial.print(" Btn_Down:");
    Serial.print(clickMinus ? -5000 : 0);
    Serial.println();
  }
}

//#############################################################
//#################### MAIN ###################################
//#############################################################
void loop() {
  int32_t speed = 0;

  if (!stepper) {
    Serial.println("[HALT] Kein Stepper-Objekt aktiv.");
    delay(1000);
    return;
  }

  // 1. Eingaben & Sensoren lesen
  getInputs(clickPlus, clickMinus, clickStop, holdPlus, holdMinus, holdStop);
  curTemp = getFilteredTemp(senTemp);

  // 2. Discord Überhitzungs-Alarm
  static bool send = false;
  if (curTemp >= settings.maxTemp && !send) {
    String message = "⚠️ **Kugelmuehle ueberhitzt!** Aktuelle Temp: " + String(curTemp) + " °C";
    sendDiscordNotification(message);
    send = true;
  } else if (curTemp < settings.coldTemp) {
    send = false;
  }

  // 3. Zeitschaltuhr & NTP prüfen
  int curH, curM, curS;
  bool timeIsValid = getCurrentTime(curH, curM, curS);

  if (settings.timerEnabled && timeIsValid) {
    shouldRun = isTimerActiveNow(curH, curM, settings.startHour, settings.startMin, settings.endHour, settings.endMin);
  } else {
    shouldRun = false;
  }

  // 4. Schutz-Verriegelung (Überhitzung)
  static bool tempOverheat = false;
  if (curTemp >= settings.maxTemp) {
    tempOverheat = true;
  } else if (curTemp <= settings.coldTemp) {
    tempOverheat = false;
  }

  // 5. Menü aufrufen
  if (holdStop && clickPlus) {
    bSettings = true; 
  }

  // HotKey Timer Toggeln
  if (holdStop && clickMinus) {
    if(settings.timerEnabled){
      settings.timerEnabled = false;
    }else{
      settings.timerEnabled = true; 
    }
  }

  // Sperr-Flag, falls der Nutzer im aktiven Timer-Fenster bewusst Stopp gedrückt hat
  static bool manualTimerStopped = false;
  if (!shouldRun) {
    manualTimerStopped = false; // Reset für den nächsten regulären Zeitzyklus
  }

  // 6. Betriebsmodi steuern
  if (bSettings) {
    setting();
  } 
  // NOT-AUS BEI ÜBERHITZUNG
  else if (tempOverheat) {
    if (stepper->isRunning()) {
      stepper->setAcceleration(10000);
      stepper->applySpeedAcceleration();
      stepper->stopMove();
      lastSpeed = 0;
    }
  }
  // AUTOMATIK-BETRIEB (Zeitschaltuhr)
  else if (settings.timerEnabled) {

    // Druch drücken von plus den Timer betrieb vortsetzen
    if (manualTimerStopped && clickPlus) {
      manualTimerStopped = false;
    }

    if (shouldRun && !manualTimerStopped) {
      if (!stepper->isRunning()) {
        uint32_t autoHz = ((uint32_t)settings.autoSpeed * MIKROSTEPS) / 60;
        stepper->setSpeedInHz(autoHz);
        stepper->setAcceleration(settings.accelRate);
        stepper->runForward();
      }

      // Manuelles Anhalten im laufenden Timer erlauben
      if (clickStop) {
        manualTimerStopped = true;
        stepper->setAcceleration(10000);
        stepper->applySpeedAcceleration();
        stepper->stopMove();
        lastSpeed = 0;
      }
    } else {
      // Außerhalb des Fensters oder manuell gestoppt
      if (stepper->isRunning()) {
        stepper->setAcceleration(10000);
        stepper->applySpeedAcceleration();
        stepper->stopMove();
        lastSpeed = 0;
      }
    }
  } 
  // MANUELLER BETRIEB (Zeitschaltuhr aus)
  else {
  static bool manualStopped = false;

  if (clickStop) {
    if (stepper->isRunning()) {
      stepper->setAcceleration(10000);
      stepper->applySpeedAcceleration();   // <-- macht die neue Rampe sofort wirksam
      stepper->stopMove();
    }
    speed = 0;
    lastSpeed = 0;
    manualStopped = true;
  } else if (manualStopped) {
    if (!holdPlus && !holdMinus) {
      manualStopped = false;       // erst freigeben wenn Tasten los sind
    }
    speed = 0;                     // während Sperre: nichts tun
  } else if (holdPlus) {
    speed = settings.accelRate;
  } else if (holdMinus) {
    speed = -settings.accelRate;
  } else {
    speed = 0;
  }

  if (speed != lastSpeed) {
    stepper->setSpeedInHz(MAX_SPEED_HZ);
    stepper->setAcceleration(settings.accelRate);
    stepper->moveByAcceleration(speed, true);
    lastSpeed = speed;
  }
}

  // 7. Geschwindigkeitsberechnung & UI
  int32_t currentSpeed_HZ = (stepper->getCurrentSpeedInUs() == 0) ? 0 : (1000000 / stepper->getCurrentSpeedInUs());
  int32_t currentSpeed = (currentSpeed_HZ * 60) / MIKROSTEPS;

  updateDisplay(bSettings, settings.settingIdx, timeEditStep, settings, currentSpeed, curH, curM, timeIsValid, curTemp);
  printStatus(stepper, speed, clickPlus, clickMinus);
}