CuriousHolidaysModule.cpp

#include "CuriousHolidaysModule.hpp"
#include "webconfig.hpp"
#include "FragmentationMonitor.hpp"
#include "MultiLogger.hpp"
#include <algorithm>
#include <cctype>
#include <LittleFS.h>

// Deutsche Monatsnamen
static const char* GERMAN_MONTH_NAMES[] = {
    "Januar", "Februar", "März", "April", "Mai", "Juni", 
    "Juli", "August", "September", "Oktober", "November", "Dezember"
};

// Hilfsfunktionen
static PsramString trim(const PsramString& str) {
    size_t start = str.find_first_not_of(" \t\n\r\f\v");
    if (start == PsramString::npos) return "";
    size_t end = str.find_last_not_of(" \t\n\r\f\v");
    return str.substr(start, end - start + 1);
}

// HTML-Entity-Decoder für die wichtigsten Zeichen
static PsramString decodeHtmlEntities(const PsramString& input) {
    PsramString output = "";
    output.reserve(input.length());
    
    for (size_t i = 0; i < input.length(); ++i) {
        if (input[i] == '&') {
            // Suche nach dem Ende der Entity
            size_t endPos = input.find(';', i);
            if (endPos != PsramString::npos && endPos - i < 10) {
                PsramString entity = input.substr(i, endPos - i + 1);
                
                // Numerische Entities (&#XXXX;)
                if (entity.length() > 3 && entity[1] == '#') {
                    int code = 0;
                    if (entity[2] == 'x' || entity[2] == 'X') {
                        // Hexadezimal
                        code = strtol(entity.c_str() + 3, nullptr, 16);
                    } else {
                        // Dezimal
                        code = atoi(entity.c_str() + 2);
                    }
                    
                    // UTF-8 Umwandlung für wichtige Zeichen
                    if (code == 8211 || code == 8212) {
                        output += '-'; // En-dash oder Em-dash
                    } else if (code == 8216 || code == 8217) {
                        output += '\''; // Linke/rechte einfache Anführungszeichen
                    } else if (code == 8220 || code == 8221) {
                        output += '"'; // Linke/rechte doppelte Anführungszeichen
                    } else if (code == 228) {
                        output += "\xC3\xA4"; // ä
                    } else if (code == 196) {
                        output += "\xC3\x84"; // Ä
                    } else if (code == 246) {
                        output += "\xC3\xB6"; // ö
                    } else if (code == 214) {
                        output += "\xC3\x96"; // Ö
                    } else if (code == 252) {
                        output += "\xC3\xBC"; // ü
                    } else if (code == 220) {
                        output += "\xC3\x9C"; // Ü
                    } else if (code == 223) {
                        output += "\xC3\x9F"; // ß
                    } else if (code == 233) {
                        output += "\xC3\xA9"; // é
                    } else if (code == 232) {
                        output += "\xC3\xA8"; // è
                    } else if (code == 234) {
                        output += "\xC3\xAA"; // ê
                    } else if (code == 224) {
                        output += "\xC3\xA0"; // à
                    } else if (code == 226) {
                        output += "\xC3\xA2"; // â
                    } else if (code == 39) {
                        output += '\''; // Apostroph
                    } else if (code == 96) {
                        output += '`'; // Backtick/Gravis
                    } else if (code == 180) {
                        output += '\''; // ´ (Akut/Apostrophe) → Apostroph
                    } else if (code == 34) {
                        output += '"'; // Anführungszeichen
                    } else if (code >= 32 && code < 127) {
                        output += (char)code; // ASCII
                    } else {
                        output += ' '; // Unbekanntes Zeichen
                    }
                    i = endPos;
                    continue;
                }
                
                // Benannte Entities
                if (entity == "&uuml;") {
                    output += "\xC3\xBC"; // ü
                } else if (entity == "&Uuml;") {
                    output += "\xC3\x9C"; // Ü
                } else if (entity == "&auml;") {
                    output += "\xC3\xA4"; // ä
                } else if (entity == "&Auml;") {
                    output += "\xC3\x84"; // Ä
                } else if (entity == "&ouml;") {
                    output += "\xC3\xB6"; // ö
                } else if (entity == "&Ouml;") {
                    output += "\xC3\x96"; // Ö
                } else if (entity == "&szlig;") {
                    output += "\xC3\x9F"; // ß
                } else if (entity == "&eacute;") {
                    output += "\xC3\xA9"; // é
                } else if (entity == "&egrave;") {
                    output += "\xC3\xA8"; // è
                } else if (entity == "&ecirc;") {
                    output += "\xC3\xAA"; // ê
                } else if (entity == "&agrave;") {
                    output += "\xC3\xA0"; // à
                } else if (entity == "&acirc;") {
                    output += "\xC3\xA2"; // â
                } else if (entity == "&ndash;") {
                    output += '-'; // En-dash
                } else if (entity == "&mdash;") {
                    output += '-'; // Em-dash
                } else if (entity == "&lsquo;") {
                    output += '\''; // Linke einfache Anführungszeichen
                } else if (entity == "&rsquo;") {
                    output += '\''; // Rechte einfache Anführungszeichen
                } else if (entity == "&ldquo;") {
                    output += '"'; // Linke doppelte Anführungszeichen
                } else if (entity == "&rdquo;") {
                    output += '"'; // Rechte doppelte Anführungszeichen
                } else if (entity == "&amp;") {
                    output += '&';
                } else if (entity == "&lt;") {
                    output += '<';
                } else if (entity == "&gt;") {
                    output += '>';
                } else if (entity == "&quot;") {
                    output += '"';
                } else if (entity == "&apos;") {
                    output += '\'';
                } else if (entity == "&nbsp;") {
                    output += ' ';
                } else {
                    output += entity; // Unbekannte Entity beibehalten
                }
                i = endPos;
                continue;
            }
        }
        output += input[i];
    }
    return output;
}

// Bereinigungs-Funktion, die nur erlaubte Zeichen durchlässt
static PsramString sanitizeString(const PsramString& input) {
    PsramString output = "";
    output.reserve(input.length());
    for (size_t i = 0; i < input.length(); ++i) {
        unsigned char c1 = input[i];
        
        // KORREKTUR: Der Punkt wird jetzt explizit erlaubt.
        bool isAllowed = (c1 >= 'a' && c1 <= 'z') ||
                         (c1 >= 'A' && c1 <= 'Z') ||
                         (c1 >= '0' && c1 <= '9') ||
                         c1 == ' ' || c1 == '-' || c1 == '.' ||
                         c1 == '\'' || c1 == '`';  // Apostroph und Backtick

        if (isAllowed) {
            output += c1;
        } else if (c1 == 0xC3) { // UTF-8 Startbyte für Umlaute/ß
            if (i + 1 < input.length()) {
                unsigned char c2 = input[i+1];
                if (c2 == 0xA4 || c2 == 0xB6 || c2 == 0xBC || // ä, ö, ü
                    c2 == 0x84 || c2 == 0x96 || c2 == 0x9C || // Ä, Ö, Ü
                    c2 == 0x9F) { // ß
                    output += c1;
                    output += c2;
                    i++; // Zwei Bytes verarbeitet
                } else {
                    output += ' '; // Unerlaubtes UTF-8 Zeichen
                }
            }
        } else if (c1 == 0xC2) { // UTF-8 Startbyte für U+0080..U+00BF (z.B. ´ = U+00B4)
            if (i + 1 < input.length()) {
                unsigned char c2 = input[i+1];
                if (c2 == 0xB4) { // ´ (U+00B4) → als Apostroph ausgeben
                    output += '\'';
                    i++; // Zwei Bytes verarbeitet
                } else {
                    output += ' '; // Unerlaubtes UTF-8 Zeichen
                }
            } else {
                output += ' '; // Unvollständige UTF-8 Sequenz
            }
        } else {
            output += ' '; // Alle anderen unerlaubten Zeichen
        }
    }
    return output;
}


static uint16_t rgb565(uint8_t r, uint8_t g, uint8_t b) { 
    return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3); 
}

// Writes a JSON-escaped string directly to a File, one byte at a time (no heap alloc)
static void writeJsonString(File& f, const PsramString& s) {
    for (size_t i = 0; i < s.length(); ++i) {
        unsigned char c = (unsigned char)s[i];
        if      (c == '"')  f.print("\\\"");
        else if (c == '\\') f.print("\\\\");
        else if (c == '\n') f.print("\\n");
        else if (c == '\r') f.print("\\r");
        else if (c == '\t') f.print("\\t");
        else                f.write(c);
    }
}

// Returns the display lines joined by the literal string "#13", replicating the
// word-wrap logic of drawAndCountLines so the JSON reflects actual on-screen breaks.
static const char* const DISPLAY_LINE_SEP = "#13";

static PsramString getDisplayLines(U8G2_FOR_ADAFRUIT_GFX& u8g2, PsramString text, int maxWidth, bool capitalizeFirst) {
    if (text.empty()) return "";
    text = trim(text);
    if (capitalizeFirst && !text.empty())
        text[0] = std::toupper(static_cast<unsigned char>(text[0]));
    if (text.empty()) return "";

    PsramString result, currentLine;
    int breakPos = -1, pos = 0;

    while (pos < (int)text.length()) {
        int spacePos  = text.find(' ', pos);
        int hyphenPos = text.find('-', pos);
        bool brokeAtHyphen = false;

        if (spacePos == (int)PsramString::npos && hyphenPos == (int)PsramString::npos) {
            breakPos = text.length();
        } else if (spacePos == (int)PsramString::npos) {
            breakPos = hyphenPos + 1; brokeAtHyphen = true;
        } else if (hyphenPos == (int)PsramString::npos) {
            breakPos = spacePos;
        } else {
            if (spacePos < hyphenPos) { breakPos = spacePos; }
            else { breakPos = hyphenPos + 1; brokeAtHyphen = true; }
        }

        PsramString word = text.substr(pos, breakPos - pos);
        PsramString potentialLine = currentLine.empty() ? word
            : (currentLine.back() == '-' ? currentLine + word : currentLine + " " + word);

        if (u8g2.getUTF8Width(potentialLine.c_str()) <= maxWidth) {
            currentLine = potentialLine;
        } else {
            if (!currentLine.empty()) {
                if (!result.empty()) result += DISPLAY_LINE_SEP;
                result += currentLine;
            }
            currentLine = word;
            if (u8g2.getUTF8Width(currentLine.c_str()) > maxWidth) {
                if (!result.empty()) result += DISPLAY_LINE_SEP;
                result += currentLine;
                currentLine = "";
            }
        }
        pos = brokeAtHyphen ? breakPos : breakPos + 1;
    }

    if (!currentLine.empty()) {
        if (!result.empty()) result += DISPLAY_LINE_SEP;
        result += currentLine;
    }
    return result;
}

static int drawAndCountLines(U8G2_FOR_ADAFRUIT_GFX& u8g2, PsramString text, int x, int& y, int maxWidth, int lineHeight, bool doDraw, bool capitalizeFirst) {
    if (text.empty()) return 0;

    text = trim(text);
    if (capitalizeFirst && !text.empty()) {
        text[0] = std::toupper(static_cast<unsigned char>(text[0]));
    }

    int lines = 0;
    if (text.length() == 0) return 0;
    
    PsramString currentLine;
    int breakPos = -1;
    int pos = 0;

    while(pos < text.length()){
        // Find next space or hyphen, whichever comes first
        int spacePos = text.find(' ', pos);
        int hyphenPos = text.find('-', pos);
        
        bool brokeAtHyphen = false;
        if(spacePos == PsramString::npos && hyphenPos == PsramString::npos){
            breakPos = text.length();
        } else if(spacePos == PsramString::npos){
            breakPos = hyphenPos + 1; // Include hyphen in the word
            brokeAtHyphen = true;
        } else if(hyphenPos == PsramString::npos){
            breakPos = spacePos;
        } else {
            if(spacePos < hyphenPos) {
                breakPos = spacePos;
            } else {
                breakPos = hyphenPos + 1;
                brokeAtHyphen = true;
            }
        }

        PsramString word = text.substr(pos, breakPos - pos);
        PsramString potentialLine;
        if (currentLine.empty()) {
            potentialLine = word;
        } else {
            // Don't add space if current line ends with hyphen
            if (currentLine.back() == '-') {
                potentialLine = currentLine + word;
            } else {
                potentialLine = currentLine + " " + word;
            }
        }

        if (u8g2.getUTF8Width(potentialLine.c_str()) <= maxWidth) {
            currentLine = potentialLine;
        } else {
            if (!currentLine.empty()) {
                if(doDraw) {
                    u8g2.setCursor(x, y);
                    u8g2.print(currentLine.c_str());
                    y += lineHeight;
                }
                lines++;
            }
            currentLine = word;
            if (u8g2.getUTF8Width(currentLine.c_str()) > maxWidth) {
                 if(doDraw) {
                    u8g2.setCursor(x, y);
                    u8g2.print(currentLine.c_str());
                    y += lineHeight;
                }
                lines++;
                currentLine = "";
            }
        }
        // If we broke at hyphen, hyphen is already included, so don't skip next char
        // If we broke at space, skip the space
        pos = brokeAtHyphen ? breakPos : breakPos + 1;
    }

    if(!currentLine.empty()){
        if(doDraw) {
            u8g2.setCursor(x, y);
            u8g2.print(currentLine.c_str());
            y += lineHeight;
        }
        lines++;
    }
    
    return lines;
}

CuriousHolidaysModule::CuriousHolidaysModule(U8G2_FOR_ADAFRUIT_GFX& u8g2, GFXcanvas16& canvas, GeneralTimeConverter& timeConverter, WebClientModule* webClient, DeviceConfig* config)
    : u8g2(u8g2), canvas(canvas), timeConverter(timeConverter), webClient(webClient), config(config), lastProcessedUpdate(0), _lastCheckedDay(-1) {
    dataMutex = xSemaphoreCreateMutex();
}

CuriousHolidaysModule::~CuriousHolidaysModule() {
    if (dataMutex) vSemaphoreDelete(dataMutex);
    if (pendingBuffer) free(pendingBuffer);
}

void CuriousHolidaysModule::begin() {
    time_t now = time(nullptr);
    time_t local_time = timeConverter.toLocal(now);
    struct tm tm_now;
    localtime_r(&local_time, &tm_now);
    _lastCheckedDay = tm_now.tm_mday;
    lastMonth = tm_now.tm_mon + 1;
    setConfig();
}

void CuriousHolidaysModule::setConfig() {
    time_t now = time(nullptr);
    time_t local_time = timeConverter.toLocal(now);
    struct tm tm_now;
    localtime_r(&local_time, &tm_now);
    
    const char* monthNames[] = {"januar", "februar", "maerz", "april", "mai", "juni", "juli", "august", "september", "oktober", "november", "dezember"};
    PsramString monthName = monthNames[tm_now.tm_mon];

    resourceUrl = "https://www.kuriose-feiertage.de/kalender/" + monthName + "/";

    if (webClient) {
        webClient->registerResource(String(resourceUrl.c_str()), 720, nullptr);
    }
}

void CuriousHolidaysModule::queueData() {
    LOG_MEM_OP("CuriousHolidaysModule::queueData");
    if (resourceUrl.empty() || !webClient) return;

    time_t now = time(nullptr);
    time_t local_time = timeConverter.toLocal(now);
    struct tm tm_now;
    localtime_r(&local_time, &tm_now);
    int currentDay = tm_now.tm_mday;

    if (currentDay != _lastCheckedDay) {
        handleDayChange();
    }
    
    if (tm_now.tm_mon + 1 != lastMonth) {
        lastMonth = tm_now.tm_mon + 1;
        setConfig(); 
    }

    webClient->accessResource(String(resourceUrl.c_str()), [this](const char* buffer, size_t size, time_t last_update, bool is_stale) {
        if (buffer && size > 0 && last_update > this->lastProcessedUpdate) {
            if (pendingBuffer) free(pendingBuffer);
            pendingBuffer = (char*)ps_malloc(size + 1);
            if (pendingBuffer) {
                memcpy(pendingBuffer, buffer, size);
                pendingBuffer[size] = '\0';
                bufferSize = size;
                lastProcessedUpdate = last_update;
                dataPending = true;
            }
        }
    });
}

void CuriousHolidaysModule::handleDayChange() {
    if (xSemaphoreTake(dataMutex, portMAX_DELAY) == pdTRUE) {
        time_t now = time(nullptr);
        time_t local_time = timeConverter.toLocal(now);
        struct tm tm_now;
        localtime_r(&local_time, &tm_now);
        
        _lastCheckedDay = tm_now.tm_mday;
        
        holidaysToday = holidaysTomorrow;
        holidaysTomorrow.clear();
        
        xSemaphoreGive(dataMutex);
        
        calculatePages();
        if (updateCallback) updateCallback();
    }
}

void CuriousHolidaysModule::processData() {
    LOG_MEM_OP("CuriousHolidaysModule::processData");
    if (dataPending) {
        parseAndProcessHtml(pendingBuffer, bufferSize);
        free(pendingBuffer);
        pendingBuffer = nullptr;
        dataPending = false;
        if (updateCallback) this->updateCallback();
    }
}

void CuriousHolidaysModule::parseAndProcessHtml(const char* buffer, size_t size) {
    PsramVector<HolidayEntry> today, tomorrow;
    // Parallel vectors holding the pre-sanitize text (used for the monthly JSON debug file)
    PsramVector<PsramString> todayRawNames,    todayRawDescs;
    PsramVector<PsramString> tomorrowRawNames, tomorrowRawDescs;
    PsramString html(buffer, size);

    time_t now = time(nullptr);
    time_t local_now = timeConverter.toLocal(now);
    struct tm tm_today;
    localtime_r(&local_now, &tm_today);
    
    time_t tomorrow_epoch = local_now + 86400;
    struct tm tm_tomorrow;
    localtime_r(&tomorrow_epoch, &tm_tomorrow);

    PsramString todayMonthName = GERMAN_MONTH_NAMES[tm_today.tm_mon];
    PsramString tomorrowMonthName = GERMAN_MONTH_NAMES[tm_tomorrow.tm_mon];

    int h2Pos = 0;
    while ((h2Pos = indexOf(html, "<h2>", h2Pos)) != -1) {
        int h2End = indexOf(html, "</h2>", h2Pos);
        if (h2End == -1) break;

        PsramString dateFromH2 = trim(html.substr(h2Pos + 4, h2End - (h2Pos + 4)));
        if (!dateFromH2.empty() && dateFromH2.back() == ':') dateFromH2.pop_back();

        int day = atoi(dateFromH2.c_str());
        PsramString monthStr;
        int dotPos = indexOf(dateFromH2, ".");
        if(dotPos != -1) monthStr = trim(dateFromH2.substr(dotPos + 1));
        
        bool isToday = (day == tm_today.tm_mday && monthStr.find(todayMonthName.c_str()) != PsramString::npos);
        if (!isToday && tm_today.tm_mon == 2) {
             isToday = (day == tm_today.tm_mday && monthStr.find("Maerz") != PsramString::npos);
        }
        bool isTomorrow = (day == tm_tomorrow.tm_mday && monthStr.find(tomorrowMonthName.c_str()) != PsramString::npos);
        if (!isTomorrow && tm_tomorrow.tm_mon == 2) {
             isTomorrow = (day == tm_tomorrow.tm_mday && monthStr.find("Maerz") != PsramString::npos);
        }

        if (!isToday && !isTomorrow) {
            h2Pos = h2End; continue;
        }

        int ulStart = indexOf(html, "<ul class=\"lcp_catlist\"", h2End);
        if (ulStart == -1) continue;
        int ulEnd = indexOf(html, "</ul>", ulStart);
        if (ulEnd == -1) continue;
        PsramString ulContent = html.substr(ulStart, ulEnd - ulStart);

        int liPos = 0;
        while ((liPos = indexOf(ulContent, "<li>", liPos)) != -1) {
            int liEnd = indexOf(ulContent, "</li>", liPos);
            if (liEnd == -1) break;

            PsramString liContent = ulContent.substr(liPos, liEnd - liPos);
            int aStart = indexOf(liContent, "<a ");
            if (aStart == -1) { liPos = liEnd + 5; continue; }
            int aEnd = indexOf(liContent, "</a>", aStart);
            if (aEnd == -1) { liPos = liEnd + 5; continue; }

            PsramString aText = liContent.substr(aStart, aEnd - aStart);
            int textStart = indexOf(aText, ">") + 1;
            if (textStart == 0) { liPos = liEnd + 5; continue; }

            PsramString rawFullText = aText.substr(textStart);
            
            // HTML-Entities dekodieren
            rawFullText = decodeHtmlEntities(rawFullText);
            
            HolidayEntry entry;
            PsramString rawName, rawDescription;

            int dashPos = indexOf(rawFullText, "–");
            if (dashPos == -1) dashPos = indexOf(rawFullText, "-"); // Nach normalen Bindestrich suchen

            if (dashPos != -1) {
                rawName = rawFullText.substr(0, dashPos);
                int descStart = rawFullText.find_first_not_of(" –-", dashPos);
                if(descStart != -1) rawDescription = rawFullText.substr(descStart);

            } else {
                rawName = rawFullText;
            }

            entry.name = trim(sanitizeString(rawName));
            entry.description = trim(sanitizeString(rawDescription));

            char date_str[30];
            snprintf(date_str, sizeof(date_str), "am %d. %s", (isToday ? tm_today.tm_mday : tm_tomorrow.tm_mday), (isToday ? todayMonthName.c_str() : tomorrowMonthName.c_str()));
            size_t date_pos = entry.description.find(date_str);
            if(date_pos != PsramString::npos) {
                entry.description.erase(date_pos, strlen(date_str));
            }
             if(tm_today.tm_mon == 2 || tm_tomorrow.tm_mon == 2){ //März/Maerz
                 snprintf(date_str, sizeof(date_str), " am %d. Maerz", (isToday ? tm_today.tm_mday : tm_tomorrow.tm_mday));
                 date_pos = entry.description.find(date_str);
                 if(date_pos != PsramString::npos) {
                    entry.description.erase(date_pos, strlen(date_str));
                 }
            }
            entry.description = trim(entry.description);


            if (!entry.name.empty()) {
                if (isToday) {
                    today.push_back(entry);
                    todayRawNames.push_back(trim(rawName));
                    todayRawDescs.push_back(trim(rawDescription));
                }
                if (isTomorrow) {
                    tomorrow.push_back(entry);
                    tomorrowRawNames.push_back(trim(rawName));
                    tomorrowRawDescs.push_back(trim(rawDescription));
                }
            }
            liPos = liEnd + 5;
        }
        h2Pos = ulEnd;
    }

    if (xSemaphoreTake(dataMutex, portMAX_DELAY) == pdTRUE) {
        holidaysToday = today;
        holidaysTomorrow = tomorrow;
        xSemaphoreGive(dataMutex);
    }

    // --- Debug: save raw HTML + parsed JSON once per calendar month ---
    {
        char rawFilename[48], jsonFilename[48];
        snprintf(rawFilename,  sizeof(rawFilename),  "/curiousholidays_%04d_%02d.html",
                 tm_today.tm_year + 1900, tm_today.tm_mon + 1);
        snprintf(jsonFilename, sizeof(jsonFilename), "/curiousholidays_%04d_%02d.json",
                 tm_today.tm_year + 1900, tm_today.tm_mon + 1);

        // Raw HTML — only if not written yet for this month
        if (!LittleFS.exists(rawFilename)) {
            File f = LittleFS.open(rawFilename, "w");
            if (f) {
                f.write((const uint8_t*)buffer, size);
                f.close();
                Log.printf("[CuriousHolidays] Raw HTML saved: %s\n", rawFilename);
            } else {
                Log.printf("[CuriousHolidays] WARN: could not write %s\n", rawFilename);
            }
        }

        // Parsed JSON — only if not written yet for this month
        if (!LittleFS.exists(jsonFilename)) {
            File f = LittleFS.open(jsonFilename, "w");
            if (f) {
                const int maxWidth = canvas.width() - 10;
                u8g2.setFont(u8g2_font_6x10_tf);

                char buf[80];
                f.print("{\n");
                f.print("  \"url\": \""); writeJsonString(f, resourceUrl); f.print("\",\n");
                snprintf(buf, sizeof(buf), "  \"date_today\": \"%d. %s\",\n",
                         tm_today.tm_mday,    GERMAN_MONTH_NAMES[tm_today.tm_mon]);
                f.print(buf);
                snprintf(buf, sizeof(buf), "  \"date_tomorrow\": \"%d. %s\",\n",
                         tm_tomorrow.tm_mday, GERMAN_MONTH_NAMES[tm_tomorrow.tm_mon]);
                f.print(buf);

                // Helper lambda: write one entries array to the open file
                auto writeDay = [&](const PsramVector<HolidayEntry>& entries,
                                    const PsramVector<PsramString>& rawNames,
                                    const PsramVector<PsramString>& rawDescs,
                                    const char* key, bool addComma) {
                    f.print("  \""); f.print(key); f.print("\": [\n");
                    for (size_t i = 0; i < entries.size(); ++i) {
                        f.print("    {\n");

                        f.print("      \"name_raw\": \"");
                        if (i < rawNames.size()) writeJsonString(f, rawNames[i]);
                        f.print("\",\n");

                        f.print("      \"description_raw\": \"");
                        if (i < rawDescs.size()) writeJsonString(f, rawDescs[i]);
                        f.print("\",\n");

                        PsramString nd = getDisplayLines(u8g2, entries[i].name,        maxWidth, false);
                        PsramString dd = getDisplayLines(u8g2, entries[i].description, maxWidth, true);

                        f.print("      \"name_display\": \"");        writeJsonString(f, nd); f.print("\",\n");
                        f.print("      \"description_display\": \""); writeJsonString(f, dd); f.print("\"\n");

                        f.print("    }");
                        if (i + 1 < entries.size()) f.print(",");
                        f.print("\n");
                    }
                    f.print("  ]");
                    if (addComma) f.print(",");
                    f.print("\n");
                };

                writeDay(today,    todayRawNames,    todayRawDescs,    "today",    true);
                writeDay(tomorrow, tomorrowRawNames, tomorrowRawDescs, "tomorrow", false);
                f.print("}\n");
                f.close();
                Log.printf("[CuriousHolidays] Parsed JSON saved: %s\n", jsonFilename);
            } else {
                Log.printf("[CuriousHolidays] WARN: could not write %s\n", jsonFilename);
            }
        }
    }
    // --- End debug file saving ---

    calculatePages();
}

void CuriousHolidaysModule::calculatePages() {
    if (xSemaphoreTake(dataMutex, portMAX_DELAY) != pdTRUE) return;

    pageIndices.clear();
    if (holidaysToday.empty()) {
        xSemaphoreGive(dataMutex);
        return;
    }

    const int maxWidth = canvas.width() - 10;
    const int lineHeight = 12;
    const int entrySpacing = 8;
    const int topMargin = 25;
    const int availableHeight = canvas.height() - topMargin - 5;
    int dummy_y = 0;

    u8g2.setFont(u8g2_font_6x10_tf);

    int holidayIndex = 0;
    while (holidayIndex < holidaysToday.size()) {
        PsramVector<int> page;
        int currentHeight = 0;
        
        while (holidayIndex < holidaysToday.size()) {
            const HolidayEntry& entry = holidaysToday[holidayIndex];
            
            int nameLines = drawAndCountLines(u8g2, entry.name, 0, dummy_y, maxWidth, lineHeight, false, false);
            int descLines = drawAndCountLines(u8g2, entry.description, 0, dummy_y, maxWidth, lineHeight, false, false);
            int entryHeight = (nameLines + descLines) * lineHeight + entrySpacing;

            if (currentHeight + entryHeight > availableHeight && !page.empty()) break; 
            
            page.push_back(holidayIndex);
            currentHeight += entryHeight;
            holidayIndex++;
        }
        
        if (!page.empty()) pageIndices.push_back(page);
        else if (holidayIndex < holidaysToday.size()) {
            page.push_back(holidayIndex);
            pageIndices.push_back(page);
            holidayIndex++;
        }
    }

    resetPaging(); 
    xSemaphoreGive(dataMutex);
}

void CuriousHolidaysModule::draw() {
    if (xSemaphoreTake(dataMutex, pdMS_TO_TICKS(100)) != pdTRUE) return;

    canvas.fillScreen(0);
    u8g2.begin(canvas);

    if (pageIndices.empty() || holidaysToday.empty()) {
        u8g2.setFont(u8g2_font_7x14_tf);
        u8g2.setForegroundColor(0xFFFF);
        const char* text = "Keine Feiertage heute";
        u8g2.setCursor((canvas.width() - u8g2.getUTF8Width(text)) / 2, 30);
        u8g2.print(text);
        xSemaphoreGive(dataMutex);
        return;
    }

    time_t now = time(nullptr);
    time_t local_time = timeConverter.toLocal(now);
    struct tm tm_now;
    localtime_r(&local_time, &tm_now);

    char dateStr[32];
    snprintf(dateStr, sizeof(dateStr), "%d. %s", tm_now.tm_mday, GERMAN_MONTH_NAMES[tm_now.tm_mon]);

    u8g2.setFont(u8g2_font_helvB14_tf);
    u8g2.setForegroundColor(rgb565(255, 255, 0));
    int dateWidth = u8g2.getUTF8Width(dateStr);
    u8g2.setCursor((canvas.width() - dateWidth) / 2, 15);
    u8g2.print(dateStr);

    const auto& currentPageIndices = pageIndices[currentPage];
    int y = 25;
    int maxWidth = canvas.width() - 10;
    const int lineHeight = 12;
    const int entrySpacing = 8;

    u8g2.setFont(u8g2_font_6x10_tf);

    for (size_t i = 0; i < currentPageIndices.size(); ++i) {
        int idx = currentPageIndices[i];
        if (idx >= holidaysToday.size()) continue; 
        const HolidayEntry& entry = holidaysToday[idx];

        u8g2.setForegroundColor(0xFFFF);
        drawAndCountLines(u8g2, entry.name, 5, y, maxWidth, lineHeight, true, false);
        
        u8g2.setForegroundColor(rgb565(0, 255, 255));
        drawAndCountLines(u8g2, entry.description, 5, y, maxWidth, lineHeight, true, true);

        y += (entrySpacing / 2);

        if (i < currentPageIndices.size() - 1) {
            uint16_t lineColor = rgb565(128, 128, 128);
            for (int hx = 5; hx < canvas.width() - 5; hx += 2) {
                canvas.drawPixel(hx, y, lineColor);
            }
            y += (entrySpacing / 2);
        }
    }

    xSemaphoreGive(dataMutex);
}

void CuriousHolidaysModule::resetPaging() {
    currentPage = 0;
    _logicTicksSincePageSwitch = 0;
    _isFinished = false;
}

bool CuriousHolidaysModule::isEnabled() {
    if (!config || !config->curiousHolidaysEnabled) {
        return false;
    }
    bool enabled = false;
    if (xSemaphoreTake(dataMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
        enabled = !holidaysToday.empty();
        xSemaphoreGive(dataMutex);
    }
    return enabled;
}

void CuriousHolidaysModule::onActivate() {
    _logicTicksSincePageSwitch = 0;
    if (config) {
        pageDisplayDuration = config->curiousHolidaysDisplaySec * 1000;
    }
    _currentTicksPerPage = pageDisplayDuration / 100;
    if (_currentTicksPerPage == 0) _currentTicksPerPage = 1;
}

void CuriousHolidaysModule::logicTick() {
    _logicTicksSincePageSwitch++;
    
    if (_logicTicksSincePageSwitch >= _currentTicksPerPage) {
        int totalPages = getTotalPages();
        if (totalPages > 0) {
            currentPage = (currentPage + 1) % totalPages;
            if (currentPage == 0) {
                _isFinished = true;
            } else {
                if (updateCallback) updateCallback();
            }
        }
        _logicTicksSincePageSwitch = 0;
    }
}

void CuriousHolidaysModule::onUpdate(std::function<void()> callback) {
    updateCallback = callback;
}