display_manager.cpp

#include "display_manager.h"
#include "system_monitor.h"
#include "config_storage.h"

// Global instance
DisplayManager displayManager;

DisplayManager::DisplayManager() : 
    dsipanel(nullptr),
    gfx(nullptr),
    displayWidth(0),
    displayHeight(0),
    displayBrightness(DEFAULT_BRIGHTNESS),
    brightnessInitialized(false),
    debugY(DEBUG_START_Y),
    debugLineCount(0),
    firstImageLoaded(false),
    otaScreenInitialized(false),
    lastOTAPercent(255),
    _paused(false)
{}

DisplayManager::~DisplayManager() {
    cleanup();
}

bool DisplayManager::begin() {
    // Get runtime display configuration from config storage
    extern ConfigStorage configStorage;
    int displayType = configStorage.getDisplayType();
    
    // Select the appropriate display config (1 = 3.4", 2 = 4.0")
    const DisplayConfig& activeConfig = (displayType == SCREEN_4INCH_DSI) 
        ? SCREEN_4_INCH_CONFIG 
        : SCREEN_3_4_INCH_CONFIG;
    
    Serial.printf("Display type selected: %d (%s)\n", displayType, activeConfig.name);
    
    // Initialize display objects with selected config
    dsipanel = new Arduino_ESP32DSIPanel(
        activeConfig.hsync_pulse_width,
        activeConfig.hsync_back_porch,
        activeConfig.hsync_front_porch,
        activeConfig.vsync_pulse_width,
        activeConfig.vsync_back_porch,
        activeConfig.vsync_front_porch,
        activeConfig.prefer_speed,
        activeConfig.lane_bit_rate);
    
    if (!dsipanel) {
        Serial.println("ERROR: Failed to create DSI panel!");
        return false;
    }
    
    gfx = new Arduino_DSI_Display(
        activeConfig.width,
        activeConfig.height,
        dsipanel,
        activeConfig.rotation,
        true,
        activeConfig.lcd_rst,
        activeConfig.init_cmds,
        activeConfig.init_cmds_size);
    
    if (!gfx) {
        Serial.println("ERROR: Failed to create display object!");
        return false;
    }
    
#ifdef GFX_EXTRA_PRE_INIT
    GFX_EXTRA_PRE_INIT();
#endif

    if (!gfx->begin()) {
        Serial.println("ERROR: Display init failed!");
        return false;
    }
    
    displayWidth = gfx->width();
    displayHeight = gfx->height();
    
    // Clear screen and start debug output
    clearScreen();
    gfx->flush();  // Ensure screen is actually cleared to hardware
    debugY = DEBUG_START_Y;
    debugLineCount = 0;
    
    return true;
}

void DisplayManager::cleanup() {
    if (gfx) {
        delete gfx;
        gfx = nullptr;
    }
    if (dsipanel) {
        delete dsipanel;
        dsipanel = nullptr;
    }
}

Arduino_DSI_Display* DisplayManager::getGFX() const {
    return gfx;
}

int16_t DisplayManager::getWidth() const {
    return displayWidth;
}

int16_t DisplayManager::getHeight() const {
    return displayHeight;
}

bool DisplayManager::initBrightness() {
    if (brightnessInitialized) return true;
    
    // Configure LEDC for backlight control using newer API
    if (ledcAttach(BACKLIGHT_PIN, BACKLIGHT_FREQ, BACKLIGHT_RESOLUTION) == 0) {
        debugPrint("ERROR: LEDC attach failed!", COLOR_RED);
        return false;
    }
    
    // Get the default brightness from configuration storage
    displayBrightness = configStorage.getDefaultBrightness();
    
    // Set initial brightness
    setBrightness(displayBrightness);
    brightnessInitialized = true;
    
    return true;
}

void DisplayManager::setBrightness(int brightness) {
    if (!brightnessInitialized) return;
    
    brightness = constrain(brightness, 0, 100);
    displayBrightness = brightness;
    
    // Convert percentage to inverted 10-bit duty cycle (0-1023)
    // Backlight uses inverted logic: low PWM = high brightness
    uint32_t duty = 1023 - ((1023 * brightness) / 100);
    
    ledcWrite(BACKLIGHT_PIN, duty);
}

int DisplayManager::getBrightness() const {
    return displayBrightness;
}

void DisplayManager::debugPrint(const char* message, uint16_t color) {
    if (firstImageLoaded) return; // Don't show debug after first image loads
    if (!gfx) return;
    
    gfx->setTextSize(DEBUG_TEXT_SIZE);
    gfx->setTextColor(color);
    
    // Calculate text width for centering
    int16_t x1, y1;
    uint16_t textWidth, textHeight;
    gfx->getTextBounds(message, 0, 0, &x1, &y1, &textWidth, &textHeight);
    
    // Center the text horizontally
    int16_t centerX = (displayWidth - textWidth) / 2;
    if (centerX < 10) centerX = 10; // Minimum margin
    
    gfx->setCursor(centerX, debugY);
    gfx->println(message);
    
    debugY += DEBUG_LINE_HEIGHT;
    debugLineCount++;
    
    // Scroll if we reach the bottom (unless auto-scroll is disabled for WiFi setup)
    if (!disableAutoScroll && (debugY > displayHeight - 50 || debugLineCount > MAX_DEBUG_LINES)) {
        // Clear screen and reset
        clearScreen();
        debugY = DEBUG_START_Y;
        debugLineCount = 0;
        
        // Don't show the debug log header during initial boot
        // Center the scroll header
        // gfx->setTextSize(DEBUG_TEXT_SIZE);
        // gfx->setTextColor(COLOR_YELLOW);
        // const char* scrollMsg = "=== DEBUG LOG ===";
        // gfx->getTextBounds(scrollMsg, 0, 0, &x1, &y1, &textWidth, &textHeight);
        // centerX = (displayWidth - textWidth) / 2;
        // gfx->setCursor(centerX, debugY);
        // gfx->println(scrollMsg);
        // debugY += DEBUG_LINE_HEIGHT * 2;
    }
}

void DisplayManager::debugPrintf(uint16_t color, const char* format, ...) {
    if (firstImageLoaded) return;
    
    char buffer[256];
    va_list args;
    va_start(args, format);
    vsnprintf(buffer, sizeof(buffer), format, args);
    va_end(args);
    
    debugPrint(buffer, color);
}

void DisplayManager::clearDebugArea() {
    debugY = DEBUG_START_Y;
    debugLineCount = 0;
}

void DisplayManager::setFirstImageLoaded(bool loaded) {
    firstImageLoaded = loaded;
}

void DisplayManager::setDebugY(int y) {
    debugY = y;
    debugLineCount = 0;
}

void DisplayManager::setDisableAutoScroll(bool disable) {
    disableAutoScroll = disable;
}

void DisplayManager::clearScreen(uint16_t color) {
    if (gfx) {
        gfx->fillScreen(color);
    }
}

void DisplayManager::drawBitmap(int16_t x, int16_t y, uint16_t* bitmap, int16_t w, int16_t h) {
    if (_paused) return;
    if (gfx && bitmap) {
        gfx->draw16bitRGBBitmap(x, y, bitmap, w, h);
    }
}

void DisplayManager::pauseDisplay() {
    // Pause display rendering to prevent memory bandwidth conflicts during heavy PSRAM operations
    _paused = true;
}

void DisplayManager::resumeDisplay() {
    // Resume normal display rendering after heavy operations complete
    _paused = false;
}

void DisplayManager::showSystemStatus() {
    if (!gfx) return;
    
    clearScreen();
    
    gfx->setTextSize(2);
    gfx->setTextColor(COLOR_WHITE);
    gfx->setCursor(10, 10);
    gfx->println("ESP32-P4 AllSky Display");
    
    gfx->setTextSize(1);
    gfx->setTextColor(COLOR_CYAN);
    gfx->setCursor(10, 40);
    gfx->printf("Display: %dx%d pixels\n", displayWidth, displayHeight);
    gfx->printf("Brightness: %d%%\n", displayBrightness);
    gfx->printf("Free Heap: %d bytes\n", systemMonitor.getCurrentFreeHeap());
    gfx->printf("Free PSRAM: %d bytes\n", systemMonitor.getCurrentFreePsram());
    gfx->printf("System Health: %s\n", systemMonitor.isSystemHealthy() ? "HEALTHY" : "CRITICAL");
}

void DisplayManager::drawStatusOverlay(const char* message, uint16_t color, int yOffset) {
    if (_paused) return;
    if (!gfx || !message) return;
    
    // Draw semi-transparent background box with rounded corners effect
    // Calculate text dimensions for the background
    int16_t x1, y1;
    uint16_t textWidth, textHeight;
    gfx->setTextSize(1);
    gfx->getTextBounds(message, 0, 0, &x1, &y1, &textWidth, &textHeight);
    
    // Create overlay box with padding
    int boxPadding = 8;
    int16_t boxX = (displayWidth - textWidth) / 2 - boxPadding;
    int16_t boxY = yOffset - 5;
    int16_t boxWidth = textWidth + (boxPadding * 2);
    int16_t boxHeight = textHeight + 10;
    
    // Clamp to screen bounds
    if (boxX < 0) boxX = 0;
    if (boxY < 0) boxY = 0;
    if (boxX + boxWidth > displayWidth) boxWidth = displayWidth - boxX;
    if (boxY + boxHeight > displayHeight) boxHeight = displayHeight - boxY;
    
    // Draw semi-transparent dark background (multiple overlays to create transparency effect)
    uint16_t bgColor = 0x0000; // Black
    gfx->fillRect(boxX, boxY, boxWidth, boxHeight, bgColor);
    
    // Draw text on the overlay
    gfx->setTextSize(1);
    gfx->setTextColor(color);
    int16_t centerX = (displayWidth - textWidth) / 2;
    gfx->setCursor(centerX, yOffset);
    gfx->println(message);
}

void DisplayManager::drawOverlayMessage(const char* message, int x, int y, uint16_t color, int backgroundColor) {
    if (_paused) return;
    if (!gfx || !message) return;
    
    // Calculate text dimensions
    int16_t x1, y1;
    uint16_t textWidth, textHeight;
    gfx->setTextSize(1);
    gfx->getTextBounds(message, 0, 0, &x1, &y1, &textWidth, &textHeight);
    
    // Create background box with padding
    int boxPadding = 6;
    int16_t boxX = x - boxPadding;
    int16_t boxY = y - boxPadding;
    int16_t boxWidth = textWidth + (boxPadding * 2);
    int16_t boxHeight = textHeight + (boxPadding * 2);
    
    // Clamp to screen bounds
    if (boxX < 0) boxX = 0;
    if (boxY < 0) boxY = 0;
    if (boxX + boxWidth > displayWidth) boxWidth = displayWidth - boxX;
    if (boxY + boxHeight > displayHeight) boxHeight = displayHeight - boxY;
    
    // Draw dark background for readability
    gfx->fillRect(boxX, boxY, boxWidth, boxHeight, backgroundColor);
    
    // Draw text
    gfx->setTextSize(1);
    gfx->setTextColor(color);
    gfx->setCursor(x, y);
    gfx->println(message);
}

void DisplayManager::clearStatusOverlay() {
    // Overlay is cleared by redrawing the last image
    // This is done by calling renderFullImage() from the main loop
}

void DisplayManager::showOTAProgress(const char* title, uint8_t percent, const char* message) {
    if (!gfx) return;
    
    // Only draw the screen once at the start
    if (!otaScreenInitialized) {
        // Calculate center positions
        int centerX = displayWidth / 2;
        int centerY = displayHeight / 2;
        
        int16_t x1, y1;
        uint16_t w, h;
        
        // Clear screen with dark background
        clearScreen(0x1082); // Dark blue background
        
        // Draw title
        gfx->setTextSize(4);
        gfx->setTextColor(COLOR_WHITE);
        const char* mainMsg = "OTA Update";
        gfx->getTextBounds(mainMsg, 0, 0, &x1, &y1, &w, &h);
        gfx->setCursor(centerX - w/2, centerY - 60);
        gfx->println(mainMsg);
        
        // Draw in progress message
        gfx->setTextSize(3);
        gfx->setTextColor(COLOR_CYAN);
        const char* statusMsg = "In Progress...";
        gfx->getTextBounds(statusMsg, 0, 0, &x1, &y1, &w, &h);
        gfx->setCursor(centerX - w/2, centerY + 20);
        gfx->println(statusMsg);
        
        // Draw warning message
        gfx->setTextSize(2);
        gfx->setTextColor(COLOR_RED);
        const char* warning = "Do not power off device";
        gfx->getTextBounds(warning, 0, 0, &x1, &y1, &w, &h);
        gfx->setCursor(centerX - w/2, centerY + 100);
        gfx->println(warning);
        
        // Flush all drawing operations to screen at once
        if (gfx) {
            gfx->flush();
        }
        
        otaScreenInitialized = true;
    }
    
    // Special handling for completion
    if (percent == 100) {
        int centerX = displayWidth / 2;
        int centerY = displayHeight / 2;
        int16_t x1, y1;
        uint16_t w, h;
        
        clearScreen(0x1082);
        
        gfx->setTextSize(4);
        gfx->setTextColor(COLOR_GREEN);
        const char* completeMsg = "OTA Complete!";
        gfx->getTextBounds(completeMsg, 0, 0, &x1, &y1, &w, &h);
        gfx->setCursor(centerX - w/2, centerY - 30);
        gfx->println(completeMsg);
        
        gfx->setTextSize(3);
        gfx->setTextColor(COLOR_WHITE);
        const char* rebootMsg = "Rebooting...";
        gfx->getTextBounds(rebootMsg, 0, 0, &x1, &y1, &w, &h);
        gfx->setCursor(centerX - w/2, centerY + 30);
        gfx->println(rebootMsg);
        
        // Flush completion screen to display
        if (gfx) {
            gfx->flush();
        }
    }
    
    // Reset screen initialized flag after showing completion so next OTA starts fresh
    if (percent == 100) {
        otaScreenInitialized = false;
    }
}