crosspoint-reader/lib/Epub/Epub/Section.cpp

#include "Section.h"

#include <SDCardManager.h>
#include <Serialization.h>

#include "Page.h"
#include "hyphenation/Hyphenator.h"
#include "parsers/ChapterHtmlSlimParser.h"

namespace {
// Version 12: Added content offsets to LUT for position restoration after re-indexing
constexpr uint8_t SECTION_FILE_VERSION = 12;
constexpr uint32_t HEADER_SIZE = sizeof(uint8_t) + sizeof(int) + sizeof(float) + sizeof(bool) + sizeof(uint8_t) +
                                 sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(bool) +
                                 sizeof(uint32_t);

// LUT entry structure: { filePosition, contentOffset }
// Each entry is 8 bytes (2 x uint32_t)
constexpr size_t LUT_ENTRY_SIZE = sizeof(uint32_t) * 2;
}  // namespace

uint32_t Section::onPageComplete(std::unique_ptr<Page> page) {
  if (!file) {
    Serial.printf("[%lu] [SCT] File not open for writing page %d\n", millis(), pageCount);
    return 0;
  }

  const uint32_t position = file.position();
  if (!page->serialize(file)) {
    Serial.printf("[%lu] [SCT] Failed to serialize page %d\n", millis(), pageCount);
    return 0;
  }
  Serial.printf("[%lu] [SCT] Page %d processed\n", millis(), pageCount);

  pageCount++;
  return position;
}

void Section::writeSectionFileHeader(const int fontId, const float lineCompression, const bool extraParagraphSpacing,
                                     const uint8_t paragraphAlignment, const uint16_t viewportWidth,
                                     const uint16_t viewportHeight, const bool hyphenationEnabled) {
  if (!file) {
    Serial.printf("[%lu] [SCT] File not open for writing header\n", millis());
    return;
  }
  static_assert(HEADER_SIZE == sizeof(SECTION_FILE_VERSION) + sizeof(fontId) + sizeof(lineCompression) +
                                   sizeof(extraParagraphSpacing) + sizeof(paragraphAlignment) + sizeof(viewportWidth) +
                                   sizeof(viewportHeight) + sizeof(pageCount) + sizeof(hyphenationEnabled) +
                                   sizeof(uint32_t),
                "Header size mismatch");
  serialization::writePod(file, SECTION_FILE_VERSION);
  serialization::writePod(file, fontId);
  serialization::writePod(file, lineCompression);
  serialization::writePod(file, extraParagraphSpacing);
  serialization::writePod(file, paragraphAlignment);
  serialization::writePod(file, viewportWidth);
  serialization::writePod(file, viewportHeight);
  serialization::writePod(file, hyphenationEnabled);
  serialization::writePod(file, pageCount);  // Placeholder for page count (will be initially 0 when written)
  serialization::writePod(file, static_cast<uint32_t>(0));  // Placeholder for LUT offset
}

bool Section::loadSectionFile(const int fontId, const float lineCompression, const bool extraParagraphSpacing,
                              const uint8_t paragraphAlignment, const uint16_t viewportWidth,
                              const uint16_t viewportHeight, const bool hyphenationEnabled) {
  if (!SdMan.openFileForRead("SCT", filePath, file)) {
    return false;
  }

  // Match parameters
  {
    uint8_t version;
    serialization::readPod(file, version);
    if (version != SECTION_FILE_VERSION) {
      file.close();
      Serial.printf("[%lu] [SCT] Deserialization failed: Unknown version %u\n", millis(), version);
      clearCache();
      return false;
    }

    int fileFontId;
    uint16_t fileViewportWidth, fileViewportHeight;
    float fileLineCompression;
    bool fileExtraParagraphSpacing;
    uint8_t fileParagraphAlignment;
    bool fileHyphenationEnabled;
    serialization::readPod(file, fileFontId);
    serialization::readPod(file, fileLineCompression);
    serialization::readPod(file, fileExtraParagraphSpacing);
    serialization::readPod(file, fileParagraphAlignment);
    serialization::readPod(file, fileViewportWidth);
    serialization::readPod(file, fileViewportHeight);
    serialization::readPod(file, fileHyphenationEnabled);

    if (fontId != fileFontId || lineCompression != fileLineCompression ||
        extraParagraphSpacing != fileExtraParagraphSpacing || paragraphAlignment != fileParagraphAlignment ||
        viewportWidth != fileViewportWidth || viewportHeight != fileViewportHeight ||
        hyphenationEnabled != fileHyphenationEnabled) {
      file.close();
      Serial.printf("[%lu] [SCT] Deserialization failed: Parameters do not match\n", millis());
      clearCache();
      return false;
    }
  }

  serialization::readPod(file, pageCount);
  file.close();
  Serial.printf("[%lu] [SCT] Deserialization succeeded: %d pages\n", millis(), pageCount);
  return true;
}

// Your updated class method (assuming you are using the 'SD' object, which is a wrapper for a specific filesystem)
bool Section::clearCache() const {
  if (!SdMan.exists(filePath.c_str())) {
    Serial.printf("[%lu] [SCT] Cache does not exist, no action needed\n", millis());
    return true;
  }

  if (!SdMan.remove(filePath.c_str())) {
    Serial.printf("[%lu] [SCT] Failed to clear cache\n", millis());
    return false;
  }

  Serial.printf("[%lu] [SCT] Cache cleared successfully\n", millis());
  return true;
}

bool Section::createSectionFile(const int fontId, const float lineCompression, const bool extraParagraphSpacing,
                                const uint8_t paragraphAlignment, const uint16_t viewportWidth,
                                const uint16_t viewportHeight, const bool hyphenationEnabled,
                                const std::function<void()>& progressSetupFn,
                                const std::function<void(int)>& progressFn) {
  constexpr uint32_t MIN_SIZE_FOR_PROGRESS = 50 * 1024;  // 50KB
  const auto localPath = epub->getSpineItem(spineIndex).href;
  const auto tmpHtmlPath = epub->getCachePath() + "/.tmp_" + std::to_string(spineIndex) + ".html";

  // Create cache directory if it doesn't exist
  {
    const auto sectionsDir = epub->getCachePath() + "/sections";
    SdMan.mkdir(sectionsDir.c_str());
  }

  // Retry logic for SD card timing issues
  bool success = false;
  uint32_t fileSize = 0;
  for (int attempt = 0; attempt < 3 && !success; attempt++) {
    if (attempt > 0) {
      Serial.printf("[%lu] [SCT] Retrying stream (attempt %d)...\n", millis(), attempt + 1);
      delay(50);  // Brief delay before retry
    }

    // Remove any incomplete file from previous attempt before retrying
    if (SdMan.exists(tmpHtmlPath.c_str())) {
      SdMan.remove(tmpHtmlPath.c_str());
    }

    FsFile tmpHtml;
    if (!SdMan.openFileForWrite("SCT", tmpHtmlPath, tmpHtml)) {
      continue;
    }
    success = epub->readItemContentsToStream(localPath, tmpHtml, 1024);
    fileSize = tmpHtml.size();
    tmpHtml.close();

    // If streaming failed, remove the incomplete file immediately
    if (!success && SdMan.exists(tmpHtmlPath.c_str())) {
      SdMan.remove(tmpHtmlPath.c_str());
      Serial.printf("[%lu] [SCT] Removed incomplete temp file after failed attempt\n", millis());
    }
  }

  if (!success) {
    Serial.printf("[%lu] [SCT] Failed to stream item contents to temp file after retries\n", millis());
    return false;
  }

  Serial.printf("[%lu] [SCT] Streamed temp HTML to %s (%d bytes)\n", millis(), tmpHtmlPath.c_str(), fileSize);

  // Only show progress bar for larger chapters where rendering overhead is worth it
  if (progressSetupFn && fileSize >= MIN_SIZE_FOR_PROGRESS) {
    progressSetupFn();
  }

  if (!SdMan.openFileForWrite("SCT", filePath, file)) {
    return false;
  }
  writeSectionFileHeader(fontId, lineCompression, extraParagraphSpacing, paragraphAlignment, viewportWidth,
                         viewportHeight, hyphenationEnabled);

  // LUT entries: { filePosition, contentOffset } pairs
  struct LutEntry {
    uint32_t filePos;
    uint32_t contentOffset;
  };
  std::vector<LutEntry> lut = {};

  ChapterHtmlSlimParser visitor(
      epub, tmpHtmlPath, renderer, fontId, lineCompression, extraParagraphSpacing, paragraphAlignment, viewportWidth,
      viewportHeight, hyphenationEnabled,
      [this, &lut](std::unique_ptr<Page> page) {
        // Capture content offset before processing
        const uint32_t contentOffset = page->firstContentOffset;
        const uint32_t filePos = this->onPageComplete(std::move(page));
        lut.push_back({filePos, contentOffset});
      },
      progressFn, epub->getCssParser());
  Hyphenator::setPreferredLanguage(epub->getLanguage());
  success = visitor.parseAndBuildPages();

  SdMan.remove(tmpHtmlPath.c_str());
  if (!success) {
    Serial.printf("[%lu] [SCT] Failed to parse XML, creating placeholder page for chapter\n", millis());
    // Create a placeholder page for malformed chapters instead of failing entirely
    // This allows the book to continue loading with chapters that do parse successfully
    auto placeholderPage = std::unique_ptr<Page>(new Page());
    placeholderPage->firstContentOffset = 0;
    // Add placeholder to LUT
    const uint32_t filePos = this->onPageComplete(std::move(placeholderPage));
    lut.push_back({filePos, 0});

    // If we still have no pages, the placeholder creation failed
    if (pageCount == 0) {
      Serial.printf("[%lu] [SCT] Failed to create placeholder page\n", millis());
      file.close();
      SdMan.remove(filePath.c_str());
      return false;
    }
  }

  const uint32_t lutOffset = file.position();
  bool hasFailedLutRecords = false;
  // Write LUT with both file position and content offset
  for (const auto& entry : lut) {
    if (entry.filePos == 0) {
      hasFailedLutRecords = true;
      break;
    }
    serialization::writePod(file, entry.filePos);
    serialization::writePod(file, entry.contentOffset);
  }

  if (hasFailedLutRecords) {
    Serial.printf("[%lu] [SCT] Failed to write LUT due to invalid page positions\n", millis());
    file.close();
    SdMan.remove(filePath.c_str());
    return false;
  }

  // Go back and write LUT offset
  file.seek(HEADER_SIZE - sizeof(uint32_t) - sizeof(pageCount));
  serialization::writePod(file, pageCount);
  serialization::writePod(file, lutOffset);
  file.close();
  return true;
}

std::unique_ptr<Page> Section::loadPageFromSectionFile() {
  if (!SdMan.openFileForRead("SCT", filePath, file)) {
    return nullptr;
  }

  file.seek(HEADER_SIZE - sizeof(uint32_t));
  uint32_t lutOffset;
  serialization::readPod(file, lutOffset);

  // LUT entries are now 8 bytes each: { filePos (4), contentOffset (4) }
  file.seek(lutOffset + LUT_ENTRY_SIZE * currentPage);
  uint32_t pagePos;
  serialization::readPod(file, pagePos);
  // Skip contentOffset for now - we don't need it when just loading the page

  file.seek(pagePos);

  auto page = Page::deserialize(file);
  file.close();
  return page;
}

int Section::findPageForContentOffset(uint32_t targetOffset) const {
  if (pageCount == 0) {
    return 0;
  }

  FsFile f;
  if (!SdMan.openFileForRead("SCT", filePath, f)) {
    Serial.printf("[%lu] [SCT] findPageForContentOffset: Failed to open file\n", millis());
    return 0;
  }

  // Read LUT offset from header
  f.seek(HEADER_SIZE - sizeof(uint32_t));
  uint32_t lutOffset;
  serialization::readPod(f, lutOffset);

  // Binary search through the LUT to find the page containing targetOffset
  // We want the largest contentOffset that is <= targetOffset
  int left = 0;
  int right = pageCount - 1;
  int result = 0;

  while (left <= right) {
    const int mid = left + (right - left) / 2;

    // Read content offset for page 'mid'
    // LUT entry format: { filePos (4), contentOffset (4) }
    f.seek(lutOffset + LUT_ENTRY_SIZE * mid + sizeof(uint32_t));  // Skip filePos
    uint32_t midOffset;
    serialization::readPod(f, midOffset);

    if (midOffset <= targetOffset) {
      result = mid;    // This page could be the answer
      left = mid + 1;  // Look for a later page that might also qualify
    } else {
      right = mid - 1;  // Look for an earlier page
    }
  }

  // When multiple pages share the same content offset (e.g., a large text
  // block spanning multiple pages), scan backward to find the FIRST page
  // with that offset, not the last
  if (result > 0) {
    f.seek(lutOffset + LUT_ENTRY_SIZE * result + sizeof(uint32_t));
    uint32_t resultOffset;
    serialization::readPod(f, resultOffset);

    while (result > 0) {
      f.seek(lutOffset + LUT_ENTRY_SIZE * (result - 1) + sizeof(uint32_t));
      uint32_t prevOffset;
      serialization::readPod(f, prevOffset);
      if (prevOffset == resultOffset) {
        result--;
      } else {
        break;
      }
    }
  }

  f.close();
  Serial.printf("[%lu] [SCT] findPageForContentOffset: offset %u -> page %d\n", millis(), targetOffset, result);
  return result;
}

uint32_t Section::getContentOffsetForPage(int pageIndex) const {
  if (pageCount == 0 || pageIndex < 0 || pageIndex >= pageCount) {
    return 0;
  }

  FsFile f;
  if (!SdMan.openFileForRead("SCT", filePath, f)) {
    Serial.printf("[%lu] [SCT] getContentOffsetForPage: Failed to open file\n", millis());
    return 0;
  }

  // Read LUT offset from header
  f.seek(HEADER_SIZE - sizeof(uint32_t));
  uint32_t lutOffset;
  serialization::readPod(f, lutOffset);

  // Read content offset for the specified page
  // LUT entry format: { filePos (4), contentOffset (4) }
  f.seek(lutOffset + LUT_ENTRY_SIZE * pageIndex + sizeof(uint32_t));  // Skip filePos
  uint32_t contentOffset;
  serialization::readPod(f, contentOffset);

  f.close();
  return contentOffset;
}