#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <lvgl.h> //Anpassung kommt weiter unten
#include <TFT_eSPI.h> // Bereits im Teil 1 angepasst
#include "ui.h"  // Binde hier die Start Datei ein, die EEZ Studio für dich generiert hat

// WLAN-Zugangsdaten (SSID = Service Set Identifier)
const char* ssid = "DEIN_WLAN_NAME";
const char* password = "DEIN_WLAN_PASSWORT";

// Koordinaten sind für Frechen/Köln eingestellt
String apiUrl = "http://api.open-meteo.com/v1/forecast?latitude=50.91&longitude=6.81&current_weather=true";

// Timer-Variablen für das 15-Minuten-Intervall
unsigned long lastTime = 0;
// 15 Minuten in Millisekunden (15 * 60 * 1000)
unsigned long timerDelay = 900000; 

// TFT-Display Setup
TFT_eSPI tft = TFT_eSPI();
#define screenWidth 480
#define screenHeight 320

// Speicherplatz (Buffer) für die Bildberechnung von LVGL reservieren
#define DRAW_BUF_SIZE (screenWidth * screenHeight / 10 * (LV_COLOR_DEPTH / 8))
uint8_t *draw_buf;

// --- LVGL HILFSFUNKTIONEN ---

// 1. Bilder auf den Bildschirm schieben
void my_disp_flush(lv_display_t *disp, const lv_area_t *area, uint8_t *px_map) {
  uint32_t w = lv_area_get_width(area);
  uint32_t h = lv_area_get_height(area);
  tft.startWrite();
  tft.setAddrWindow(area->x1, area->y1, w, h);
  tft.pushColors((uint16_t *)px_map, w * h, true);
  tft.endWrite();
  lv_display_flush_ready(disp);
}

// 2. Berührungen (Touch) erkennen (Aktuell als Platzhalter)
void my_touch_read(lv_indev_t * indev, lv_indev_data_t * data) {
  data->state = LV_INDEV_STATE_RELEASED;
}

// --- WETTER-FUNKTION ---

// Funktion für den Datenabruf per HTTP (Hypertext Transfer Protocol)
void fetchAndDisplayWeather() {
  HTTPClient http; 
  http.begin(apiUrl);
  int httpResponseCode = http.GET(); 

  if (httpResponseCode > 0) {
    String payload = http.getString();
    
    // JSON (JavaScript Object Notation - ein strukturiertes Datenformat) auslesen
    JsonDocument doc;
    DeserializationError error = deserializeJson(doc, payload);

    if (!error) {
      // Temperatur aus den Daten auslesen
      float temp = doc["current_weather"]["temperature"];
      
      // Temperatur-Zahl in einen Text umwandeln (mit einer Nachkommastelle)
      char tempString[15];
      sprintf(tempString, "%.1f °C", temp);
      
      // HIER FINDET DIE MAGIE STATT:
      // Wir übergeben den neuen Text an das Textfeld aus deinem EEZ-Design.
      // WICHTIG: Ersetze "ui_LabelTemperatur" durch den exakten Namen deines Textfeldes!
      lv_label_set_text(objects.ui_LabelTemperatur, tempString);
      
    } else {
      Serial.println("Fehler beim Verarbeiten der Wetterdaten.");
    }
  } else {
    Serial.println("Fehler beim Herunterladen der Daten.");
  }
  
  http.end(); // Verbindung sauber schließen
}

// --- HAUPTPROGRAMM ---

void setup() {
  Serial.begin(115200);

  // Hintergrundbeleuchtung einschalten
  pinMode(27, OUTPUT);
  digitalWrite(27, HIGH);

  // Display starten
  tft.begin();
  tft.setRotation(1); 

  if (draw_buf == NULL) {
  Serial.println("Hinweis: Kein PSRAM gefunden. Nutze normalen Speicher.");
  draw_buf = (uint8_t *)malloc(DRAW_BUF_SIZE);
}

  // LVGL (Grafik-Software) starten
  lv_init();
  lv_display_t * disp = lv_display_create(screenWidth, screenHeight);
  lv_display_set_flush_cb(disp, my_disp_flush);
  lv_display_set_buffers(disp, draw_buf, NULL, DRAW_BUF_SIZE, LV_DISPLAY_RENDER_MODE_PARTIAL);

  lv_indev_t * indev = lv_indev_create();
  lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
  lv_indev_set_read_cb(indev, my_touch_read);

  // Die Benutzeroberfläche (GUI - Graphical User Interface) von EEZ Studio laden
  ui_init();

  // WLAN verbinden
  Serial.print("Verbinde mit WLAN...");
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(50);
    // WICHTIG: Damit das Display nicht einfriert, während wir auf das WLAN warten,
    // müssen wir LVGL auch hier regelmäßig aktualisieren.
    lv_timer_handler(); 
    lv_tick_inc(50);
  }
  Serial.println(" Verbunden!");

  // Erster Abruf der Wetterdaten direkt nach dem Start
  fetchAndDisplayWeather();
}

void loop() {
  // LVGL Taktgeber und Aktualisierung
  lv_tick_inc(5); 
  lv_timer_handler(); 
  
  // Timer: Alle 15 Minuten das Wetter neu laden
  if ((millis() - lastTime) > timerDelay) {
    if (WiFi.status() == WL_CONNECTED) {
      fetchAndDisplayWeather();
    }
    lastTime = millis();
  }
  
  // Kurze Pause zur Entlastung des Mikrocontrollers
  delay(5); 
}

// ============================================================
//  Wetterstation CYD ESP32-3248S035R
//  UI erzeugt mit EEZ Studio (LVGL 9.5)
//  Prilchen LABS 2026
// ============================================================

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <lvgl.h>
#include <TFT_eSPI.h>
#include <esp_sleep.h>
#include "driver/rtc_io.h"

// EEZ Studio: lvgl.h ohne Unterordner einbinden
#define LV_LVGL_H_INCLUDE_SIMPLE
#include "ui.h"

// ---------------- Zugangsdaten ----------------
const char* ssid = "xxx";
const char* password = "xxx";

String apiUrl = "http://api.open-meteo.com/v1/forecast?latitude=50.91&longitude=6.81&current=temperature_2m,relative_humidity_2m,wind_speed_10m,wind_direction_10m&hourly=precipitation_probability&forecast_days=1&timezone=Europe/Berlin";

// ---------------- Display ----------------
#define TFT_HOR_RES 480
#define TFT_VER_RES 320

// ---------------- Tacho-Parameter ----------------
#define TEMP_MIN          (-20.0f)
#define TEMP_MAX          ( 50.0f)
#define NEEDLE_LENGTH     100

// ---------------- Sleep ----------------
#define TOUCH_IRQ_PIN      36
#define SCREEN_TIMEOUT_MS  60000

TFT_eSPI tft = TFT_eSPI();
static lv_color_t draw_buf[TFT_HOR_RES * 10];

unsigned long lastTime     = 0;
unsigned long timerDelay   = 900000;   // 15 min
unsigned long screenOnTime = 0;

// ============================================================
//  Hilfsfunktion: Grad -> Himmelsrichtung
// ============================================================
static const char* wind_dir_text(int deg) {
    deg = ((deg % 360) + 360) % 360;
    if (deg < 22  || deg >= 338) return "N";
    if (deg < 67)  return "NO";
    if (deg < 112) return "O";
    if (deg < 157) return "SO";
    if (deg < 202) return "S";
    if (deg < 247) return "SW";
    if (deg < 292) return "W";
    return "NW";
}

// ============================================================
//  LVGL Flush-Callback (TFT_eSPI)
// ============================================================
void my_disp_flush(lv_display_t *disp, const lv_area_t *area, uint8_t *px_map) {
    uint32_t breite = lv_area_get_width(area);
    uint32_t hoehe  = lv_area_get_height(area);
    tft.startWrite();
    tft.setAddrWindow(area->x1, area->y1, breite, hoehe);
    tft.pushColors((uint16_t *)px_map, breite * hoehe, true);
    tft.endWrite();
    lv_display_flush_ready(disp);
}

// ============================================================
//  Tacho aktualisieren (Nadel + Zahlenwert)
//  Die Widgets kommen aus der EEZ-generierten UI:
//    objects.scale_main  -> lv_scale
//    objects.scale_needle-> lv_line (Kind der Scale)
//    objects.label_temp  -> lv_label
// ============================================================
static void update_gauge(float temp) {
    if (temp < TEMP_MIN) temp = TEMP_MIN;
    if (temp > TEMP_MAX) temp = TEMP_MAX;

    lv_scale_set_line_needle_value(objects.scale_main,
                                   objects.scale_needle,
                                   NEEDLE_LENGTH,
                                   (int32_t)temp);

    lv_label_set_text_fmt(objects.label_temp, "%.1f C", temp);
}

// ============================================================
//  Deep Sleep
// ============================================================
static void goToDeepSleep() {
    Serial.println("Gehe in Deep Sleep - Touch zum Aufwachen");

    // Backlight aus
    digitalWrite(27, LOW);

    // ST7796 in Sleep-Modus
    tft.writecommand(0x10);
    delay(120);

    // RGB-LEDs aus (common anode)
    pinMode(22, INPUT);
    pinMode(16, INPUT);
    pinMode(17, INPUT);

    // Warten bis Finger weg
    pinMode(TOUCH_IRQ_PIN, INPUT);
    unsigned long t0 = millis();
    while (digitalRead(TOUCH_IRQ_PIN) == LOW && millis() - t0 < 5000) {
        delay(50);
    }
    delay(200);

    // RTC-Pull-Up für IO36 aktivieren
    rtc_gpio_pullup_en((gpio_num_t)TOUCH_IRQ_PIN);
    rtc_gpio_pulldown_dis((gpio_num_t)TOUCH_IRQ_PIN);

    // Wake bei fallender Flanke
    esp_sleep_enable_ext0_wakeup((gpio_num_t)TOUCH_IRQ_PIN, 0);

    esp_deep_sleep_start();
}

static void update_clock_from_meteo(const String& isoTime) {
    // Erwartetes Format: "2026-09-13T14:35"
    if (isoTime.length() < 16) {
        lv_label_set_text(objects.label_time, "--.--.---- --:--");
        return;
    }

    String jahr  = isoTime.substring(0, 4);   // "2026"
    String monat = isoTime.substring(5, 7);   // "09"
    String tag   = isoTime.substring(8, 10);  // "13"
    String stunde= isoTime.substring(11, 13); // "14"
    String minute= isoTime.substring(14, 16); // "35"

    lv_label_set_text_fmt(objects.label_time,
        "%s.%s.%s  %s:%s",
        tag.c_str(), monat.c_str(), jahr.c_str(),
        stunde.c_str(), minute.c_str());
}

// ============================================================
//  Setup
// ============================================================
void setup() {
    Serial.begin(115200);

    esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
    switch (cause) {
        case ESP_SLEEP_WAKEUP_EXT0:      Serial.println("Aufgewacht durch Touch"); break;
        case ESP_SLEEP_WAKEUP_TIMER:     Serial.println("Aufgewacht durch Timer"); break;
        case ESP_SLEEP_WAKEUP_UNDEFINED: Serial.println("Kaltstart / Reset");      break;
        default:                         Serial.println("Anderer Grund");
    }

    // Backlight an
    pinMode(27, OUTPUT);
    digitalWrite(27, HIGH);

    tft.begin();
    tft.setRotation(1);

    // ---------- LVGL ----------
    lv_init();
    lv_tick_set_cb(millis);

    lv_display_t *disp = lv_display_create(TFT_HOR_RES, TFT_VER_RES);
    lv_display_set_buffers(disp, draw_buf, NULL, sizeof(draw_buf),
                           LV_DISPLAY_RENDER_MODE_PARTIAL);
    lv_display_set_flush_cb(disp, my_disp_flush);

    // ---------- UI aus EEZ Studio ----------
    ui_init();

    // Status initial setzen (Screen ist jetzt aktiv)
    lv_label_set_text(objects.label_status, "WLAN...");
    lv_obj_set_style_text_color(objects.label_status,
                                lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_timer_handler();

    // ---------- WLAN ----------
    WiFi.begin(ssid, password);
    Serial.print("Verbinde mit WLAN");
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
        lv_timer_handler();
    }
    Serial.println(" verbunden");

    lv_label_set_text(objects.label_status, "online");
    lv_obj_set_style_text_color(objects.label_status,
                                lv_color_hex(0x13b594), LV_PART_MAIN);
    lv_timer_handler();

    // ---------- Erste Wetterdaten ----------
    fetchAndDisplayWeather();

    // Timeout starten
    screenOnTime = millis();
    lastTime     = millis();
}

// ============================================================
//  Loop
// ============================================================
void loop() {
    lv_timer_handler();
    delay(5);

    // Daten alle 15 min aktualisieren
    if ((millis() - lastTime) > timerDelay) {
        if (WiFi.status() == WL_CONNECTED) {
            fetchAndDisplayWeather();
        }
        lastTime = millis();
    }

    // Nach SCREEN_TIMEOUT_MS in Deep Sleep
    if (screenOnTime > 0 && (millis() - screenOnTime) > SCREEN_TIMEOUT_MS) {
        goToDeepSleep();
    }
}

// ------------------------------------------------------------
//  Wetterdaten von Open-Meteo holen und anzeigen
//  Rückgabe: true = Erfolg, false = alle Versuche gescheitert
// ------------------------------------------------------------
bool fetchAndDisplayWeather() {
    for (int versuch = 1; versuch <= 3; versuch++) {
        HTTPClient http;
        http.setTimeout(5000);
        http.begin(apiUrl);
        int code = http.GET();

        if (code == 200) {
            String payload = http.getString();
            JsonDocument doc;
            DeserializationError error = deserializeJson(doc, payload);

            if (!error) {
                float temp    = doc["current"]["temperature_2m"];
                int   hum     = doc["current"]["relative_humidity_2m"];
                float wind    = doc["current"]["wind_speed_10m"];
                int   winddir = doc["current"]["wind_direction_10m"];

                // ----- Uhrzeit / Datum -----
                String nowStr = doc["current"]["time"].as<String>();
                update_clock_from_meteo(nowStr);

                // ----- Regenrisiko (aktuelle Stunde) -----
                int rain = 0;
                if (nowStr.length() >= 13) {
                    int hour = nowStr.substring(11, 13).toInt();
                    if (hour >= 0 && hour < 24) {
                        rain = doc["hourly"]["precipitation_probability"][hour];
                    }
                }

                // ----- Tacho -----
                update_gauge(temp);

                // ----- Textzeilen -----
                lv_label_set_text_fmt(objects.label_hum,
                                      "Luftfeuchtigkeit: %d%%", hum);
                lv_label_set_text_fmt(objects.label_wind,
                                      "Wind: %.0f km/h %s",
                                      wind, wind_dir_text(winddir));
                lv_label_set_text_fmt(objects.label_rain,
                                      "Regenrisiko: %d%%", rain);

                Serial.printf("OK: T=%.1f H=%d%% Wind=%.0f %s Regen=%d%% Zeit=%s\n",
                              temp, hum, wind, wind_dir_text(winddir),
                              rain, nowStr.c_str());
                http.end();
                return true;
            } else {
                Serial.print("JSON-Fehler: ");
                Serial.println(error.c_str());
            }
        } else {
            Serial.printf("HTTP-Code %d (Versuch %d/3)\n", code, versuch);
        }
        http.end();
        delay(800); // kurz warten, dann erneut versuchen
    }

    // Alle Versuche gescheitert – dem Nutzer zeigen
    lv_label_set_text(objects.label_status, "API-Fehler");
    lv_obj_set_style_text_color(objects.label_status,
                                lv_color_hex(0x13B594), LV_PART_MAIN);
    return false;
}