// boards/esp32-s3-lcd-43/DisplayDriverGFX.cpp
#include "DisplayDriverGFX.h"

#include "LovyanPins.h"
#include "board_config.h"

#include <Arduino.h>
#include <KlubhausCore.h>

// ── Globals ──
static LGFX* _gfx = nullptr;
extern DisplayManager display;

// ── Forward declarations ──
static void initDisplay();

// ── Dimensions ──
static constexpr int DISP_W = 800;
static constexpr int DISP_H = 480;

// ── Display initialization ──
static void initDisplay() {
    Serial.println("LovyanGFX init...");

    // Note: LovyanGFX handles I2C internally (port 1 for touch, port 0 for CH422G)
    // No need to call Wire.begin() or Wire1.begin()

    _gfx = new LGFX();
    _gfx->init();
    _gfx->setRotation(0); // Landscape
    _gfx->fillScreen(0x000000);

    Serial.println("Display ready");
}

// ── Singleton ──
DisplayDriverGFX& DisplayDriverGFX::instance() {
    static DisplayDriverGFX inst;
    return inst;
}

// ── IDisplayDriver implementation ──

void DisplayDriverGFX::begin() {
    initDisplay();
    // Turn on backlight immediately
    setBacklight(true);
}

void DisplayDriverGFX::setBacklight(bool on) {
    if(_gfx) {
        // LovyanGFX handles backlight via setBrightness
        _gfx->setBrightness(on ? 255 : 0);
    }
}

int DisplayDriverGFX::width() { return _gfx ? _gfx->width() : DISP_W; }

int DisplayDriverGFX::height() { return _gfx ? _gfx->height() : DISP_H; }

// ── Fonts ──
// LovyanGFX built-in fonts for 800x480 display
void DisplayDriverGFX::setTitleFont() { _gfx->setFont(&fonts::FreeSansBold24pt7b); }

void DisplayDriverGFX::setBodyFont() { _gfx->setFont(&fonts::FreeSans18pt7b); }

void DisplayDriverGFX::setLabelFont() { _gfx->setFont(&fonts::FreeSans12pt7b); }

void DisplayDriverGFX::setDefaultFont() { _gfx->setFont(&fonts::Font2); }

// Transform touch coordinates to match display orientation
// GT911 touch panel on this board is rotated 180° relative to display
void DisplayDriverGFX::transformTouch(int* x, int* y) {
    if(!x || !y)
        return;
    // Flip both axes: (0,0) becomes (width, height)
    *x = DISP_W - *x;
    *y = DISP_H - *y;
}

// Test harness: parse serial commands to inject synthetic touches
// Commands:
//   TEST:touch x y press   - simulate press at (x, y) [raw panel coords]
//   TEST:touch x y release - simulate release at (x, y)
//   TEST:touch clear       - clear test mode
bool DisplayDriverGFX::parseTestTouch(int* outX, int* outY, bool* outPressed) {
    if(!Serial.available())
        return false;

    // Only consume if it starts with 'T' - don't steal other commands
    // Use "TEST:" prefix to avoid conflict with [CMD] echo
    if(Serial.peek() != 'T') {
        return false;
    }

    String cmd = Serial.readStringUntil('\n');
    cmd.trim();

    if(!cmd.startsWith("TEST:touch"))
        return false;

    // Parse: touch x y press|release
    int firstSpace = cmd.indexOf(' ');
    if(firstSpace < 0)
        return false;

    String args = cmd.substring(firstSpace + 1);
    args.trim();

    if(args.equals("clear")) {
        _testMode = false;
        Serial.println("[TEST] Test mode cleared");
        return false;
    }

    // Parse x y state
    int secondSpace = args.indexOf(' ');
    if(secondSpace < 0)
        return false;

    String xStr = args.substring(0, secondSpace);
    String yState = args.substring(secondSpace + 1);
    yState.trim();

    int x = xStr.toInt();
    int y = yState.substring(0, yState.indexOf(' ')).toInt();
    String state = yState.substring(yState.indexOf(' ') + 1);
    state.trim();

    bool pressed = state.equals("press");

    Serial.printf("[TEST] Injecting touch: (%d,%d) %s\n", x, y, pressed ? "press" : "release");

    if(outX)
        *outX = x;
    if(outY)
        *outY = y;
    if(outPressed)
        *outPressed = pressed;

    _testMode = true;
    return true;
}

// Touch handling

TouchEvent DisplayDriverGFX::readTouch() {
    TouchEvent evt;
    if(!_gfx)
        return evt;

    // Check for test injection via serial
    int testX, testY;
    bool testPressed;
    if(parseTestTouch(&testX, &testY, &testPressed)) {
        // Handle test touch with same logic as real touch
        unsigned long now = millis();

        if(testPressed && !_lastTouch.pressed) {
            evt.pressed = true;
            evt.downX = testX;
            evt.downY = testY;
            _lastTouch.downX = evt.downX;
            _lastTouch.downY = evt.downY;
            _touchBounced = false;
        } else if(!testPressed && _lastTouch.pressed) {
            evt.released = true;
            evt.downX = _lastTouch.downX;
            evt.downY = _lastTouch.downY;
            _lastReleaseMs = now;
            _touchBounced = true;
        }

        if(testPressed) {
            evt.x = testX;
            evt.y = testY;
            evt.downX = _lastTouch.downX;
            evt.downY = _lastTouch.downY;
            _pressStartMs = millis();
        }

        if(_touchBounced && now - _lastReleaseMs >= TOUCH_DEBOUNCE_MS) {
            _touchBounced = false;
        }

        _lastTouch.pressed = testPressed;
        if(testPressed) {
            _lastTouch.x = evt.x;
            _lastTouch.y = evt.y;
        }
        return evt;
    }

    int32_t x, y;
    bool pressed = _gfx->getTouch(&x, &y);

    // Filter out invalid coordinates (touch panel can return garbage on release)
    // Ignore both press and release transitions when coordinates are out of bounds
    bool validCoords = !(x < 0 || x > DISP_W || y < 0 || y > DISP_H);
    if(!validCoords) {
        pressed = false;
        // Don't update _lastTouch.pressed - keep previous state to avoid false release
        return evt;
    }

    // Debounce: ignore repeated press events within debounce window after release
    unsigned long now = millis();
    if(pressed && _touchBounced) {
        // Within debounce window - ignore this press
        _lastTouch.pressed = pressed;
        return evt;
    }

    // Detect transitions (press/release)
    if(pressed && !_lastTouch.pressed) {
        // Press transition: finger just touched down
        evt.pressed = true;
        evt.downX = static_cast<int>(x);
        evt.downY = static_cast<int>(y);
        _lastTouch.downX = evt.downX;
        _lastTouch.downY = evt.downY;
        _touchBounced = false;
    } else if(!pressed && _lastTouch.pressed) {
        // Release transition: finger just lifted
        evt.released = true;
        evt.downX = _lastTouch.downX;
        evt.downY = _lastTouch.downY;
        // Start debounce window
        _lastReleaseMs = now;
        _touchBounced = true;
    }

    // Current position if still touched
    if(pressed) {
        evt.x = static_cast<int>(x);
        evt.y = static_cast<int>(y);
        evt.downX = _lastTouch.downX;
        evt.downY = _lastTouch.downY;
        _pressStartMs = millis();
    }

    // Check if debounce window has expired
    if(_touchBounced && now - _lastReleaseMs >= TOUCH_DEBOUNCE_MS) {
        _touchBounced = false;
    }

    // Track previous state
    _lastTouch.pressed = pressed;
    if(pressed) {
        _lastTouch.x = evt.x;
        _lastTouch.y = evt.y;
    }
    return evt;
}

int DisplayDriverGFX::dashboardTouch(int x, int y) {
    // Dashboard tiles: 2 rows × 4 columns
    constexpr int cols = 4;
    constexpr int rows = 2;
    constexpr int tileW = DISP_W / cols;
    constexpr int tileH = DISP_H / rows;

    if(x < 0 || x >= DISP_W || y < 0 || y >= DISP_H) {
        return -1;
    }

    int col = x / tileW;
    int row = y / tileH;

    return row * cols + col;
}

HoldState DisplayDriverGFX::updateHold(const TouchEvent& evt, unsigned long holdMs) {
    HoldState state;

    if(!evt.pressed) {
        _isHolding = false;
        return state;
    }

    unsigned long elapsed = millis() - _pressStartMs;

    if(!_isHolding) {
        _isHolding = true;
        state.started = true;
    }

    state.active = true;
    state.progress = static_cast<float>(elapsed) / static_cast<float>(holdMs);

    if(state.progress >= 1.0f) {
        state.progress = 1.0f;
        state.completed = true;
    }

    return state;
}

// ── Rendering ──

void DisplayDriverGFX::render(const ScreenState& state) {
    if(!_gfx)
        return;

    // Check if we need full redraw
    if(state.screen != _lastScreen
        || (state.screen == ScreenID::BOOT && state.bootStage != _lastBootStage)) {
        _needsRedraw = true;
        _lastScreen = state.screen;
        _lastBootStage = state.bootStage;
    }

    switch(state.screen) {
    case ScreenID::BOOT:
        if(_needsRedraw) {
            drawBoot(state);
            _needsRedraw = false;
        }
        break;

    case ScreenID::OFF:
        if(_needsRedraw) {
            _gfx->fillScreen(0x000000);
            _needsRedraw = false;
        }
        break;

    case ScreenID::ALERT:
        // Only redraw on first entry or screen change
        if(_needsRedraw) {
            drawAlert(state);
            _needsRedraw = false;
        }
        break;

    case ScreenID::DASHBOARD:
        if(_needsRedraw) {
            drawDashboard(state);
            _needsRedraw = false;
        }
        break;

    case ScreenID::STATUS:
        if(_needsRedraw) {
            drawStatus(state);
            _needsRedraw = false;
        }
        break;
    }
}

void DisplayDriverGFX::drawBoot(const ScreenState& state) {
    BootStage stage = state.bootStage;

    _gfx->fillScreen(TFT_BLACK);
    _gfx->setTextColor(STYLE_COLOR_FG);
    setTitleFont();
    _gfx->setCursor(STYLE_SPACING_X, STYLE_SPACING_Y);
    _gfx->print("KLUBHAUS");

    setBodyFont();
    _gfx->setCursor(STYLE_SPACING_X, STYLE_SPACING_Y + STYLE_HEADER_HEIGHT);
    _gfx->print(BOARD_NAME);

    // Show boot stage status
    setLabelFont();
    _gfx->setCursor(STYLE_SPACING_X, STYLE_SPACING_Y + STYLE_HEADER_HEIGHT + 30);
    switch(stage) {
    case BootStage::SPLASH:
        _gfx->print("Initializing...");
        break;
    case BootStage::INIT_DISPLAY:
        _gfx->print("Display OK");
        break;
    case BootStage::INIT_NETWORK:
        _gfx->print("Network init...");
        break;
    case BootStage::CONNECTING_WIFI:
        _gfx->print("Connecting WiFi...");
        break;
    case BootStage::READY:
        _gfx->print("All systems go!");
        break;
    case BootStage::DONE:
        _gfx->print("Ready!");
        break;
    }
}

void DisplayDriverGFX::drawAlert(const ScreenState& state) {
    uint32_t elapsed = millis() - state.alertStartMs;
    uint8_t pulse = static_cast<uint8_t>(180.0f + 75.0f * sinf(elapsed / 300.0f));
    uint16_t bg = _gfx->color565(pulse, 0, 0);

    _gfx->fillScreen(bg);
    _gfx->setTextColor(STYLE_COLOR_FG, bg);

    setTitleFont();
    _gfx->setCursor(STYLE_SPACING_X, STYLE_HEADER_HEIGHT);
    _gfx->print(state.alertTitle.length() > 0 ? state.alertTitle.c_str() : "ALERT");

    setBodyFont();
    _gfx->setCursor(STYLE_SPACING_X, STYLE_HEADER_HEIGHT + 50);
    _gfx->print(state.alertBody);

    setLabelFont();
    _gfx->setCursor(STYLE_SPACING_X, DISP_H - STYLE_SPACING_Y);
    _gfx->print("Hold to silence...");
}

void DisplayDriverGFX::drawDashboard(const ScreenState& state) {
    _gfx->fillScreen(STYLE_COLOR_BG);

    // Header - use Layout for safe positioning
    _gfx->fillRect(0, 0, DISP_W, STYLE_HEADER_HEIGHT, STYLE_COLOR_HEADER);
    Layout header = Layout::header(DISP_W, STYLE_HEADER_HEIGHT);
    Layout safeText = header.padded(STYLE_SPACING_X);

    setBodyFont();
    _gfx->setTextColor(STYLE_COLOR_FG);

    // Title with scrolling support
    _headerScroller.setText("KLUBHAUS");
    _headerScroller.setScrollSpeed(80);
    _headerScroller.setPauseDuration(2000);
    _headerScroller.render(
        [&](int16_t x, const char* s) {
            _gfx->setCursor(safeText.x + x, safeText.y + 4);
            _gfx->print(s);
        },
        safeText.w);

    // WiFi status - right aligned with scrolling
    Layout wifiArea(DISP_W - 150, 0, 140, STYLE_HEADER_HEIGHT);
    Layout safeWifi = wifiArea.padded(4);
    _wifiScroller.setText(state.wifiSsid.length() > 0 ? state.wifiSsid.c_str() : "WiFi: OFF");
    _wifiScroller.setScrollSpeed(60);
    _wifiScroller.setPauseDuration(1500);
    _wifiScroller.render(
        [&](int16_t x, const char* s) {
            _gfx->setCursor(safeWifi.x + x, safeWifi.y + 4);
            _gfx->print(s);
        },
        safeWifi.w);

    // Get tile layouts from library helper
    int tileCount = display.calculateDashboardLayouts(STYLE_HEADER_HEIGHT, STYLE_TILE_GAP);
    display.setHeaderHeight(STYLE_HEADER_HEIGHT);
    const TileLayout* layouts = display.getTileLayouts();

    const char* tileLabels[] = { "Alert", "Silent", "Status", "Reboot" };
    const uint16_t tileColors[] = { 0x0280, 0x0400, 0x0440, 0x0100 };

    for(int i = 0; i < tileCount && i < 4; i++) {
        const TileLayout& lay = layouts[i];
        int x = lay.x;
        int y = lay.y;
        int w = lay.w;
        int h = lay.h;

        // Tile background
        _gfx->fillRoundRect(x, y, w, h, STYLE_TILE_RADIUS, tileColors[i]);

        // Tile border
        _gfx->drawRoundRect(x, y, w, h, STYLE_TILE_RADIUS, STYLE_COLOR_FG);

        // Tile label
        _gfx->setTextColor(STYLE_COLOR_FG);
        setBodyFont();
        int textLen = strlen(tileLabels[i]);
        int textW = textLen * 14;
        _gfx->setCursor(x + w / 2 - textW / 2, y + h / 2 - 10);
        _gfx->print(tileLabels[i]);
    }
}

void DisplayDriverGFX::drawStatus(const ScreenState& st) {
    _gfx->fillScreen(STYLE_COLOR_BG);

    // Header with title and back button
    _gfx->fillRect(0, 0, DISP_W, STYLE_HEADER_HEIGHT, STYLE_COLOR_HEADER);
    Layout header = Layout::header(DISP_W, STYLE_HEADER_HEIGHT);
    Layout safeText = header.padded(STYLE_SPACING_X);

    setTitleFont();
    _gfx->setTextColor(STYLE_COLOR_FG);
    _gfx->setCursor(safeText.x, safeText.y + 4);
    _gfx->print("STATUS");

    // Back button in lower-right
    setLabelFont();
    _gfx->setCursor(DISP_W - 60, DISP_H - 20);
    _gfx->print("[BACK]");

    // Status items in 2-column layout
    setBodyFont();
    int colWidth = DISP_W / 2;
    int startY = STYLE_HEADER_HEIGHT + 30;
    int rowHeight = 35;
    int labelX = STYLE_SPACING_X + 10;
    int valueX = STYLE_SPACING_X + 120;

    // Column 1
    int y = startY;

    // WiFi SSID
    _gfx->setTextColor(0x8888);
    _gfx->setCursor(labelX, y);
    _gfx->print("WiFi:");
    _gfx->setTextColor(STYLE_COLOR_FG);
    _gfx->setCursor(valueX, y);
    _gfx->print(st.wifiSsid.length() > 0 ? st.wifiSsid.c_str() : "N/A");

    // RSSI
    y += rowHeight;
    _gfx->setTextColor(0x8888);
    _gfx->setCursor(labelX, y);
    _gfx->print("Signal:");
    _gfx->setTextColor(STYLE_COLOR_FG);
    _gfx->setCursor(valueX, y);
    _gfx->printf("%d dBm", st.wifiRssi);

    // IP Address
    y += rowHeight;
    _gfx->setTextColor(0x8888);
    _gfx->setCursor(labelX, y);
    _gfx->print("IP:");
    _gfx->setTextColor(STYLE_COLOR_FG);
    _gfx->setCursor(valueX, y);
    _gfx->print(st.ipAddr.length() > 0 ? st.ipAddr.c_str() : "N/A");

    // Column 2
    y = startY;

    // Uptime
    uint32_t upSec = st.uptimeMs / 1000;
    uint32_t upMin = upSec / 60;
    uint32_t upHr = upMin / 60;
    upSec = upSec % 60;
    upMin = upMin % 60;
    _gfx->setTextColor(0x8888);
    _gfx->setCursor(colWidth + labelX, y);
    _gfx->print("Uptime:");
    _gfx->setTextColor(STYLE_COLOR_FG);
    _gfx->setCursor(colWidth + valueX, y);
    _gfx->printf("%02lu:%02lu:%02lu", upHr, upMin, upSec);

    // Heap
    y += rowHeight;
    _gfx->setTextColor(0x8888);
    _gfx->setCursor(colWidth + labelX, y);
    _gfx->print("Heap:");
    _gfx->setTextColor(STYLE_COLOR_FG);
    _gfx->setCursor(colWidth + valueX, y);
    _gfx->printf("%d KB", ESP.getFreeHeap() / 1024);

    // Last Poll
    y += rowHeight;
    _gfx->setTextColor(0x8888);
    _gfx->setCursor(colWidth + labelX, y);
    _gfx->print("Last Poll:");
    _gfx->setTextColor(STYLE_COLOR_FG);
    _gfx->setCursor(colWidth + valueX, y);
    uint32_t pollAgo = (millis() - st.lastPollMs) / 1000;
    if(pollAgo < 60) {
        _gfx->printf("%lu sec", pollAgo);
    } else {
        _gfx->printf("%lu min", pollAgo / 60);
    }

    // Footer with firmware version
    setLabelFont();
    _gfx->setTextColor(0x6666);
    _gfx->setCursor(STYLE_SPACING_X, DISP_H - STYLE_SPACING_Y);
    _gfx->print("v" FW_VERSION);
}

void DisplayDriverGFX::drawDebugTouch(int x, int y) {
    if(!_gfx)
        return;

    const int size = 20;
    _gfx->drawLine(x - size, y, x + size, y, TFT_RED);
    _gfx->drawLine(x, y - size, x, y + size, TFT_RED);
}