#include "SleepActivity.h"

#include <Epub.h>
#include <GfxRenderer.h>
#include <HalStorage.h>
#include <Serialization.h>
#include <Txt.h>
#include <Xtc.h>

#include <algorithm>
#include <cmath>

#include "CrossPointSettings.h"
#include "CrossPointState.h"
#include "components/UITheme.h"
#include "fontIds.h"
#include "images/Logo120.h"
#include "util/StringUtils.h"

namespace {

// Number of source pixels along the image edge to average for the dominant color
constexpr int EDGE_SAMPLE_DEPTH = 20;

// Map a 2-bit quantized pixel value to an 8-bit grayscale value
constexpr uint8_t val2bitToGray(uint8_t val2bit) { return val2bit * 85; }

// Letterbox fill data: one average gray value per edge (top/bottom or left/right).
struct LetterboxFillData {
  uint8_t avgA = 128;       // average gray of edge A (top or left)
  uint8_t avgB = 128;       // average gray of edge B (bottom or right)
  int letterboxA = 0;       // pixel size of the first letterbox area (top or left)
  int letterboxB = 0;       // pixel size of the second letterbox area (bottom or right)
  bool horizontal = false;  // true = top/bottom letterbox, false = left/right
  bool valid = false;
};

// Snap an 8-bit gray value to the nearest of the 4 e-ink levels: 0, 85, 170, 255.
uint8_t snapToEinkLevel(uint8_t gray) {
  // Thresholds at midpoints: 42, 127, 212
  if (gray < 43) return 0;
  if (gray < 128) return 85;
  if (gray < 213) return 170;
  return 255;
}

// 4x4 Bayer ordered dithering matrix, values 0-255.
// Produces a structured halftone pattern for 4-level quantization.
// clang-format off
constexpr uint8_t BAYER_4X4[4][4] = {
  {  0, 128,  32, 160},
  {192,  64, 224,  96},
  { 48, 176,  16, 144},
  {240, 112, 208,  80}
};
// clang-format on

// Ordered (Bayer) dithering for 4-level e-ink display.
// Maps an 8-bit gray value to a 2-bit level (0-3) using the Bayer matrix
// to produce a structured, repeating halftone pattern.
uint8_t quantizeBayerDither(int gray, int x, int y) {
  const int threshold = BAYER_4X4[y & 3][x & 3];
  const int scaled = gray * 3;
  if (scaled < 255) {
    return (scaled + threshold >= 255) ? 1 : 0;
  } else if (scaled < 510) {
    return ((scaled - 255) + threshold >= 255) ? 2 : 1;
  } else {
    return ((scaled - 510) + threshold >= 255) ? 3 : 2;
  }
}

// Check whether a gray value would produce a dithered mix that crosses the
// level-2 / level-3 boundary.  This is the ONLY boundary where some dithered
// pixels are BLACK (level ≤ 2) and others are WHITE (level 3) in the BW pass,
// creating a high-frequency checkerboard that causes e-ink display crosstalk
// and washes out adjacent content during HALF_REFRESH.
// Gray values 171-254 produce a level-2/level-3 mix via Bayer dithering.
bool bayerCrossesBwBoundary(uint8_t gray) {
  return gray > 170 && gray < 255;
}

// Hash-based block dithering for BW-boundary gray values (171-254).
// Each blockSize×blockSize pixel block gets a single uniform level (2 or 3),
// determined by a deterministic spatial hash.  The proportion of level-3 blocks
// approximates the target gray.  Unlike Bayer, the pattern is irregular
// (noise-like), making it much less visually obvious at the same block size.
// The hash is purely spatial (depends only on x, y, blockSize) so it produces
// identical levels across BW, LSB, and MSB render passes.
static constexpr int BW_DITHER_BLOCK = 2;

uint8_t hashBlockDither(uint8_t avg, int x, int y) {
  const int bx = x / BW_DITHER_BLOCK;
  const int by = y / BW_DITHER_BLOCK;
  // Fast mixing hash (splitmix32-inspired)
  uint32_t h = (uint32_t)bx * 2654435761u ^ (uint32_t)by * 2246822519u;
  h ^= h >> 16;
  h *= 0x45d9f3bu;
  h ^= h >> 16;
  // Proportion of level-3 blocks needed to approximate the target gray
  const float ratio = (avg - 170.0f) / 85.0f;
  const uint32_t threshold = (uint32_t)(ratio * 4294967295.0f);
  return (h < threshold) ? 3 : 2;
}

// --- Edge average cache ---
// Caches the computed edge averages alongside the cover BMP so we don't rescan on every sleep.
constexpr uint8_t EDGE_CACHE_VERSION = 2;

bool loadEdgeCache(const std::string& path, int screenWidth, int screenHeight, LetterboxFillData& data) {
  FsFile file;
  if (!Storage.openFileForRead("SLP", path, file)) return false;

  uint8_t version;
  serialization::readPod(file, version);
  if (version != EDGE_CACHE_VERSION) {
    file.close();
    return false;
  }

  uint16_t cachedW, cachedH;
  serialization::readPod(file, cachedW);
  serialization::readPod(file, cachedH);
  if (cachedW != static_cast<uint16_t>(screenWidth) || cachedH != static_cast<uint16_t>(screenHeight)) {
    file.close();
    return false;
  }

  uint8_t horizontal;
  serialization::readPod(file, horizontal);
  data.horizontal = (horizontal != 0);

  serialization::readPod(file, data.avgA);
  serialization::readPod(file, data.avgB);

  int16_t lbA, lbB;
  serialization::readPod(file, lbA);
  serialization::readPod(file, lbB);
  data.letterboxA = lbA;
  data.letterboxB = lbB;

  file.close();
  data.valid = true;
  Serial.printf("[%lu] [SLP] Loaded edge cache from %s (avgA=%d, avgB=%d)\n", millis(), path.c_str(), data.avgA,
                data.avgB);
  return true;
}

bool saveEdgeCache(const std::string& path, int screenWidth, int screenHeight, const LetterboxFillData& data) {
  if (!data.valid) return false;

  FsFile file;
  if (!Storage.openFileForWrite("SLP", path, file)) return false;

  serialization::writePod(file, EDGE_CACHE_VERSION);
  serialization::writePod(file, static_cast<uint16_t>(screenWidth));
  serialization::writePod(file, static_cast<uint16_t>(screenHeight));
  serialization::writePod(file, static_cast<uint8_t>(data.horizontal ? 1 : 0));
  serialization::writePod(file, data.avgA);
  serialization::writePod(file, data.avgB);
  serialization::writePod(file, static_cast<int16_t>(data.letterboxA));
  serialization::writePod(file, static_cast<int16_t>(data.letterboxB));
  file.close();

  Serial.printf("[%lu] [SLP] Saved edge cache to %s\n", millis(), path.c_str());
  return true;
}

// Read the bitmap once to compute a single average gray value for the top/bottom or left/right edges.
// Only computes running sums -- no per-pixel arrays, no malloc beyond row buffers.
// After sampling the bitmap is rewound via rewindToData().
LetterboxFillData computeEdgeAverages(const Bitmap& bitmap, int imgX, int imgY, int pageWidth, int pageHeight,
                                      float scale, float cropX, float cropY) {
  LetterboxFillData data;

  const int cropPixX = static_cast<int>(std::floor(bitmap.getWidth() * cropX / 2.0f));
  const int cropPixY = static_cast<int>(std::floor(bitmap.getHeight() * cropY / 2.0f));
  const int visibleWidth = bitmap.getWidth() - 2 * cropPixX;
  const int visibleHeight = bitmap.getHeight() - 2 * cropPixY;

  if (visibleWidth <= 0 || visibleHeight <= 0) return data;

  const int outputRowSize = (bitmap.getWidth() + 3) / 4;
  auto* outputRow = static_cast<uint8_t*>(malloc(outputRowSize));
  auto* rowBytes = static_cast<uint8_t*>(malloc(bitmap.getRowBytes()));
  if (!outputRow || !rowBytes) {
    free(outputRow);
    free(rowBytes);
    return data;
  }

  if (imgY > 0) {
    // Top/bottom letterboxing -- compute overall average of first/last EDGE_SAMPLE_DEPTH rows
    data.horizontal = true;
    const int scaledHeight = static_cast<int>(std::round(static_cast<float>(visibleHeight) * scale));
    data.letterboxA = imgY;
    data.letterboxB = pageHeight - imgY - scaledHeight;
    if (data.letterboxB < 0) data.letterboxB = 0;

    const int sampleRows = std::min(EDGE_SAMPLE_DEPTH, visibleHeight);
    uint64_t sumTop = 0, sumBot = 0;
    int countTop = 0, countBot = 0;

    for (int bmpY = 0; bmpY < bitmap.getHeight(); bmpY++) {
      if (bitmap.readNextRow(outputRow, rowBytes) != BmpReaderError::Ok) break;
      const int logicalY = bitmap.isTopDown() ? bmpY : bitmap.getHeight() - 1 - bmpY;
      if (logicalY < cropPixY || logicalY >= bitmap.getHeight() - cropPixY) continue;
      const int outY = logicalY - cropPixY;

      const bool inTop = (outY < sampleRows);
      const bool inBot = (outY >= visibleHeight - sampleRows);
      if (!inTop && !inBot) continue;

      for (int bmpX = cropPixX; bmpX < bitmap.getWidth() - cropPixX; bmpX++) {
        const uint8_t val = (outputRow[bmpX / 4] >> (6 - ((bmpX * 2) % 8))) & 0x3;
        const uint8_t gray = val2bitToGray(val);
        if (inTop) {
          sumTop += gray;
          countTop++;
        }
        if (inBot) {
          sumBot += gray;
          countBot++;
        }
      }
    }

    data.avgA = countTop > 0 ? static_cast<uint8_t>(sumTop / countTop) : 128;
    data.avgB = countBot > 0 ? static_cast<uint8_t>(sumBot / countBot) : 128;
    data.valid = true;
  } else if (imgX > 0) {
    // Left/right letterboxing -- compute overall average of first/last EDGE_SAMPLE_DEPTH columns
    data.horizontal = false;
    const int scaledWidth = static_cast<int>(std::round(static_cast<float>(visibleWidth) * scale));
    data.letterboxA = imgX;
    data.letterboxB = pageWidth - imgX - scaledWidth;
    if (data.letterboxB < 0) data.letterboxB = 0;

    const int sampleCols = std::min(EDGE_SAMPLE_DEPTH, visibleWidth);
    uint64_t sumLeft = 0, sumRight = 0;
    int countLeft = 0, countRight = 0;

    for (int bmpY = 0; bmpY < bitmap.getHeight(); bmpY++) {
      if (bitmap.readNextRow(outputRow, rowBytes) != BmpReaderError::Ok) break;
      const int logicalY = bitmap.isTopDown() ? bmpY : bitmap.getHeight() - 1 - bmpY;
      if (logicalY < cropPixY || logicalY >= bitmap.getHeight() - cropPixY) continue;

      for (int bmpX = cropPixX; bmpX < cropPixX + sampleCols; bmpX++) {
        const uint8_t val = (outputRow[bmpX / 4] >> (6 - ((bmpX * 2) % 8))) & 0x3;
        sumLeft += val2bitToGray(val);
        countLeft++;
      }
      for (int bmpX = bitmap.getWidth() - cropPixX - sampleCols; bmpX < bitmap.getWidth() - cropPixX; bmpX++) {
        const uint8_t val = (outputRow[bmpX / 4] >> (6 - ((bmpX * 2) % 8))) & 0x3;
        sumRight += val2bitToGray(val);
        countRight++;
      }
    }

    data.avgA = countLeft > 0 ? static_cast<uint8_t>(sumLeft / countLeft) : 128;
    data.avgB = countRight > 0 ? static_cast<uint8_t>(sumRight / countRight) : 128;
    data.valid = true;
  }

  bitmap.rewindToData();
  free(outputRow);
  free(rowBytes);
  return data;
}

// Draw letterbox fill in the areas around the cover image.
// DITHERED: fills with the edge average using Bayer ordered dithering to approximate the color.
// SOLID: snaps edge average to nearest e-ink level (0/85/170/255) for a clean uniform fill.
// Must be called once per render pass (BW, GRAYSCALE_LSB, GRAYSCALE_MSB).
void drawLetterboxFill(GfxRenderer& renderer, const LetterboxFillData& data, uint8_t fillMode) {
  if (!data.valid) return;

  const bool isSolid = (fillMode == CrossPointSettings::SLEEP_SCREEN_LETTERBOX_FILL::LETTERBOX_SOLID);

  // For DITHERED mode with gray values in 171-254 (the level-2/level-3 BW boundary):
  // Pixel-level Bayer dithering creates a regular high-frequency checkerboard in
  // the BW pass that causes e-ink display crosstalk during HALF_REFRESH.
  //
  // Solution: HASH-BASED BLOCK DITHERING.  Each 2x2 pixel block gets a single
  // level (2 or 3) determined by a spatial hash, with the proportion of level-3
  // blocks tuned to approximate the target gray.  The 2px minimum run avoids BW
  // crosstalk, and the irregular hash pattern is much less visible than a regular
  // Bayer grid at the same block size.
  const bool hashA = !isSolid && bayerCrossesBwBoundary(data.avgA);
  const bool hashB = !isSolid && bayerCrossesBwBoundary(data.avgB);

  // For solid mode: snap to nearest e-ink level
  const uint8_t levelA = isSolid ? snapToEinkLevel(data.avgA) / 85 : 0;
  const uint8_t levelB = isSolid ? snapToEinkLevel(data.avgB) / 85 : 0;

  if (data.horizontal) {
    if (data.letterboxA > 0) {
      for (int y = 0; y < data.letterboxA; y++)
        for (int x = 0; x < renderer.getScreenWidth(); x++) {
          uint8_t lv;
          if (isSolid)      lv = levelA;
          else if (hashA)   lv = hashBlockDither(data.avgA, x, y);
          else              lv = quantizeBayerDither(data.avgA, x, y);
          renderer.drawPixelGray(x, y, lv);
        }
    }
    if (data.letterboxB > 0) {
      const int start = renderer.getScreenHeight() - data.letterboxB;
      for (int y = start; y < renderer.getScreenHeight(); y++)
        for (int x = 0; x < renderer.getScreenWidth(); x++) {
          uint8_t lv;
          if (isSolid)      lv = levelB;
          else if (hashB)   lv = hashBlockDither(data.avgB, x, y);
          else              lv = quantizeBayerDither(data.avgB, x, y);
          renderer.drawPixelGray(x, y, lv);
        }
    }
  } else {
    if (data.letterboxA > 0) {
      for (int x = 0; x < data.letterboxA; x++)
        for (int y = 0; y < renderer.getScreenHeight(); y++) {
          uint8_t lv;
          if (isSolid)      lv = levelA;
          else if (hashA)   lv = hashBlockDither(data.avgA, x, y);
          else              lv = quantizeBayerDither(data.avgA, x, y);
          renderer.drawPixelGray(x, y, lv);
        }
    }
    if (data.letterboxB > 0) {
      const int start = renderer.getScreenWidth() - data.letterboxB;
      for (int x = start; x < renderer.getScreenWidth(); x++)
        for (int y = 0; y < renderer.getScreenHeight(); y++) {
          uint8_t lv;
          if (isSolid)      lv = levelB;
          else if (hashB)   lv = hashBlockDither(data.avgB, x, y);
          else              lv = quantizeBayerDither(data.avgB, x, y);
          renderer.drawPixelGray(x, y, lv);
        }
    }
  }
}

}  // namespace

void SleepActivity::onEnter() {
  Activity::onEnter();
  GUI.drawPopup(renderer, "Entering Sleep...");

  switch (SETTINGS.sleepScreen) {
    case (CrossPointSettings::SLEEP_SCREEN_MODE::BLANK):
      return renderBlankSleepScreen();
    case (CrossPointSettings::SLEEP_SCREEN_MODE::CUSTOM):
      return renderCustomSleepScreen();
    case (CrossPointSettings::SLEEP_SCREEN_MODE::COVER):
    case (CrossPointSettings::SLEEP_SCREEN_MODE::COVER_CUSTOM):
      return renderCoverSleepScreen();
    default:
      return renderDefaultSleepScreen();
  }
}

void SleepActivity::renderCustomSleepScreen() const {
  // Check if we have a /sleep directory
  auto dir = Storage.open("/sleep");
  if (dir && dir.isDirectory()) {
    std::vector<std::string> files;
    char name[500];
    // collect all valid BMP files
    for (auto file = dir.openNextFile(); file; file = dir.openNextFile()) {
      if (file.isDirectory()) {
        file.close();
        continue;
      }
      file.getName(name, sizeof(name));
      auto filename = std::string(name);
      if (filename[0] == '.') {
        file.close();
        continue;
      }

      if (filename.substr(filename.length() - 4) != ".bmp") {
        Serial.printf("[%lu] [SLP] Skipping non-.bmp file name: %s\n", millis(), name);
        file.close();
        continue;
      }
      Bitmap bitmap(file);
      if (bitmap.parseHeaders() != BmpReaderError::Ok) {
        Serial.printf("[%lu] [SLP] Skipping invalid BMP file: %s\n", millis(), name);
        file.close();
        continue;
      }
      files.emplace_back(filename);
      file.close();
    }
    const auto numFiles = files.size();
    if (numFiles > 0) {
      // Generate a random number between 1 and numFiles
      auto randomFileIndex = random(numFiles);
      // If we picked the same image as last time, reroll
      while (numFiles > 1 && randomFileIndex == APP_STATE.lastSleepImage) {
        randomFileIndex = random(numFiles);
      }
      APP_STATE.lastSleepImage = randomFileIndex;
      APP_STATE.saveToFile();
      const auto filename = "/sleep/" + files[randomFileIndex];
      FsFile file;
      if (Storage.openFileForRead("SLP", filename, file)) {
        Serial.printf("[%lu] [SLP] Randomly loading: /sleep/%s\n", millis(), files[randomFileIndex].c_str());
        delay(100);
        Bitmap bitmap(file, true);
        if (bitmap.parseHeaders() == BmpReaderError::Ok) {
          renderBitmapSleepScreen(bitmap);
          dir.close();
          return;
        }
      }
    }
  }
  if (dir) dir.close();

  // Look for sleep.bmp on the root of the sd card to determine if we should
  // render a custom sleep screen instead of the default.
  FsFile file;
  if (Storage.openFileForRead("SLP", "/sleep.bmp", file)) {
    Bitmap bitmap(file, true);
    if (bitmap.parseHeaders() == BmpReaderError::Ok) {
      Serial.printf("[%lu] [SLP] Loading: /sleep.bmp\n", millis());
      renderBitmapSleepScreen(bitmap);
      return;
    }
  }

  renderDefaultSleepScreen();
}

void SleepActivity::renderDefaultSleepScreen() const {
  const auto pageWidth = renderer.getScreenWidth();
  const auto pageHeight = renderer.getScreenHeight();

  renderer.clearScreen();
  renderer.drawImage(Logo120, (pageWidth - 120) / 2, (pageHeight - 120) / 2, 120, 120);
  renderer.drawCenteredText(UI_10_FONT_ID, pageHeight / 2 + 70, "CrossPoint", true, EpdFontFamily::BOLD);
  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight / 2 + 95, "SLEEPING");

  // Make sleep screen dark unless light is selected in settings
  if (SETTINGS.sleepScreen != CrossPointSettings::SLEEP_SCREEN_MODE::LIGHT) {
    renderer.invertScreen();
  }

  renderer.displayBuffer(HalDisplay::HALF_REFRESH);
}

void SleepActivity::renderBitmapSleepScreen(const Bitmap& bitmap, const std::string& edgeCachePath) const {
  int x, y;
  const auto pageWidth = renderer.getScreenWidth();
  const auto pageHeight = renderer.getScreenHeight();
  float cropX = 0, cropY = 0;

  Serial.printf("[%lu] [SLP] bitmap %d x %d, screen %d x %d\n", millis(), bitmap.getWidth(), bitmap.getHeight(),
                pageWidth, pageHeight);

  // Always compute aspect-ratio-preserving scale and position (supports both larger and smaller images)
  float ratio = static_cast<float>(bitmap.getWidth()) / static_cast<float>(bitmap.getHeight());
  const float screenRatio = static_cast<float>(pageWidth) / static_cast<float>(pageHeight);

  Serial.printf("[%lu] [SLP] bitmap ratio: %f, screen ratio: %f\n", millis(), ratio, screenRatio);
  if (ratio > screenRatio) {
    // image wider than viewport ratio, needs to be centered vertically
    if (SETTINGS.sleepScreenCoverMode == CrossPointSettings::SLEEP_SCREEN_COVER_MODE::CROP) {
      cropX = 1.0f - (screenRatio / ratio);
      Serial.printf("[%lu] [SLP] Cropping bitmap x: %f\n", millis(), cropX);
      ratio = (1.0f - cropX) * static_cast<float>(bitmap.getWidth()) / static_cast<float>(bitmap.getHeight());
    }
    x = 0;
    y = std::round((static_cast<float>(pageHeight) - static_cast<float>(pageWidth) / ratio) / 2);
    Serial.printf("[%lu] [SLP] Centering with ratio %f to y=%d\n", millis(), ratio, y);
  } else {
    // image taller than or equal to viewport ratio, needs to be centered horizontally
    if (SETTINGS.sleepScreenCoverMode == CrossPointSettings::SLEEP_SCREEN_COVER_MODE::CROP) {
      cropY = 1.0f - (ratio / screenRatio);
      Serial.printf("[%lu] [SLP] Cropping bitmap y: %f\n", millis(), cropY);
      ratio = static_cast<float>(bitmap.getWidth()) / ((1.0f - cropY) * static_cast<float>(bitmap.getHeight()));
    }
    x = std::round((static_cast<float>(pageWidth) - static_cast<float>(pageHeight) * ratio) / 2);
    y = 0;
    Serial.printf("[%lu] [SLP] Centering with ratio %f to x=%d\n", millis(), ratio, x);
  }

  Serial.printf("[%lu] [SLP] drawing to %d x %d\n", millis(), x, y);

  // Compute the scale factor (same formula as drawBitmap) so we can map screen coords to source coords
  const float effectiveWidth = (1.0f - cropX) * bitmap.getWidth();
  const float effectiveHeight = (1.0f - cropY) * bitmap.getHeight();
  const float scale =
      std::min(static_cast<float>(pageWidth) / effectiveWidth, static_cast<float>(pageHeight) / effectiveHeight);

  // Determine letterbox fill settings
  const uint8_t fillMode = SETTINGS.sleepScreenLetterboxFill;
  const bool wantFill = (fillMode != CrossPointSettings::SLEEP_SCREEN_LETTERBOX_FILL::LETTERBOX_NONE);

  static const char* fillModeNames[] = {"dithered", "solid", "none"};
  const char* fillModeName = (fillMode < 3) ? fillModeNames[fillMode] : "unknown";

  // Compute edge averages if letterbox fill is requested (try cache first)
  LetterboxFillData fillData;
  const bool hasLetterbox = (x > 0 || y > 0);
  if (hasLetterbox && wantFill) {
    bool cacheLoaded = false;
    if (!edgeCachePath.empty()) {
      cacheLoaded = loadEdgeCache(edgeCachePath, pageWidth, pageHeight, fillData);
    }
    if (!cacheLoaded) {
      Serial.printf("[%lu] [SLP] Letterbox detected (x=%d, y=%d), computing edge averages for %s fill\n", millis(), x,
                    y, fillModeName);
      fillData = computeEdgeAverages(bitmap, x, y, pageWidth, pageHeight, scale, cropX, cropY);
      if (fillData.valid && !edgeCachePath.empty()) {
        saveEdgeCache(edgeCachePath, pageWidth, pageHeight, fillData);
      }
    }
    if (fillData.valid) {
      Serial.printf("[%lu] [SLP] Letterbox fill: %s, horizontal=%d, avgA=%d, avgB=%d, letterboxA=%d, letterboxB=%d\n",
                    millis(), fillModeName, fillData.horizontal, fillData.avgA, fillData.avgB, fillData.letterboxA,
                    fillData.letterboxB);
    }
  }

  renderer.clearScreen();

  const bool hasGreyscale = bitmap.hasGreyscale() &&
                            SETTINGS.sleepScreenCoverFilter == CrossPointSettings::SLEEP_SCREEN_COVER_FILTER::NO_FILTER;

  // Draw letterbox fill (BW pass)
  if (fillData.valid) {
    drawLetterboxFill(renderer, fillData, fillMode);
  }

  renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight, cropX, cropY);

  if (SETTINGS.sleepScreenCoverFilter == CrossPointSettings::SLEEP_SCREEN_COVER_FILTER::INVERTED_BLACK_AND_WHITE) {
    renderer.invertScreen();
  }

  renderer.displayBuffer(HalDisplay::HALF_REFRESH);

  if (hasGreyscale) {
    bitmap.rewindToData();
    renderer.clearScreen(0x00);
    renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
    if (fillData.valid) {
      drawLetterboxFill(renderer, fillData, fillMode);
    }
    renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight, cropX, cropY);
    renderer.copyGrayscaleLsbBuffers();

    bitmap.rewindToData();
    renderer.clearScreen(0x00);
    renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB);
    if (fillData.valid) {
      drawLetterboxFill(renderer, fillData, fillMode);
    }
    renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight, cropX, cropY);
    renderer.copyGrayscaleMsbBuffers();

    renderer.displayGrayBuffer();
    renderer.setRenderMode(GfxRenderer::BW);
  }
}

void SleepActivity::renderCoverSleepScreen() const {
  void (SleepActivity::*renderNoCoverSleepScreen)() const;
  switch (SETTINGS.sleepScreen) {
    case (CrossPointSettings::SLEEP_SCREEN_MODE::COVER_CUSTOM):
      renderNoCoverSleepScreen = &SleepActivity::renderCustomSleepScreen;
      break;
    default:
      renderNoCoverSleepScreen = &SleepActivity::renderDefaultSleepScreen;
      break;
  }

  if (APP_STATE.openEpubPath.empty()) {
    return (this->*renderNoCoverSleepScreen)();
  }

  std::string coverBmpPath;
  bool cropped = SETTINGS.sleepScreenCoverMode == CrossPointSettings::SLEEP_SCREEN_COVER_MODE::CROP;

  // Check if the current book is XTC, TXT, or EPUB
  if (StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".xtc") ||
      StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".xtch")) {
    // Handle XTC file
    Xtc lastXtc(APP_STATE.openEpubPath, "/.crosspoint");
    if (!lastXtc.load()) {
      Serial.printf("[%lu] [SLP] Failed to load last XTC\n", millis());
      return (this->*renderNoCoverSleepScreen)();
    }

    if (!lastXtc.generateCoverBmp()) {
      Serial.printf("[%lu] [SLP] Failed to generate XTC cover bmp\n", millis());
      return (this->*renderNoCoverSleepScreen)();
    }

    coverBmpPath = lastXtc.getCoverBmpPath();
  } else if (StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".txt")) {
    // Handle TXT file - looks for cover image in the same folder
    Txt lastTxt(APP_STATE.openEpubPath, "/.crosspoint");
    if (!lastTxt.load()) {
      Serial.printf("[%lu] [SLP] Failed to load last TXT\n", millis());
      return (this->*renderNoCoverSleepScreen)();
    }

    if (!lastTxt.generateCoverBmp()) {
      Serial.printf("[%lu] [SLP] No cover image found for TXT file\n", millis());
      return (this->*renderNoCoverSleepScreen)();
    }

    coverBmpPath = lastTxt.getCoverBmpPath();
  } else if (StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".epub")) {
    // Handle EPUB file
    Epub lastEpub(APP_STATE.openEpubPath, "/.crosspoint");
    // Skip loading css since we only need metadata here
    if (!lastEpub.load(true, true)) {
      Serial.printf("[%lu] [SLP] Failed to load last epub\n", millis());
      return (this->*renderNoCoverSleepScreen)();
    }

    if (!lastEpub.generateCoverBmp(cropped)) {
      Serial.printf("[%lu] [SLP] Failed to generate cover bmp\n", millis());
      return (this->*renderNoCoverSleepScreen)();
    }

    coverBmpPath = lastEpub.getCoverBmpPath(cropped);
  } else {
    return (this->*renderNoCoverSleepScreen)();
  }

  FsFile file;
  if (Storage.openFileForRead("SLP", coverBmpPath, file)) {
    Bitmap bitmap(file);
    if (bitmap.parseHeaders() == BmpReaderError::Ok) {
      Serial.printf("[%lu] [SLP] Rendering sleep cover: %s\n", millis(), coverBmpPath.c_str());
      // Derive edge cache path from cover BMP path (e.g. cover.bmp -> cover_edges.bin)
      std::string edgeCachePath;
      const auto dotPos = coverBmpPath.rfind(".bmp");
      if (dotPos != std::string::npos) {
        edgeCachePath = coverBmpPath.substr(0, dotPos) + "_edges.bin";
      }
      renderBitmapSleepScreen(bitmap, edgeCachePath);
      return;
    }
  }

  return (this->*renderNoCoverSleepScreen)();
}

void SleepActivity::renderBlankSleepScreen() const {
  renderer.clearScreen();
  renderer.displayBuffer(HalDisplay::HALF_REFRESH);
}