ThemeParkModule.cpp

#include "ThemeParkModule.hpp"
#include "MultiLogger.hpp"
#include "WebClientModule.hpp"
#include "webconfig.hpp"
#include "FragmentationMonitor.hpp"
#include <ArduinoJson.h>
#include <algorithm>
#include <LittleFS.h>
#include <strings.h>  // For strcasecmp

// Allocator for PSRAM
struct SpiRamAllocator : ArduinoJson::Allocator {
    void* allocate(size_t size) override { return ps_malloc(size); }
    void deallocate(void* pointer) override { free(pointer); }
    void* reallocate(void* ptr, size_t new_size) override { return ps_realloc(ptr, new_size); }
};

ThemeParkModule::ThemeParkModule(U8G2_FOR_ADAFRUIT_GFX& u8g2, GFXcanvas16& canvas, WebClientModule* webClient)
    : _u8g2(u8g2), _canvas(canvas), _webClient(webClient), _config(nullptr),
      _currentPage(0), _currentParkIndex(0), _currentAttractionPage(0), _totalPages(1), 
      _logicTicksSincePageSwitch(0), _pageDisplayDuration(15000), _lastUpdate(0), 
      _lastParksListUpdate(0), _lastParkDetailsUpdate(0) {
    _dataMutex = xSemaphoreCreateMutex();
    
    // PixelScroller für Parknamen und Attraktionen erstellen
    _parkNameScroller = new (ps_malloc(sizeof(PixelScroller))) PixelScroller(u8g2, 50);
    _attractionScroller = new (ps_malloc(sizeof(PixelScroller))) PixelScroller(u8g2, 50);
    
    // Default-Konfiguration
    PixelScrollerConfig scrollConfig;
    scrollConfig.mode = ScrollMode::CONTINUOUS;
    scrollConfig.pauseBetweenCyclesMs = 0;
    scrollConfig.scrollReverse = false;
    scrollConfig.paddingPixels = 20;
    _parkNameScroller->setConfig(scrollConfig);
    _attractionScroller->setConfig(scrollConfig);
}

ThemeParkModule::~ThemeParkModule() {
    if (_dataMutex) vSemaphoreDelete(_dataMutex);
    if (_parkNameScroller) {
        _parkNameScroller->~PixelScroller();
        free(_parkNameScroller);
    }
    if (_attractionScroller) {
        _attractionScroller->~PixelScroller();
        free(_attractionScroller);
    }
}

void ThemeParkModule::begin() {
    loadParkCache();
    
    // If cache is empty, trigger immediate fetch of parks list
    if (_availableParks.empty()) {
        Log.println("[ThemePark] Cache is empty, will fetch parks list on first queueData call");
        _lastParksListUpdate = 0;  // Ensure checkAndUpdateParksList will load cache or fetch
    }
    
    Log.println("[ThemePark] Module initialized");
}

void ThemeParkModule::setConfig(const DeviceConfig* config) {
    _config = config;
    _pageDisplayDuration = (_config && _config->themeParkDisplaySec > 0) 
        ? _config->themeParkDisplaySec * 1000UL : 15000;
    
    if (!_webClient || !_config) return;
    
    // Parse park IDs from config
    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
        _parkIds.clear();
        if (!_config->themeParkIds.empty()) {
            PsramString parkIds = _config->themeParkIds;
            size_t pos = 0;
            while (pos < parkIds.length()) {
                size_t commaPos = parkIds.find(',', pos);
                if (commaPos == PsramString::npos) commaPos = parkIds.length();
                
                PsramString parkId = parkIds.substr(pos, commaPos - pos);
                // Trim whitespace
                while (!parkId.empty() && (parkId[0] == ' ' || parkId[0] == '\t')) {
                    parkId = parkId.substr(1);
                }
                while (!parkId.empty() && (parkId[parkId.length()-1] == ' ' || parkId[parkId.length()-1] == '\t')) {
                    parkId = parkId.substr(0, parkId.length()-1);
                }
                
                if (!parkId.empty()) {
                    _parkIds.push_back(parkId);
                }
                
                pos = commaPos + 1;
            }
        }
        xSemaphoreGive(_dataMutex);
    }
    
    // Register resources for each configured park
    // Each park needs wait times data from the /waitingtimes endpoint
    unsigned long updateIntervalMinutes = (_config && _config->themeParkFetchIntervalMin > 0) 
        ? _config->themeParkFetchIntervalMin : 10;
    
    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
        for (const auto& parkId : _parkIds) {
            // Wait times endpoint uses header-based park selection
            PsramString waitTimesUrl = "https://api.wartezeiten.app/v1/waitingtimes";
            PsramString waitTimesHeaders = "accept: application/json\npark: " + parkId + "\nlanguage: de";
            
            // Register the wait times resource with custom headers
            _webClient->registerResourceWithHeaders(String(waitTimesUrl.c_str()), 
                                                    String(waitTimesHeaders.c_str()), 
                                                    updateIntervalMinutes, 
                                                    nullptr);
            
            // Register opening times resource (updated less frequently - every 6 hours)
            PsramString openingTimesUrl = "https://api.wartezeiten.app/v1/openingtimes";
            PsramString openingTimesHeaders = "accept: application/json\npark: " + parkId;
            _webClient->registerResourceWithHeaders(String(openingTimesUrl.c_str()),
                                                    String(openingTimesHeaders.c_str()),
                                                    360,  // 6 hours
                                                    nullptr);
            
            // Register crowd level resource (updated every 30 minutes)
            PsramString crowdLevelUrl = "https://api.wartezeiten.app/v1/crowdlevel";
            PsramString crowdLevelHeaders = "accept: application/json\npark: " + parkId + "\nlanguage: de";
            _webClient->registerResourceWithHeaders(String(crowdLevelUrl.c_str()),
                                                    String(crowdLevelHeaders.c_str()),
                                                    30,  // 30 minutes
                                                    nullptr);
            
            Log.printf("[ThemePark] Registered resources for park %s\n", parkId.c_str());
        }
        xSemaphoreGive(_dataMutex);
    }
    
    // PixelScroller Konfiguration aktualisieren
    if (_config && _parkNameScroller && _attractionScroller) {
        _parkNameScroller->setConfiguredScrollSpeed(_config->globalScrollSpeedMs);
        _attractionScroller->setConfiguredScrollSpeed(_config->globalScrollSpeedMs);
        
        PixelScrollerConfig scrollConfig;
        scrollConfig.mode = (_config->scrollMode == 1) ? ScrollMode::PINGPONG : ScrollMode::CONTINUOUS;
        scrollConfig.pauseBetweenCyclesMs = (uint32_t)_config->scrollPauseSec * 1000;
        scrollConfig.scrollReverse = (_config->scrollReverse == 1);
        scrollConfig.paddingPixels = 20;
        
        _parkNameScroller->setConfig(scrollConfig);
        _attractionScroller->setConfig(scrollConfig);
    }
}

void ThemeParkModule::queueData() {
    LOG_MEM_OP("ThemeParkModule::queueData");
    if (!_webClient || !_config) return;
    
    // Check if parks list needs daily update
    checkAndUpdateParksList();
    
    // Fetch wait times for each configured park
    // Create a copy of park IDs to avoid holding the mutex during network operations
    PsramVector<PsramString> parkIdsCopy;
    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
        parkIdsCopy = _parkIds;
        xSemaphoreGive(_dataMutex);
    }
    
    for (const auto& parkId : parkIdsCopy) {
        // Fetch wait times from /waitingtimes endpoint
        PsramString waitTimesUrl = "https://api.wartezeiten.app/v1/waitingtimes";
        PsramString waitTimesHeaders = "accept: application/json\npark: " + parkId + "\nlanguage: de";
        
        // Access the resource - this will use cached data if still fresh,
        // or trigger a new fetch if the update interval has passed
        _webClient->accessResource(String(waitTimesUrl.c_str()), String(waitTimesHeaders.c_str()),
            [this, parkId](const char* buffer, size_t size, time_t last_update, bool is_stale) {
                if (buffer && size > 0) {
                    // Only process if this is new data (not already processed)
                    bool shouldProcess = false;
                    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
                        // Find existing entry in vector
                        time_t* existingTime = nullptr;
                        for (auto& entry : _lastProcessedWaitTimes) {
                            if (entry.parkId == parkId) {
                                existingTime = &entry.timestamp;
                                break;
                            }
                        }
                        if (!existingTime || *existingTime < last_update) {
                            shouldProcess = true;
                            if (existingTime) {
                                *existingTime = last_update;
                            } else {
                                _lastProcessedWaitTimes.push_back(ProcessedTimeEntry(parkId, last_update));
                            }
                        }
                        xSemaphoreGive(_dataMutex);
                    }
                    
                    if (shouldProcess) {
                        // Take mutex before parsing to ensure thread safety
                        if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
                            parseWaitTimes(buffer, size, parkId);
                            xSemaphoreGive(_dataMutex);
                            
                            // Trigger a redraw if callback is set
                            if (_updateCallback) {
                                _updateCallback();
                            }
                        }
                    }
                }
            });
        
        // Fetch opening times
        PsramString openingTimesUrl = "https://api.wartezeiten.app/v1/openingtimes";
        PsramString openingTimesHeaders = "accept: application/json\npark: " + parkId;
        
        _webClient->accessResource(String(openingTimesUrl.c_str()), String(openingTimesHeaders.c_str()),
            [this, parkId](const char* buffer, size_t size, time_t last_update, bool is_stale) {
                if (buffer && size > 0) {
                    // Only process if this is new data (not already processed)
                    bool shouldProcess = false;
                    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
                        // Find existing entry in vector
                        time_t* existingTime = nullptr;
                        for (auto& entry : _lastProcessedOpeningTimes) {
                            if (entry.parkId == parkId) {
                                existingTime = &entry.timestamp;
                                break;
                            }
                        }
                        if (!existingTime || *existingTime < last_update) {
                            shouldProcess = true;
                            if (existingTime) {
                                *existingTime = last_update;
                            } else {
                                _lastProcessedOpeningTimes.push_back(ProcessedTimeEntry(parkId, last_update));
                            }
                        }
                        xSemaphoreGive(_dataMutex);
                    }
                    
                    if (shouldProcess) {
                        if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
                            parseOpeningTimes(buffer, size, parkId);
                            xSemaphoreGive(_dataMutex);
                            
                            // Trigger a redraw if callback is set
                            if (_updateCallback) {
                                _updateCallback();
                            }
                        }
                    }
                }
            });
        
        // Fetch crowd level
        PsramString crowdLevelUrl = "https://api.wartezeiten.app/v1/crowdlevel";
        PsramString crowdLevelHeaders = "accept: application/json\npark: " + parkId + "\nlanguage: de";
        
        _webClient->accessResource(String(crowdLevelUrl.c_str()), String(crowdLevelHeaders.c_str()),
            [this, parkId](const char* buffer, size_t size, time_t last_update, bool is_stale) {
                if (buffer && size > 0) {
                    // Only process if this is new data (not already processed)
                    bool shouldProcess = false;
                    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
                        // Find existing entry in vector
                        time_t* existingTime = nullptr;
                        for (auto& entry : _lastProcessedCrowdLevel) {
                            if (entry.parkId == parkId) {
                                existingTime = &entry.timestamp;
                                break;
                            }
                        }
                        if (!existingTime || *existingTime < last_update) {
                            shouldProcess = true;
                            if (existingTime) {
                                *existingTime = last_update;
                            } else {
                                _lastProcessedCrowdLevel.push_back(ProcessedTimeEntry(parkId, last_update));
                            }
                        }
                        xSemaphoreGive(_dataMutex);
                    }
                    
                    if (shouldProcess) {
                        if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
                            parseCrowdLevel(buffer, size, parkId);
                            xSemaphoreGive(_dataMutex);
                            
                            // Trigger a redraw if callback is set
                            if (_updateCallback) {
                                _updateCallback();
                            }
                        }
                    }
                }
            });
    }
}

void ThemeParkModule::processData() {
    LOG_MEM_OP("ThemeParkModule::processData");
    // Data processing is now handled directly in queueData() callback
    // This keeps it simple like the Calendar module pattern
}

void ThemeParkModule::parseAvailableParks(const char* jsonBuffer, size_t size) {
    SpiRamAllocator allocator;
    JsonDocument doc(&allocator);
    
    DeserializationError error = deserializeJson(doc, jsonBuffer, size);
    if (error) {
        Log.printf("[ThemePark] Failed to parse parks list: %s\n", error.c_str());
        return;
    }
    
    _availableParks.clear();
    
    JsonArray parks = doc.as<JsonArray>();
    for (JsonObject park : parks) {
        const char* id = park["id"] | "";
        const char* name = park["name"] | "";
        const char* country = park["land"] | "";  // API uses "land" not "country"
        
        if (id && name && strlen(id) > 0 && strlen(name) > 0) {
            _availableParks.push_back(AvailablePark(id, name, country));
        }
    }
    
    // Save park cache to LittleFS for later use
    saveParkCache();
    
    // Update timestamp when parks list is manually refreshed (e.g., via web button)
    // This ensures the daily auto-update timer is reset
    _lastParksListUpdate = time(nullptr);
    
    Log.printf("[ThemePark] Loaded %d available parks\n", _availableParks.size());
}

void ThemeParkModule::parseWaitTimes(const char* jsonBuffer, size_t size, const PsramString& parkId) {
    Log.printf("[ThemePark] parseWaitTimes called for park: %s\n", parkId.c_str());
    
    SpiRamAllocator allocator;
    JsonDocument doc(&allocator);
    
    DeserializationError error = deserializeJson(doc, jsonBuffer, size);
    if (error) {
        Log.printf("[ThemePark] Failed to parse wait times: %s\n", error.c_str());
        return;
    }
    
    // The API returns an array of attractions, not park metadata
    // We need to get the park name and country from our cache
    Log.printf("[ThemePark] About to lookup name for: %s\n", parkId.c_str());
    PsramString parkName = getParkNameFromCache(parkId);
    if (parkName.empty()) {
        parkName = parkId;  // Fallback to ID if name not found
        Log.printf("[ThemePark] Using parkId as fallback name: %s\n", parkId.c_str());
    }
    
    Log.printf("[ThemePark] About to lookup country for: %s\n", parkId.c_str());
    PsramString parkCountry = getParkCountryFromCache(parkId);
    
    // Find or create park data
    ThemeParkData* parkData = nullptr;
    for (auto& park : _parkData) {
        if (park.id == parkId) {
            parkData = &park;
            break;
        }
    }
    
    if (!parkData) {
        _parkData.push_back(ThemeParkData());
        parkData = &_parkData[_parkData.size() - 1];
    }
    
    parkData->id = parkId;
    parkData->name = parkName;
    parkData->country = parkCountry;
    parkData->attractions.clear();
    parkData->lastUpdate = time(nullptr);
    
    // Note: The API response doesn't include crowdLevel, isOpen, openingTime, closingTime
    // These fields will remain at their default values (0/false/empty)
    // If needed, these could be fetched from a different API endpoint
    
    // Parse attractions array
    JsonArray attractions = doc.as<JsonArray>();
    int openAttractionsCount = 0;
    if (attractions) {
        for (JsonObject attr : attractions) {
            const char* name = attr["name"] | "";
            int waitTime = attr["waitingtime"] | 0;  // Note: field is "waitingtime" not "waitTime"
            const char* status = attr["status"] | "unknown";
            
            if (name && strlen(name) > 0) {
                Attraction attraction;
                attraction.name = name;
                attraction.waitTime = waitTime;
                // Check attraction status (case-insensitive)
                // Mark as open if status is explicitly "open" or "opened"
                // This is more conservative and avoids marking maintenance/refurbishment as open
                attraction.isOpen = (strcasecmp(status, "opened") == 0 || 
                                    strcasecmp(status, "open") == 0 ||
                                    strcasecmp(status, "operating") == 0);
                parkData->attractions.push_back(attraction);
                
                if (attraction.isOpen) {
                    openAttractionsCount++;
                }
            }
        }
    }
    
    // Check if park should be considered closed:
    // Park is closed if all attractions are closed
    bool allAttractionsClosed = (parkData->attractions.size() > 0 && openAttractionsCount == 0);
    
    // Don't remove parks here - opening times might not be fetched yet due to async callbacks
    // The display logic will handle whether to show closed parks based on opening hours
    if (allAttractionsClosed) {
        Log.printf("[ThemePark] Park %s is closed (all attractions closed)\n", parkName.c_str());
    }
    
    // Sort attractions:
    // 1. Open attractions first, then closed attractions
    // 2. Within each group: Sort by wait time (descending), then by name (ascending, case-insensitive)
    std::sort(parkData->attractions.begin(), parkData->attractions.end(),
              [](const Attraction& a, const Attraction& b) {
                  // Criterion 1: Open status (open first, closed last)
                  if (a.isOpen != b.isOpen) {
                      return a.isOpen > b.isOpen;  // true > false, so open comes first
                  }
                  
                  // Criterion 2: Wait time (higher first)
                  if (a.waitTime != b.waitTime) {
                      return a.waitTime > b.waitTime;
                  }
                  
                  // Criterion 3: Name (alphabetical, case-insensitive)
                  PsramString aLower = a.name;
                  PsramString bLower = b.name;
                  std::transform(aLower.begin(), aLower.end(), aLower.begin(), ::tolower);
                  std::transform(bLower.begin(), bLower.end(), bLower.begin(), ::tolower);
                  return aLower < bLower;
              });
    
    // Calculate how many pages needed to show all attractions
    // 6 attractions per page as requested
    // For open parks: show ALL attractions (both open and closed)
    // For closed parks: show 1 page with opening times
    int attractionsPerPage = 6;
    parkData->attractionPages = (parkData->attractions.size() + attractionsPerPage - 1) / attractionsPerPage;
    if (parkData->attractionPages < 1) parkData->attractionPages = 1;
    
    // Calculate total pages across all parks using the helper method
    // This properly accounts for closed parks (1 page) vs open parks (all attractions)
    _totalPages = calculateTotalPages();
    
    Log.printf("[ThemePark] Updated park %s with %d attractions (%d open), %d pages, total pages: %d\n", 
               parkName.c_str(), parkData->attractions.size(), openAttractionsCount, parkData->attractionPages, _totalPages);
}

void ThemeParkModule::parseCrowdLevel(const char* jsonBuffer, size_t size, const PsramString& parkId) {
    SpiRamAllocator allocator;
    JsonDocument doc(&allocator);
    
    DeserializationError error = deserializeJson(doc, jsonBuffer, size);
    if (error) {
        Log.printf("[ThemePark] Failed to parse crowd level: %s\n", error.c_str());
        return;
    }
    
    // Extract crowd level from JSON
    float crowdLevel = doc["crowd_level"] | 0.0f;
    
    // Find the park data and update crowd level
    for (auto& park : _parkData) {
        if (park.id == parkId) {
            park.crowdLevel = crowdLevel;
            Log.printf("[ThemePark] Updated crowd level for %s: %.2f%%\n", parkId.c_str(), crowdLevel);
            break;
        }
    }
}

void ThemeParkModule::parseOpeningTimes(const char* jsonBuffer, size_t size, const PsramString& parkId) {
    SpiRamAllocator allocator;
    JsonDocument doc(&allocator);
    
    DeserializationError error = deserializeJson(doc, jsonBuffer, size);
    if (error) {
        Log.printf("[ThemePark] Failed to parse opening times: %s\n", error.c_str());
        return;
    }
    
    // API returns array like: [{"opened_today":true,"open_from":"2025-11-14T09:00:00+01:00","closed_from":"2025-11-14T18:00:00+01:00"}]
    JsonArray timesArray = doc.as<JsonArray>();
    if (!timesArray || timesArray.size() == 0) {
        Log.printf("[ThemePark] No opening times data for park %s\n", parkId.c_str());
        return;
    }
    
    JsonObject today = timesArray[0];
    bool openedToday = today["opened_today"] | false;
    const char* openFrom = today["open_from"] | "";
    const char* closedFrom = today["closed_from"] | "";
    
    // Find the park data and update opening times
    for (auto& park : _parkData) {
        if (park.id == parkId) {
            park.isOpen = openedToday;
            
            // Extract just the time portion (HH:MM) from ISO 8601 timestamp
            // Format is "2025-11-14T09:00:00+01:00", we want "09:00"
            if (openFrom && strlen(openFrom) >= 16) {
                PsramString openStr(openFrom);
                size_t tPos = openStr.find('T');
                if (tPos != PsramString::npos && tPos + 6 <= openStr.length()) {
                    park.openingTime = openStr.substr(tPos + 1, 5);  // Extract "09:00"
                }
            }
            
            if (closedFrom && strlen(closedFrom) >= 16) {
                PsramString closedStr(closedFrom);
                size_t tPos = closedStr.find('T');
                if (tPos != PsramString::npos && tPos + 6 <= closedStr.length()) {
                    park.closingTime = closedStr.substr(tPos + 1, 5);  // Extract "18:00"
                }
            }
            
            Log.printf("[ThemePark] Updated opening times for %s: %s - %s (open: %s)\n", 
                      parkId.c_str(), park.openingTime.c_str(), park.closingTime.c_str(), 
                      park.isOpen ? "yes" : "no");
            break;
        }
    }
}

void ThemeParkModule::onUpdate(std::function<void()> callback) {
    _updateCallback = callback;
}

bool ThemeParkModule::isEnabled() {
    return _config && _config->themeParkEnabled;
}

unsigned long ThemeParkModule::getDisplayDuration() {
    unsigned long duration;
    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
        // Use the helper method to calculate total pages
        // This properly accounts for closed parks (1 page) vs open parks (attraction pages)
        int totalPages = calculateTotalPages();
        duration = (totalPages * _pageDisplayDuration) + runtime_safe_buffer;
        xSemaphoreGive(_dataMutex);
    } else {
        duration = _pageDisplayDuration;
    }
    return duration;
}

void ThemeParkModule::resetPaging() {
    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
        _currentPage = 0;
        _currentParkIndex = 0;
        _currentAttractionPage = 0;
        _logicTicksSincePageSwitch = 0;
        _isFinished = false;
        // Reset PixelScroller
        if (_parkNameScroller) _parkNameScroller->reset();
        if (_attractionScroller) _attractionScroller->reset();
        xSemaphoreGive(_dataMutex);
    }
}

void ThemeParkModule::configure(const ModuleConfig& config) {
    _modConfig = config;
}

void ThemeParkModule::onActivate() {
    if (_modConfig.resetOnActivate) {
        _currentPage = 0;
    }
    _logicTicksSincePageSwitch = 0;
}

bool ThemeParkModule::shouldDisplayPark(const ThemeParkData& park) const {
    // A park is OPEN if at least ONE attraction is open
    // A park is CLOSED if ALL attractions are closed
    
    // Display open parks (at least one attraction open)
    if (parkHasOpenAttractions(park)) {
        return true;
    }
    
    // Display closed parks ONLY if they have opening time information
    // Skip closed parks without opening times entirely
    return !park.openingTime.empty() || !park.closingTime.empty();
}

bool ThemeParkModule::parkHasOpenAttractions(const ThemeParkData& park) const {
    for (const auto& attr : park.attractions) {
        if (attr.isOpen) {
            return true;
        }
    }
    return false;
}

int ThemeParkModule::calculateTotalPages() const {
    // NOTE: This function expects _dataMutex to already be held by the caller
    // 
    // Page calculation logic:
    // - OPEN park (at least one attraction open): Show all attractions (6 per page)
    // - CLOSED park with opening times: Show 1 page with "Geschlossen" message and opening hours
    // - CLOSED park without opening times: Skip entirely (not counted)
    int totalPages = 0;
    for (const auto& park : _parkData) {
        if (shouldDisplayPark(park)) {
            if (parkHasOpenAttractions(park)) {
                // OPEN park: use attractionPages (all attractions, 6 per page)
                totalPages += park.attractionPages;
            } else {
                // CLOSED park with opening times: count as 1 page
                totalPages += 1;
            }
        }
    }
    
    if (totalPages == 0) totalPages = 1;
    return totalPages;
}

void ThemeParkModule::tick() {
    // PixelScroller tick für pixelweises Scrolling
    bool scrolled = false;
    
    if (_parkNameScroller) {
        if (_parkNameScroller->tick()) {
            scrolled = true;
        }
    }
    if (_attractionScroller) {
        if (_attractionScroller->tick()) {
            scrolled = true;
        }
    }
    
    if (scrolled && _updateCallback) {
        _updateCallback();
    }
}

void ThemeParkModule::logicTick() {
    _logicTicksSincePageSwitch++;
    
    uint32_t ticksPerPage = (_pageDisplayDuration / 100);
    
    if (_logicTicksSincePageSwitch >= ticksPerPage) {
        if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
            // Filter displayable parks
            PsramVector<int> displayableIndices;
            for (size_t i = 0; i < _parkData.size(); i++) {
                if (shouldDisplayPark(_parkData[i])) {
                    displayableIndices.push_back(i);
                }
            }
            
            // Sort displayable parks:
            // 1. OPEN parks first (at least one attraction open)
            // 2. Then CLOSED parks (with opening times)
            // 3. Alphabetically by name within each group (case-insensitive)
            std::sort(displayableIndices.begin(), displayableIndices.end(),
                      [this](int idxA, int idxB) {
                          const auto& parkA = _parkData[idxA];
                          const auto& parkB = _parkData[idxB];
                          
                          // Criterion 1: Open parks first
                          bool aHasOpen = parkHasOpenAttractions(parkA);
                          bool bHasOpen = parkHasOpenAttractions(parkB);
                          if (aHasOpen != bHasOpen) {
                              return aHasOpen > bHasOpen;
                          }
                          
                          // Criterion 2: Alphabetically by name (case-insensitive)
                          PsramString aLower = parkA.name;
                          PsramString bLower = parkB.name;
                          std::transform(aLower.begin(), aLower.end(), aLower.begin(), ::tolower);
                          std::transform(bLower.begin(), bLower.end(), bLower.begin(), ::tolower);
                          return aLower < bLower;
                      });
            
            if (displayableIndices.empty()) {
                _currentPage = 0;
                _currentParkIndex = 0;
                _currentAttractionPage = 0;
                _totalPages = 1;
                _isFinished = true;
                xSemaphoreGive(_dataMutex);
                _logicTicksSincePageSwitch = 0;
                return;
            }
            
            // Compute pages per park for the sorted displayable list
            PsramVector<int> pagesPerPark;
            int computedTotalPages = 0;
            for (int idx : displayableIndices) {
                const auto& park = _parkData[idx];
                int pages = parkHasOpenAttractions(park) ? park.attractionPages : 1;
                if (pages < 1) pages = 1;
                pagesPerPark.push_back(pages);
                computedTotalPages += pages;
            }
            if (computedTotalPages < 1) computedTotalPages = 1;
            _totalPages = computedTotalPages;
            
            // Bounds check current park index
            if (_currentParkIndex < 0 || _currentParkIndex >= (int)displayableIndices.size()) {
                _currentParkIndex = 0;
                _currentAttractionPage = 0;
            }
            
            // Move to next attraction page within current park
            _currentAttractionPage++;
            // NUR Attraktions-Scroller zurücksetzen, NICHT den Parknamen-Scroller
            // Der Parkname soll kontinuierlich weiterscrollen
            if (_attractionScroller) _attractionScroller->reset();
            
            // Determine pages for current park (with bounds check)
            int pagesForThisPark = (_currentParkIndex >= 0 && _currentParkIndex < (int)pagesPerPark.size()) 
                                   ? pagesPerPark[_currentParkIndex] : 1;
            
            // If we've shown all pages for current park, move to next park
            if (_currentAttractionPage >= pagesForThisPark) {
                _currentAttractionPage = 0;
                _currentParkIndex++;
                // Bei Park-Wechsel: Parkname-Scroller zurücksetzen (neuer Park = neuer Name)
                if (_parkNameScroller) _parkNameScroller->reset();
                
                // If we've shown all displayable parks, we're done
                if (_currentParkIndex >= (int)displayableIndices.size()) {
                    _currentParkIndex = 0;
                    _currentAttractionPage = 0;
                    _isFinished = true;
                    Log.printf("[ThemePark] All %d displayable parks shown -> Module finished\n", (int)displayableIndices.size());
                }
            }
            
            // Compute _currentPage as cumulative pages before current park + current attraction page
            int cumulativePages = 0;
            for (int i = 0; i < _currentParkIndex && i < (int)pagesPerPark.size(); i++) {
                cumulativePages += pagesPerPark[i];
            }
            _currentPage = cumulativePages + _currentAttractionPage;
            
            if (_updateCallback) _updateCallback();
            
            xSemaphoreGive(_dataMutex);
        }
        _logicTicksSincePageSwitch = 0;
    }
}

void ThemeParkModule::draw() {
    _canvas.fillScreen(0);
    _u8g2.begin(_canvas);  // Initialize u8g2 with canvas - required for proper rendering
    
    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
        // Filter displayable parks
        PsramVector<int> displayableIndices;
        for (size_t i = 0; i < _parkData.size(); i++) {
            if (shouldDisplayPark(_parkData[i])) {
                displayableIndices.push_back(i);
            }
        }
        
        // Sort displayable parks consistently with logicTick():
        // 1. OPEN parks first (at least one attraction open)
        // 2. Then CLOSED parks (with opening times)
        // 3. Alphabetically by name within each group (case-insensitive)
        std::sort(displayableIndices.begin(), displayableIndices.end(),
                  [this](int idxA, int idxB) {
                      const auto& parkA = _parkData[idxA];
                      const auto& parkB = _parkData[idxB];
                      
                      // Criterion 1: Open parks first
                      bool aHasOpen = parkHasOpenAttractions(parkA);
                      bool bHasOpen = parkHasOpenAttractions(parkB);
                      if (aHasOpen != bHasOpen) {
                          return aHasOpen > bHasOpen;
                      }
                      
                      // Criterion 2: Alphabetically by name (case-insensitive)
                      PsramString aLower = parkA.name;
                      PsramString bLower = parkB.name;
                      std::transform(aLower.begin(), aLower.end(), aLower.begin(), ::tolower);
                      std::transform(bLower.begin(), bLower.end(), bLower.begin(), ::tolower);
                      return aLower < bLower;
                  });
        
        if (displayableIndices.empty()) {
            drawNoDataPage();
        } else {
            // Find which displayable park we should show based on current index
            // Bounds check to prevent invalid access
            int displayIndex = (_currentParkIndex >= 0 && _currentParkIndex < (int)displayableIndices.size()) 
                               ? _currentParkIndex : 0;
            drawParkPage(displayableIndices[displayIndex], _currentAttractionPage);
        }
        xSemaphoreGive(_dataMutex);
    } else {
        drawNoDataPage();
    }
}

void ThemeParkModule::drawParkPage(int parkIndex, int attractionPage) {
    if (parkIndex < 0 || parkIndex >= (int)_parkData.size()) {
        drawNoDataPage();
        return;
    }
    
    const ThemeParkData& park = _parkData[parkIndex];
    
    // Check if this park should be displayed
    if (!shouldDisplayPark(park)) {
        drawNoDataPage();
        return;
    }
    
    // Check if park has any open attractions
    bool hasOpenAttractions = parkHasOpenAttractions(park);
    
    // Draw park name with country as headline - scrolling text
    // Use smaller font (6x13 like CalendarModule uses) and scrolling
    _u8g2.setFont(u8g2_font_6x13_tf);
    _u8g2.setForegroundColor(0xFFFF);
    
    PsramString displayName = park.name;
    if (!park.country.empty()) {
        displayName = displayName + " (" + park.country + ")";
    }
    
    // Add opening hours to scrolling text ONLY if park is OPEN
    if (hasOpenAttractions && !park.openingTime.empty() && !park.closingTime.empty()) {
        // Show opening hours in format: "Geöffnet von HH:MM - HH:MM Uhr"
        displayName = displayName + " : Geöffnet von " + park.openingTime + " - " + park.closingTime + " Uhr";
    }
    
    // Determine if crowd level will be shown
    bool showCrowdLevel = hasOpenAttractions && park.crowdLevel > 0.0f;
    
    // Calculate max name width - leave space for crowd level only if it will be shown
    int maxNameWidth = showCrowdLevel ? (_canvas.width() - 50) : (_canvas.width() - 4);
    
    // Pixelweises Scrolling für Parknamen
    if (_parkNameScroller) {
        _parkNameScroller->drawScrollingText(_canvas, displayName.c_str(), 2, 11, maxNameWidth, 0, 0xFFFF);
    } else {
        _u8g2.setCursor(2, 11);
        _u8g2.print(displayName.c_str());
    }
    
    // Draw crowd level as percentage text (no box)
    // Only show for OPEN parks (not closed parks)
    // Use same font as park name (u8g2_font_6x13_tf)
    // Color: green <= 40%, yellow 41-60%, red > 60%
    if (showCrowdLevel) {
        uint16_t crowdColor;
        if (park.crowdLevel <= 40.0f) {
            crowdColor = 0x07E0;  // Green
        } else if (park.crowdLevel <= 60.0f) {
            crowdColor = 0xFFE0;  // Yellow
        } else {
            crowdColor = 0xF800;  // Red
        }
        
        _u8g2.setFont(u8g2_font_6x13_tf);  // Same font as park name
        _u8g2.setForegroundColor(crowdColor);
        char crowdText[8];
        snprintf(crowdText, sizeof(crowdText), "%.0f%%", park.crowdLevel);
        int crowdW = _u8g2.getUTF8Width(crowdText);
        _u8g2.setCursor(_canvas.width() - crowdW - 2, 11);
        _u8g2.print(crowdText);
    }
    
    // If park is closed (no open attractions), show closed message instead of attraction list
    if (!hasOpenAttractions) {
        int yPos = 16;
        _u8g2.setFont(u8g2_font_9x15_tf);
        _u8g2.setForegroundColor(0xF800);  // Red
        
        yPos += 10;
        const char* closedMsg = "Geschlossen";
        int closedW = _u8g2.getUTF8Width(closedMsg);
        _u8g2.setCursor((_canvas.width() - closedW) / 2, yPos);
        _u8g2.print(closedMsg);
        
        // Show when park reopens if opening hours available
        if (!park.openingTime.empty() && !park.closingTime.empty()) {
            yPos += 20;
            _u8g2.setFont(u8g2_font_6x13_tf);
            _u8g2.setForegroundColor(0xFFFF);  // White
            
            PsramString reopenMsg = "Öffnet wieder von";
            int reopenW = _u8g2.getUTF8Width(reopenMsg.c_str());
            _u8g2.setCursor((_canvas.width() - reopenW) / 2, yPos);
            _u8g2.print(reopenMsg.c_str());
            
            yPos += 16;
            PsramString timeMsg = park.openingTime + " - " + park.closingTime + " Uhr";
            int timeW = _u8g2.getUTF8Width(timeMsg.c_str());
            _u8g2.setCursor((_canvas.width() - timeW) / 2, yPos);
            _u8g2.print(timeMsg.c_str());
        }
        
        return;  // Don't draw attractions list
    }
    
    // Park is open - draw attractions using smaller font like CalendarModule
    // Start position moved down by 2 more pixels
    int yPos = 16;
    _u8g2.setFont(u8g2_font_5x8_tf);
    _u8g2.setForegroundColor(0xFFFF);
    
    yPos += 4;  // Gap before attractions
    int lineHeight = 8;
    
    // Force exactly 6 attractions per page as requested
    int maxLines = 6;
    
    // Find maximum wait time for this park (for dynamic color gradient)
    int maxWaitTime = 0;
    for (const auto& attr : park.attractions) {
        if (attr.isOpen && attr.waitTime > maxWaitTime) {
            maxWaitTime = attr.waitTime;
        }
    }
    // Ensure we have a reasonable maximum (at least 1 to avoid division by zero)
    if (maxWaitTime < 1) maxWaitTime = 1;
    
    // Show ALL attractions (both open and closed) when park is open
    // Calculate which attractions to show on this page
    int startIdx = attractionPage * maxLines;
    int endIdx = min(startIdx + maxLines, (int)park.attractions.size());
    
    // Ensure PixelScroller slots for attractions
    int attractionsToShow = endIdx - startIdx;
    if (_attractionScroller) {
        _attractionScroller->ensureSlots(attractionsToShow);
    }
    
    // Calculate max width for attraction names (leave space for wait time)
    int maxAttrNameWidth = _canvas.width() - 45;
    
    for (int i = startIdx; i < endIdx; i++) {
        const Attraction& attr = park.attractions[i];
        int scrollIndex = i - startIdx;
        
        // Draw attraction name - use WHITE if open, RED if closed
        uint16_t attrColor = attr.isOpen ? 0xFFFF : 0xF800;
        
        // Pixelweises Scrolling für Attraktionsnamen
        if (_attractionScroller) {
            _attractionScroller->drawScrollingText(_canvas, attr.name.c_str(), 2, yPos, maxAttrNameWidth, scrollIndex, attrColor);
        } else {
            _u8g2.setForegroundColor(attrColor);
            _u8g2.setCursor(2, yPos);
            _u8g2.print(attr.name.c_str());
        }
        
        // Draw wait time or "Geschlossen" for closed attractions
        if (attr.isOpen) {
            char waitStr[10];
            snprintf(waitStr, sizeof(waitStr), "%d min", attr.waitTime);
            int waitW = _u8g2.getUTF8Width(waitStr);
            
            // Calculate color using dynamic gradient from green (0 min) to red (max wait time)
            uint16_t waitColor = calcColor(attr.waitTime, 5, maxWaitTime);
            
            _u8g2.setForegroundColor(waitColor);
            _u8g2.setCursor(_canvas.width() - waitW - 2, yPos);
            _u8g2.print(waitStr);
        } else {
            // Show "Geschlossen" in red for closed attractions
            const char* closedText = "Geschl.";
            int closedW = _u8g2.getUTF8Width(closedText);
            _u8g2.setForegroundColor(0xF800);  // Red
            _u8g2.setCursor(_canvas.width() - closedW - 2, yPos);
            _u8g2.print(closedText);
        }
        
        _u8g2.setForegroundColor(0xFFFF);
        yPos += lineHeight;
    }
}

void ThemeParkModule::drawNoDataPage() {
    _u8g2.setFont(u8g2_font_9x15_tf);
    _u8g2.setForegroundColor(0xFFFF);
    
    const char* msg1 = "Freizeitpark";
    const char* msg2 = "Keine Daten";
    
    int w1 = _u8g2.getUTF8Width(msg1);
    int w2 = _u8g2.getUTF8Width(msg2);
    
    _u8g2.setCursor((_canvas.width() - w1) / 2, _canvas.height() / 2 - 8);
    _u8g2.print(msg1);
    _u8g2.setCursor((_canvas.width() - w2) / 2, _canvas.height() / 2 + 8);
    _u8g2.print(msg2);
}

uint16_t ThemeParkModule::getCrowdLevelColor(float level) {
    // Level is 0-100 scale from API
    if (level <= 40.0f) return 0x07E0;      // Green
    if (level <= 60.0f) return 0xFFE0;      // Yellow
    return 0xF800;                          // Red
}

uint16_t ThemeParkModule::calcColor(float value, float low, float high) {
    // Calculate smooth color gradient from green (low) to red (high)
    // Adapted from TankerkoenigModule
    
    // 0 oder niedrige Werte = Grün (gut!)
    if (value <= 0) return rgb565(0, 255, 0);
    
    if (low >= high) return rgb565(255, 255, 0);

    float val = (value < low) ? low : (value > high ? high : value);
    
    int diff = (int)roundf(((high - val) / (high - low)) * 100.0f);

    uint8_t rval, gval;

    if (diff <= 50) { 
        rval = 255;
        gval = map(diff, 0, 50, 0, 255);
    } else { 
        gval = 255;
        rval = map(diff, 50, 100, 255, 0);
    }
    return rgb565(rval, gval, 0);
}

uint16_t ThemeParkModule::rgb565(uint8_t r, uint8_t g, uint8_t b) {
    // Convert RGB888 to RGB565 format
    return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}

PsramString ThemeParkModule::truncateString(const PsramString& text, int maxWidth) {
    int textWidth = _u8g2.getUTF8Width(text.c_str());
    if (textWidth <= maxWidth) {
        return text;
    }
    
    PsramString truncated = text;
    while (textWidth > maxWidth && truncated.length() > 3) {
        truncated = truncated.substr(0, truncated.length() - 1);
        PsramString withDots = truncated + "...";
        textWidth = _u8g2.getUTF8Width(withDots.c_str());
    }
    
    return truncated + "...";
}

PsramVector<AvailablePark> ThemeParkModule::getAvailableParks() {
    PsramVector<AvailablePark> parks;
    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
        parks = _availableParks;
        xSemaphoreGive(_dataMutex);
    }
    return parks;
}

void ThemeParkModule::loadParkCache() {
    if (!LittleFS.exists("/park_cache.json")) {
        Log.println("[ThemePark] No park cache found");
        return;
    }
    
    File file = LittleFS.open("/park_cache.json", "r");
    if (!file) {
        Log.println("[ThemePark] Failed to open park cache");
        return;
    }
    
    SpiRamAllocator allocator;
    JsonDocument doc(&allocator);
    
    DeserializationError error = deserializeJson(doc, file);
    file.close();
    
    if (error) {
        Log.printf("[ThemePark] Failed to parse park cache: %s\n", error.c_str());
        return;
    }
    
    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
        _availableParks.clear();
        
        JsonArray parks = doc["parks"].as<JsonArray>();
        if (parks) {
            for (JsonObject park : parks) {
                const char* id = park["id"] | "";
                const char* name = park["name"] | "";
                // Try both "land" (from API) and "country" (from cache) for compatibility
                const char* country = park["land"] | park["country"] | "";
                
                if (id && name && strlen(id) > 0 && strlen(name) > 0) {
                    _availableParks.push_back(AvailablePark(id, name, country));
                    Log.printf("[ThemePark] Loaded from cache: id=%s, name=%s, country=%s\n", id, name, country);
                }
            }
        }
        
        xSemaphoreGive(_dataMutex);
    }
    
    Log.printf("[ThemePark] Loaded %d parks from cache\n", _availableParks.size());
}

void ThemeParkModule::saveParkCache() {
    File file = LittleFS.open("/park_cache.json", "w");
    if (!file) {
        Log.println("[ThemePark] Failed to create park cache file");
        return;
    }
    
    SpiRamAllocator allocator;
    JsonDocument doc(&allocator);
    
    JsonArray parks = doc["parks"].to<JsonArray>();
    
    if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
        for (const auto& park : _availableParks) {
            JsonObject parkObj = parks.add<JsonObject>();
            parkObj["id"] = park.id.c_str();
            parkObj["name"] = park.name.c_str();
            parkObj["country"] = park.country.c_str();
        }
        xSemaphoreGive(_dataMutex);
    }
    
    serializeJson(doc, file);
    file.close();
    
    Log.printf("[ThemePark] Saved %d parks to cache\n", _availableParks.size());
}

PsramString ThemeParkModule::getParkNameFromCache(const PsramString& parkId) {
    // NOTE: This function expects _dataMutex to already be held by the caller
    PsramString name;
    
    Log.printf("[ThemePark] getParkNameFromCache: searching %d parks for %s\n", _availableParks.size(), parkId.c_str());
    for (const auto& park : _availableParks) {
        if (park.id == parkId) {
            name = park.name;
            Log.printf("[ThemePark] Found name for %s: %s\n", parkId.c_str(), name.c_str());
            break;
        }
    }
    if (name.empty()) {
        Log.printf("[ThemePark] No name found for %s in cache (%d parks)\n", parkId.c_str(), _availableParks.size());
    }
    
    return name;
}

PsramString ThemeParkModule::getParkCountryFromCache(const PsramString& parkId) {
    // NOTE: This function expects _dataMutex to already be held by the caller
    PsramString country;
    
    Log.printf("[ThemePark] getParkCountryFromCache: searching %d parks for %s\n", _availableParks.size(), parkId.c_str());
    for (const auto& park : _availableParks) {
        if (park.id == parkId) {
            country = park.country;
            Log.printf("[ThemePark] Found country for %s: %s\n", parkId.c_str(), country.c_str());
            break;
        }
    }
    if (country.empty()) {
        Log.printf("[ThemePark] No country found for %s in cache\n", parkId.c_str());
    }
    
    return country;
}

void ThemeParkModule::checkAndUpdateParksList() {
    if (!_webClient) return;
    
    time_t now = time(nullptr);
    
    // Check if we need to update (once per day = 86400 seconds)
    // If _lastParksListUpdate is 0, load from cache first
    if (_lastParksListUpdate == 0) {
        // First time - try to load from cache
        loadParkCache();
        
        // If cache is still empty after loading, fetch from API immediately
        bool cacheEmpty = false;
        if (xSemaphoreTake(_dataMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
            cacheEmpty = _availableParks.empty();
            xSemaphoreGive(_dataMutex);
        }
        
        if (cacheEmpty) {
            Log.println("[ThemePark] Cache empty, fetching parks list from API");
            // Don't set _lastParksListUpdate yet, let it fetch
        } else {
            _lastParksListUpdate = now;  // Set to now to prevent immediate fetch
            return;
        }
    } else if ((now - _lastParksListUpdate) < 86400) {
        return;  // Not yet time to update
    }
    
    Log.println("[ThemePark] Fetching parks list from API");
    
    PsramString url = "https://api.wartezeiten.app/v1/parks";
    PsramString headers = "accept: application/json\nlanguage: de";
    
    // Update timestamp BEFORE making request to prevent multiple simultaneous requests
    _lastParksListUpdate = now;
    
    // Fetch parks list asynchronously
    _webClient->getRequest(url, headers, [this](int httpCode, const char* payload, size_t len) {
        if (httpCode == 200 && payload && len > 0) {
            Log.printf("[ThemePark] Received parks list (size: %d)\n", len);
            parseAvailableParks(payload, len);
        } else {
            Log.printf("[ThemePark] Parks list fetch failed: HTTP %d\n", httpCode);
        }
    });
}