logging.cpp

// Copyright (c) 2025 Yasushi
// Licensed under the MIT License. See LICENSE for details.

#include "logging.h"

#include <cstring>

static SerialDisplayLogger gLogger(Serial);
static SemaphoreHandle_t gDisplayMutex = nullptr;

SerialDisplayLogger::SerialDisplayLogger(HardwareSerial& serial)
    : serial_(serial) {}

void SerialDisplayLogger::begin(unsigned long baud) {
  serial_.begin(baud);
  if (!queue_) {
    queue_ = xQueueCreate(LOG_QUEUE_LENGTH, sizeof(LogLine));
    xTaskCreatePinnedToCore(taskEntry, "LogTask", 4096, this, 1, &taskHandle_,
                            0);
  }
}

void SerialDisplayLogger::enableDisplayOutput() {
  displayEnabled_ = true;
  if (logAreaHeight_ <= 0) {
    logAreaHeight_ = M5.Display.height();
  }
  redrawDisplay();
}

void SerialDisplayLogger::setLogAreaHeight(int height) {
  logAreaHeight_ = height;
}

void SerialDisplayLogger::setDisplayMutex(SemaphoreHandle_t mutex) {
  displayMutex_ = mutex;
}

size_t SerialDisplayLogger::write(uint8_t c) {
  if (c == '\r') return 1;
  if (c == '\n') {
    enqueueLine(currentLine_.c_str());
    currentLine_.clear();
  } else {
    if (currentLine_.length() >= LOG_LINE_MAX - 1) {
      enqueueLine(currentLine_.c_str());
      currentLine_.clear();
    }
    currentLine_ += static_cast<char>(c);
  }
  return 1;
}

void SerialDisplayLogger::taskEntry(void* arg) {
  reinterpret_cast<SerialDisplayLogger*>(arg)->processQueue();
}

void SerialDisplayLogger::processQueue() {
  LogLine line;
  while (true) {
    if (xQueueReceive(queue_, &line, portMAX_DELAY) == pdTRUE) {
      serial_.println(line.text);
      if (displayEnabled_) {
        pushLine(line.text);
        redrawDisplay();
      }
    }
  }
}

void SerialDisplayLogger::enqueueLine(const char* text) {
  if (!queue_) return;
  LogLine line = {};
  size_t len = strlen(text);
  if (len >= LOG_LINE_MAX) len = LOG_LINE_MAX - 1;
  memcpy(line.text, text, len);
  line.text[len] = '\0';
  if (xQueueSend(queue_, &line, 0) != pdTRUE) {
    // queue full -> drop oldest then retry
    LogLine dropped;
    xQueueReceive(queue_, &dropped, 0);
    xQueueSend(queue_, &line, 0);
  }
}

void SerialDisplayLogger::pushLine(const char* line) {
  lines_.push_back(String(line));
  if (lines_.size() > MAX_LOG_LINES) {
    lines_.erase(lines_.begin());
  }
}

void SerialDisplayLogger::redrawDisplay() {
  if (logAreaHeight_ <= 0) {
    logAreaHeight_ = M5.Display.height();
  }
  if (!displayMutex_ || xSemaphoreTake(displayMutex_, portMAX_DELAY) == pdTRUE) {
    M5.Display.fillRect(0, 0, M5.Display.width(), logAreaHeight_,
                        LOG_BG_COLOR);
    M5.Display.setTextColor(LOG_TEXT_COLOR);
    M5.Display.setCursor(0, 0);
    M5.Display.setTextWrap(true);
    for (const auto& line : lines_) {
      M5.Display.println(line);
    }
    if (displayMutex_) xSemaphoreGive(displayMutex_);
  }
}

namespace Logging {

void begin(unsigned long baud) {
  if (!gDisplayMutex) {
    gDisplayMutex = xSemaphoreCreateMutex();
  }
  gLogger.setDisplayMutex(gDisplayMutex);
  gLogger.begin(baud);
}

void setLogAreaHeight(int height) {
  gLogger.setLogAreaHeight(height);
}

void enableDisplayOutput() {
  gLogger.enableDisplayOutput();
}

SerialDisplayLogger& logger() { return gLogger; }

SemaphoreHandle_t displayMutex() { return gDisplayMutex; }

}  // namespace Logging