AppWeb.cpp

#include "App.h"

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "Config.h"
#include "Log.h"
#include "Platform.h"
#include "esp_system.h"
#include "esp_timer.h"
#include "esp_random.h"
#include "esp_wifi.h"

namespace {
constexpr char kRawMidiMagic[8] = {'R', 'A', 'W', 'M', 'I', 'D', '1', '\0'};
constexpr char kProvisioningApSsid[] = "ESP32-Tiny-MIDI-Setup";
constexpr uint32_t kWifiResponseGraceMs = 250;

void appendRaw(char* dst, size_t capacity, size_t& length, const char* text) {
  if (dst == nullptr || capacity == 0 || text == nullptr) {
    return;
  }
  while (*text != '\0' && length + 1 < capacity) {
    dst[length++] = *text++;
  }
  dst[length] = '\0';
}

void appendChar(char* dst, size_t capacity, size_t& length, char value) {
  if (dst == nullptr || capacity == 0 || length + 1 >= capacity) {
    return;
  }
  dst[length++] = value;
  dst[length] = '\0';
}

void appendUnsigned(char* dst, size_t capacity, size_t& length, uint32_t value) {
  char buffer[16];
  snprintf(buffer, sizeof(buffer), "%lu", static_cast<unsigned long>(value));
  appendRaw(dst, capacity, length, buffer);
}

void appendUnsigned64(char* dst, size_t capacity, size_t& length, uint64_t value) {
  // ROM nano printf does not support %llu. Keep nano formatting enabled and
  // serialize all 20 possible decimal digits without a printf dependency.
  char buffer[21];
  char* digit = buffer + sizeof(buffer) - 1;
  *digit = '\0';
  do {
    *--digit = static_cast<char>('0' + value % 10);
    value /= 10;
  } while (value != 0);
  appendRaw(dst, capacity, length, digit);
}

void appendSigned(char* dst, size_t capacity, size_t& length, int value) {
  char buffer[16];
  snprintf(buffer, sizeof(buffer), "%d", value);
  appendRaw(dst, capacity, length, buffer);
}

void appendBool(char* dst, size_t capacity, size_t& length, bool value) {
  appendRaw(dst, capacity, length, value ? "true" : "false");
}

void appendEscapedJson(char* dst, size_t capacity, size_t& length, const char* value) {
  if (dst == nullptr || capacity == 0 || value == nullptr) {
    return;
  }
  for (const char* p = value; *p != '\0' && length + 1 < capacity; ++p) {
    const char* replacement = nullptr;
    char single[2] = {*p, '\0'};
    switch (*p) {
      case '\\':
        replacement = "\\\\";
        break;
      case '"':
        replacement = "\\\"";
        break;
      case '\n':
        replacement = "\\n";
        break;
      case '\r':
        replacement = "";
        break;
      default:
        replacement = single;
        break;
    }
    appendRaw(dst, capacity, length, replacement);
  }
}

void urlDecodeInPlace(char* text) {
  if (text == nullptr) return;
  char* read = text;
  char* write = text;
  while (*read != '\0') {
    if (*read == '%' && isxdigit(
            static_cast<unsigned char>(read[1])) &&
        isxdigit(static_cast<unsigned char>(read[2]))) {
      char hex[3] = {read[1], read[2], '\0'};
      *write++ = static_cast<char>(strtoul(hex, nullptr, 16));
      read += 3;
    } else {
      *write++ = *read == '+' ? ' ' : *read;
      ++read;
    }
  }
  *write = '\0';
}

bool copyServerArg(
    httpd_req_t* request,
    const char* name,
    char* dst,
    size_t capacity) {
  if (dst == nullptr || capacity == 0) {
    return false;
  }
  dst[0] = '\0';
  if (request == nullptr || name == nullptr) {
    return false;
  }
  const size_t queryLength = httpd_req_get_url_query_len(request);
  if (queryLength == 0 || queryLength >= 256) {
    return false;
  }
  char query[256];
  // ESP-IDF returns the *encoded* value. A 17-character MAC occupies 27
  // characters with %3A separators; apply the destination limit after decode.
  char encoded[256];
  if (httpd_req_get_url_query_str(request, query, sizeof(query)) != ESP_OK ||
      httpd_query_key_value(query, name, encoded, sizeof(encoded)) != ESP_OK) {
    return false;
  }
  urlDecodeInPlace(encoded);
  const size_t length = strlen(encoded);
  if (length == 0 || length >= capacity) return false;
  memcpy(dst, encoded, length + 1);
  return true;
}

bool readRequestBody(httpd_req_t* request, char* dst, size_t capacity) {
  if (request == nullptr || dst == nullptr || capacity == 0 ||
      request->content_len == 0 || request->content_len >= capacity) {
    return false;
  }
  size_t receivedTotal = 0;
  while (receivedTotal < request->content_len) {
    const int received = httpd_req_recv(
        request, dst + receivedTotal,
        request->content_len - receivedTotal);
    if (received <= 0) return false;
    receivedTotal += static_cast<size_t>(received);
  }
  dst[receivedTotal] = '\0';
  return true;
}

bool copyFormArg(
    char* body,
    const char* name,
    char* dst,
    size_t capacity,
    bool allowEmpty) {
  if (body == nullptr || name == nullptr || dst == nullptr || capacity == 0) {
    return false;
  }
  char encoded[256];
  if (httpd_query_key_value(body, name, encoded, sizeof(encoded)) != ESP_OK) {
    return false;
  }
  urlDecodeInPlace(encoded);
  const size_t length = strlen(encoded);
  if ((!allowEmpty && length == 0) || length >= capacity) return false;
  memcpy(dst, encoded, length + 1);
  return true;
}

esp_err_t sendResponse(
    httpd_req_t* request,
    int status,
    const char* contentType,
    const char* body,
    ssize_t bodyLength = HTTPD_RESP_USE_STRLEN) {
  if (request == nullptr) return ESP_ERR_INVALID_ARG;
  if (status == 400) {
    httpd_resp_set_status(request, HTTPD_400);
  } else if (status == 404) {
    httpd_resp_set_status(request, HTTPD_404);
  } else if (status == 409) {
    httpd_resp_set_status(request, "409 Conflict");
  } else if (status == 503) {
    httpd_resp_set_status(request, "503 Service Unavailable");
  } else if (status == 500) {
    httpd_resp_set_status(request, HTTPD_500);
  }
  httpd_resp_set_type(request, contentType);
  return httpd_resp_send(request, body, bodyLength);
}

bool requestPathEquals(const httpd_req_t* request, const char* path) {
  if (request == nullptr || path == nullptr) return false;
  const size_t pathLength = strlen(path);
  return strncmp(request->uri, path, pathLength) == 0 &&
      (request->uri[pathLength] == '\0' || request->uri[pathLength] == '?');
}

#include "WebUiGzip.generated.h"

#if APP_ENABLE_DEBUG_DIAGNOSTICS
static char g_statusJsonBuffer[2048];
static char g_btDevicesJsonBuffer[768];
#else
static char g_statusJsonBuffer[1024];
static char g_btDevicesJsonBuffer[512];
#endif
static char g_httpArgAddress[24];
static char g_httpArgState[8];
static char g_httpArgVoices[8];
static char g_httpArgSampleRate[16];
static char g_httpArgWaveTableSet[16];
static char g_httpArgToneClass[24];
static char g_httpArgNote[8];
static char g_httpArgToneOverride[8];
static char g_httpArgToneProgram[8];
static char g_syncJsonBuffer[256];
static char g_transportAction[16];

}  // namespace

void App::beginWebServer() {
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();
  config.core_id = 0;
  config.stack_size = 6144;
  config.max_uri_handlers = 17;
  config.lru_purge_enable = true;
  if (httpd_start(&m_server, &config) != ESP_OK) {
    m_server = nullptr;
    Log::info("Web server start failed");
    return;
  }
  logStagedHeap("HTTP server start");

  struct RouteDef {
    const char* uri;
    httpd_method_t method;
  };
  static constexpr RouteDef routes[] = {
      {"/", HTTP_GET},
      {"/api/status", HTTP_GET},
      {"/api/sync", HTTP_GET},
      {"/api/log", HTTP_GET},
      {"/api/midi/file", HTTP_GET},
      {"/api/bt-devices", HTTP_GET},
      {"/api/bt-scan/start", HTTP_GET},
      {"/api/bt-connect", HTTP_GET},
      {"/api/wifi-scan/start", HTTP_GET},
      {"/api/wifi-scan", HTTP_GET},
      {"/api/wifi-config", HTTP_GET},
      {"/api/wifi-config", HTTP_POST},
      {"/api/play", HTTP_GET},
      {"/api/transport", HTTP_POST},
      {"/api/synth-config", HTTP_GET},
      {"/api/tone-preview", HTTP_GET},
      {"/api/midi/upload", HTTP_POST},
  };
  for (const RouteDef& route : routes) {
    httpd_uri_t handler = {};
    handler.uri = route.uri;
    handler.method = route.method;
    handler.handler = &App::httpRequestHandler;
    handler.user_ctx = this;
    if (httpd_register_uri_handler(m_server, &handler) != ESP_OK) {
      Log::infof("Web route registration failed: %s", route.uri);
    }
  }
  Log::info("Web server started on port 80");
}

esp_err_t App::httpRequestHandler(httpd_req_t* request) {
  App* app = request != nullptr
      ? static_cast<App*>(request->user_ctx)
      : nullptr;
  if (app == nullptr) return ESP_FAIL;
  app->m_currentRequest = request;
  if (requestPathEquals(request, "/") && request->method == HTTP_GET) {
    app->handleRoot();
  } else if (requestPathEquals(request, "/api/status")) {
    app->handleStatus();
  } else if (requestPathEquals(request, "/api/sync") && request->method == HTTP_GET) {
    app->handleSync();
  } else if (requestPathEquals(request, "/api/log") && request->method == HTTP_GET) {
    app->handleLog();
  } else if (requestPathEquals(request, "/api/midi/file") && request->method == HTTP_GET) {
    app->handleMidiFile();
  } else if (requestPathEquals(request, "/api/bt-devices")) {
    app->handleBtDevices();
  } else if (requestPathEquals(request, "/api/bt-scan/start")) {
    app->handleBtScanStart();
  } else if (requestPathEquals(request, "/api/bt-connect")) {
    app->handleBtConnect();
  } else if (requestPathEquals(request, "/api/wifi-scan/start") &&
             request->method == HTTP_GET) {
    app->handleWifiScanStart();
  } else if (requestPathEquals(request, "/api/wifi-scan") &&
             request->method == HTTP_GET) {
    app->handleWifiScanResults();
  } else if (requestPathEquals(request, "/api/wifi-config") &&
             request->method == HTTP_GET) {
    app->handleWifiConfigStatus();
  } else if (requestPathEquals(request, "/api/wifi-config") &&
             request->method == HTTP_POST) {
    app->handleWifiConfig();
  } else if (requestPathEquals(request, "/api/play")) {
    app->handlePlayControl();
  } else if (requestPathEquals(request, "/api/transport") && request->method == HTTP_POST) {
    app->handleTransport();
  } else if (requestPathEquals(request, "/api/synth-config")) {
    app->handleSynthConfig();
  } else if (requestPathEquals(request, "/api/tone-preview")) {
    app->handleTonePreview();
  } else if (requestPathEquals(request, "/api/midi/upload") &&
             request->method == HTTP_POST) {
    app->handleMidiUpload();
  } else {
    sendResponse(request, 404, "text/plain; charset=utf-8", "not found");
  }
  app->m_currentRequest = nullptr;
  return ESP_OK;
}

size_t App::getStoredSongSize() const {
  return m_songStoredBytes;
}

void App::handleRoot() {
  httpd_resp_set_hdr(m_currentRequest, "Content-Encoding", "gzip");
  // Firmware updates can change the embedded converter semantics (for
  // example the 32-class to GM128 migration), so always revalidate `/`.
  httpd_resp_set_hdr(m_currentRequest, "Cache-Control", "no-cache");
  sendResponse(
      m_currentRequest,
      200,
      "text/html; charset=utf-8",
      reinterpret_cast<const char*>(kRootPageGzip),
      static_cast<ssize_t>(kRootPageGzipSize));
}

void App::handleStatus() {
  noteHttpActivity("status");
  buildStatusJson(g_statusJsonBuffer, sizeof(g_statusJsonBuffer));
  sendResponse(
      m_currentRequest,
      200,
      "application/json; charset=utf-8",
      g_statusJsonBuffer);
}

// Build a short, lock-free snapshot for the browser. The renderer schedules
// MIDI against millis(), including its own ring-buffer lookahead; do not
// subtract that lookahead twice. Keep this path independent of m_synthMutex:
// taking that mutex from the HTTP task made /api/sync return 503 during heavy
// render blocks and caused the browser clock to visibly jump after retries.
size_t App::buildSyncJson(char* dst, size_t capacity) const {
  if (dst == nullptr || capacity == 0) return 0;
  uint32_t generation = 0;
  portENTER_CRITICAL(const_cast<portMUX_TYPE*>(&m_syncMux));
  generation = m_syncGeneration;
  portEXIT_CRITICAL(const_cast<portMUX_TYPE*>(&m_syncMux));
  const uint32_t sampleRate = __atomic_load_n(&m_sampleRateHz, __ATOMIC_ACQUIRE);
  const uint32_t outputSampleRate =
      __atomic_load_n(&m_outputSampleRateHz, __ATOMIC_ACQUIRE);
  const uint32_t outputRate = outputSampleRate != 0 ? outputSampleRate : sampleRate;
  const bool playing = m_playing;
  const bool songLoaded = m_songLoaded;
  const bool audioStarted = m_audioStarted;
  const bool a2dpConnected = m_a2dpConnected;
  const uint32_t playbackStartMs = static_cast<uint32_t>(
      __atomic_load_n(&m_playbackStartMs, __ATOMIC_ACQUIRE));
  const uint32_t songIdHash = __atomic_load_n(&m_songIdHash, __ATOMIC_ACQUIRE);
  const bool running = playing && songLoaded && audioStarted && a2dpConnected;
  const uint64_t positionUs = running && playbackStartMs != 0
      ? static_cast<uint64_t>(static_cast<uint32_t>(millis() - playbackStartMs)) * 1000ULL : 0;
  char songId[9];
  snprintf(songId, sizeof(songId), "%08lx", static_cast<unsigned long>(songIdHash));
  size_t length = 0;
  dst[0] = '\0';
  appendRaw(dst, capacity, length, "{\"songId\":\"");
  appendRaw(dst, capacity, length, songLoaded ? songId : "");
  appendRaw(dst, capacity, length, "\",\"generation\":");
  appendUnsigned(dst, capacity, length, generation);
  appendRaw(dst, capacity, length, ",\"state\":\"");
  appendRaw(dst, capacity, length, running ? "playing" : (playing && songLoaded ? "waiting" : "stopped"));
  appendRaw(dst, capacity, length, "\",\"deviceTimeUs\":");
  appendUnsigned64(dst, capacity, length, static_cast<uint64_t>(esp_timer_get_time()));
  appendRaw(dst, capacity, length, ",\"positionUs\":");
  appendUnsigned64(dst, capacity, length, positionUs);
  appendRaw(dst, capacity, length, ",\"rate\":1,\"sampleRateHz\":");
  appendUnsigned(dst, capacity, length, outputRate);
  static const uint32_t sessionId = esp_random();
  appendRaw(dst, capacity, length, ",\"sessionId\":");
  appendUnsigned(dst, capacity, length, sessionId);
  appendRaw(dst, capacity, length, ",\"timingQuality\":\"scheduler\"}");
  return length;
}

void App::handleSync() {
  noteHttpActivity("sync");
  httpd_resp_set_hdr(m_currentRequest, "Cache-Control", "no-store");
  // Do not wait for the render mutex here. buildSyncJson only reads the
  // lock-free state snapshot above, so sync remains available while a heavy
  // audio block is rendering.
  buildSyncJson(g_syncJsonBuffer, sizeof(g_syncJsonBuffer));
  sendResponse(m_currentRequest, 200, "application/json; charset=utf-8", g_syncJsonBuffer);
}

void App::handleLog() {
  noteHttpActivity("log");
  // Snapshot history plus the RAM suffix without forcing or pausing Flash writes.
  httpd_resp_set_hdr(m_currentRequest, "Cache-Control", "no-store");
  Log::FlashReadCursor cursor;
  if (!Log::beginFlashRead(&cursor)) {
    char logTextBuffer[4097];
    const size_t length = Log::copyRing(logTextBuffer, sizeof(logTextBuffer));
    sendResponse(
        m_currentRequest,
        200,
        "text/plain; charset=utf-8",
        logTextBuffer,
        static_cast<ssize_t>(length));
    return;
  }

  httpd_resp_set_type(m_currentRequest, "text/plain; charset=utf-8");
  uint8_t buffer[1024];
  esp_err_t result = ESP_OK;
  while (true) {
    const size_t length = Log::readFlash(
        &cursor, reinterpret_cast<char*>(buffer), sizeof(buffer));
    if (length == 0) break;
    result = httpd_resp_send_chunk(
        m_currentRequest,
        reinterpret_cast<const char*>(buffer),
        static_cast<ssize_t>(length));
    if (result != ESP_OK) break;
  }
  while (result == ESP_OK && !cursor.failed) {
    const size_t length = Log::readRam(
        &cursor, reinterpret_cast<char*>(buffer), sizeof(buffer));
    if (length == 0) break;
    result = httpd_resp_send_chunk(
        m_currentRequest,
        reinterpret_cast<const char*>(buffer),
        static_cast<ssize_t>(length));
  }
  Log::endFlashRead(&cursor);
  if (result == ESP_OK && !cursor.failed) {
    result = httpd_resp_send_chunk(m_currentRequest, nullptr, 0);
  }
  if (result != ESP_OK || cursor.failed) {
    httpd_sess_trigger_close(m_server, httpd_req_to_sockfd(m_currentRequest));
  }
}

void App::handleMidiFile() {
  noteHttpActivity("midifile");
  if (!m_songLoaded || m_songPartition == nullptr ||
      m_songFormatVersion != kSongFormatVersionRawMidi) {
    sendResponse(m_currentRequest, 409, "text/plain; charset=utf-8", "raw MIDI is not available");
    return;
  }
  bool parserLocked = false;
  if (m_rawMidiParserMutex != nullptr) {
    if (xSemaphoreTake(m_rawMidiParserMutex, pdMS_TO_TICKS(50)) != pdTRUE) {
      sendResponse(m_currentRequest, 503, "text/plain; charset=utf-8", "MIDI is busy");
      return;
    }
    parserLocked = true;
  }
  SongPartitionHeader header;
  const bool headerOk = esp_partition_read(m_songPartition, 0, &header, sizeof(header)) == ESP_OK &&
      memcmp(header.magic, kRawMidiMagic, sizeof(kRawMidiMagic)) == 0 &&
      header.version == kSongFormatVersionRawMidi &&
      header.headerSize == kSongHeaderSize &&
      header.dataBytes >= 14 &&
      header.headerSize <= m_songPartition->size &&
      header.dataBytes <= m_songPartition->size - header.headerSize;
  if (!headerOk) {
    if (parserLocked) xSemaphoreGive(m_rawMidiParserMutex);
    sendResponse(m_currentRequest, 409, "text/plain; charset=utf-8", "stored MIDI is invalid");
    return;
  }
  // Never hold the parser mutex while waiting for a slow network client.
  if (parserLocked) { xSemaphoreGive(m_rawMidiParserMutex); parserLocked = false; }
  httpd_resp_set_type(m_currentRequest, "audio/midi");
  httpd_resp_set_hdr(m_currentRequest, "Content-Disposition", "attachment; filename=stored.mid");
  httpd_resp_set_hdr(m_currentRequest, "Cache-Control", "no-store");
  uint8_t buffer[1024];
  size_t offset = header.headerSize;
  size_t remaining = header.dataBytes;
  esp_err_t result = ESP_OK;
  while (remaining > 0) {
    const size_t count = remaining < sizeof(buffer) ? remaining : sizeof(buffer);
    if (esp_partition_read(m_songPartition, offset, buffer, count) != ESP_OK) {
      result = ESP_FAIL;
      break;
    }
    result = httpd_resp_send_chunk(
        m_currentRequest, reinterpret_cast<const char*>(buffer), static_cast<ssize_t>(count));
    if (result != ESP_OK) break;
    offset += count;
    remaining -= count;
  }
  if (result == ESP_OK) {
    result = httpd_resp_send_chunk(m_currentRequest, nullptr, 0);
  }
  if (result != ESP_OK) {
    httpd_sess_trigger_close(m_server, httpd_req_to_sockfd(m_currentRequest));
  }
  if (parserLocked) xSemaphoreGive(m_rawMidiParserMutex);
}

void App::handleTransport() {
  noteHttpActivity("transport");
  g_transportAction[0] = '\0';
  copyServerArg(m_currentRequest, "action", g_transportAction, sizeof(g_transportAction));
  if (m_currentRequest->content_len != 0) {
    httpd_resp_set_hdr(m_currentRequest, "Connection", "close");
    sendResponse(m_currentRequest, 400, "text/plain", "Use POST ?action=play|stop with an empty body");
    httpd_sess_trigger_close(m_server, httpd_req_to_sockfd(m_currentRequest));
    return;
  }
  if (strcmp(g_transportAction, "play") != 0 && strcmp(g_transportAction, "stop") != 0) {
    sendResponse(m_currentRequest, 400, "application/json; charset=utf-8",
        "{\"ok\":false,\"error\":\"action must be play or stop\"}");
    return;
  }
  if (m_synthMutex == nullptr ||
      xSemaphoreTake(m_synthMutex, pdMS_TO_TICKS(50)) != pdTRUE) {
    sendResponse(m_currentRequest, 503, "application/json; charset=utf-8",
        "{\"ok\":false,\"error\":\"synth busy\"}");
    return;
  }
  if (strcmp(g_transportAction, "play") == 0) {
    if (!m_songLoaded) {
      xSemaphoreGive(m_synthMutex);
      sendResponse(m_currentRequest, 409, "text/plain", "No MIDI loaded");
      return;
    }
    m_playing = true;
    if (m_songLoaded && m_audioStarted) startSongPlayback();
  } else {
    m_playing = false;
    portENTER_CRITICAL(&m_syncMux);
    ++m_syncGeneration;
    m_audioConsumedFrames = 0;
    portEXIT_CRITICAL(&m_syncMux);
    stopAllVoices();
    clearAudioRingBuffer();
  }
  buildSyncJson(g_syncJsonBuffer, sizeof(g_syncJsonBuffer));
  xSemaphoreGive(m_synthMutex);
  sendResponse(m_currentRequest, 200, "application/json; charset=utf-8", g_syncJsonBuffer);
}

void App::handleBtDevices() {
  noteHttpActivity("btdev");
  buildBtDevicesJson(g_btDevicesJsonBuffer, sizeof(g_btDevicesJsonBuffer));
  sendResponse(
      m_currentRequest,
      200,
      "application/json; charset=utf-8",
      g_btDevicesJsonBuffer);
}

void App::handleBtScanStart() {
  noteHttpActivity("btscan");
  startBtDiscovery();
  handleStatus();
}

void App::handleBtConnect() {
  noteHttpActivity("btconn");
  if (!copyServerArg(m_currentRequest, "address", g_httpArgAddress, sizeof(g_httpArgAddress))) {
    Log::info("BT connect HTTP rejected: missing or oversized address");
    sendResponse(m_currentRequest, 400, "text/plain", "Invalid Bluetooth address");
    return;
  }
  bool valid = strlen(g_httpArgAddress) == 17;
  for (size_t i = 0; valid && i < 17; ++i) {
    valid = i % 3 == 2 ? g_httpArgAddress[i] == ':' :
        isxdigit(static_cast<unsigned char>(g_httpArgAddress[i])) != 0;
  }
  if (!valid) {
    Log::info("BT connect HTTP rejected: malformed address");
    sendResponse(m_currentRequest, 400, "text/plain", "Invalid Bluetooth address");
    return;
  }
  if (!m_btReady || !m_a2dpReady) {
    Log::info("BT connect HTTP rejected: Bluetooth is not ready");
    sendResponse(m_currentRequest, 503, "text/plain", "Bluetooth is not ready");
    return;
  }
  Log::infof("BT connect HTTP accepted: %s", g_httpArgAddress);
  connectToAddress(g_httpArgAddress);
  handleStatus();
}

void App::handleWifiScanStart() {
  noteHttpActivity("wscan");
  if (!m_wifiStarted) {
    sendResponse(m_currentRequest, 503, "text/plain; charset=utf-8", "Wi-Fi is not ready");
    return;
  }
  if (m_wifiScanRunning) {
    sendResponse(
        m_currentRequest, 200, "application/json; charset=utf-8",
        "{\"ok\":true,\"running\":true}");
    return;
  }
  wifi_scan_config_t scanConfig = {};
  scanConfig.show_hidden = false;
  scanConfig.scan_type = WIFI_SCAN_TYPE_ACTIVE;
  // Keep returning to the provisioning AP's home channel while walking the
  // other channels.  APSTA shares one 2.4 GHz radio, so this is what makes a
  // full SSID search usable from a browser that is connected to 192.168.4.1.
  scanConfig.scan_time.active.min = 60;
  scanConfig.scan_time.active.max = 160;
  scanConfig.home_chan_dwell_time = 80;
  scanConfig.coex_background_scan = true;
  portENTER_CRITICAL(&m_wifiScanMux);
  memset(m_wifiNetworks, 0, sizeof(m_wifiNetworks));
  m_wifiNetworkCount = 0;
  m_wifiScanReady = false;
  m_wifiScanRunning = true;
  portEXIT_CRITICAL(&m_wifiScanMux);
  const esp_err_t result = esp_wifi_scan_start(&scanConfig, false);
  if (result != ESP_OK) {
    portENTER_CRITICAL(&m_wifiScanMux);
    m_wifiScanRunning = false;
    portEXIT_CRITICAL(&m_wifiScanMux);
    Log::infof("Wi-Fi scan start failed: %s", esp_err_to_name(result));
    sendResponse(m_currentRequest, 503, "text/plain; charset=utf-8", "Wi-Fi scan could not start");
    return;
  }
  Log::info("Wi-Fi scan requested");
  sendResponse(
      m_currentRequest, 200, "application/json; charset=utf-8",
      "{\"ok\":true,\"running\":true}");
}

void App::handleWifiScanResults() {
  noteHttpActivity("wscanget");
  WifiNetworkInfo snapshot[kMaxWifiNetworks] = {};
  uint8_t networkCount = 0;
  bool running = false;
  bool ready = false;
  portENTER_CRITICAL(&m_wifiScanMux);
  memcpy(snapshot, m_wifiNetworks, sizeof(snapshot));
  networkCount = m_wifiNetworkCount;
  running = m_wifiScanRunning;
  ready = m_wifiScanReady;
  portEXIT_CRITICAL(&m_wifiScanMux);

  httpd_resp_set_type(m_currentRequest, "application/json; charset=utf-8");
  httpd_resp_set_hdr(m_currentRequest, "Cache-Control", "no-store");
  char chunk[192];
  size_t length = 0;
  appendRaw(chunk, sizeof(chunk), length, "{\"running\":");
  appendBool(chunk, sizeof(chunk), length, running);
  appendRaw(chunk, sizeof(chunk), length, ",\"ready\":");
  appendBool(chunk, sizeof(chunk), length, ready);
  appendRaw(chunk, sizeof(chunk), length, ",\"networks\":[");
  esp_err_t result = httpd_resp_send_chunk(
      m_currentRequest, chunk, static_cast<ssize_t>(length));
  for (uint8_t i = 0; result == ESP_OK && i < networkCount; ++i) {
    length = 0;
    if (i != 0) appendChar(chunk, sizeof(chunk), length, ',');
    appendRaw(chunk, sizeof(chunk), length, "{\"ssid\":\"");
    appendEscapedJson(chunk, sizeof(chunk), length, snapshot[i].ssid);
    appendRaw(chunk, sizeof(chunk), length, "\",\"rssi\":");
    appendSigned(chunk, sizeof(chunk), length, snapshot[i].rssi);
    appendRaw(chunk, sizeof(chunk), length, ",\"authmode\":");
    appendUnsigned(chunk, sizeof(chunk), length, snapshot[i].authmode);
    appendRaw(chunk, sizeof(chunk), length, ",\"secure\":");
    appendBool(chunk, sizeof(chunk), length, snapshot[i].authmode != 0);
    appendChar(chunk, sizeof(chunk), length, '}');
    result = httpd_resp_send_chunk(
        m_currentRequest, chunk, static_cast<ssize_t>(length));
  }
  if (result == ESP_OK) {
    length = 0;
    appendRaw(chunk, sizeof(chunk), length, "]}");
    result = httpd_resp_send_chunk(
        m_currentRequest, chunk, static_cast<ssize_t>(length));
  }
  if (result == ESP_OK) {
    result = httpd_resp_send_chunk(m_currentRequest, nullptr, 0);
  }
  if (result != ESP_OK) {
    httpd_sess_trigger_close(m_server, httpd_req_to_sockfd(m_currentRequest));
  }
}

void App::handleWifiConfigStatus() {
  noteHttpActivity("wcfgget");
  char body[384];
  size_t length = 0;
  body[0] = '\0';
  appendRaw(body, sizeof(body), length, "{\"ok\":true,\"ssid\":\"");
  appendEscapedJson(body, sizeof(body), length, m_wifiSsid);
  appendRaw(body, sizeof(body), length, "\",\"connected\":");
  appendBool(body, sizeof(body), length, m_wifiConnected);
  appendRaw(body, sizeof(body), length, ",\"ipAddress\":\"");
  appendRaw(body, sizeof(body), length, m_ipAddress);
  appendRaw(body, sizeof(body), length,
            "\",\"mdnsHost\":\"esp32-tiny-midi.local\",\"provisioning\":");
  appendBool(body, sizeof(body), length, m_wifiProvisioningMode);
  appendRaw(body, sizeof(body), length, ",\"apSsid\":\"");
  appendRaw(body, sizeof(body), length,
            m_wifiProvisioningMode ? kProvisioningApSsid : "");
  appendRaw(body, sizeof(body), length, "\",\"scanAvailable\":");
  appendBool(body, sizeof(body), length, m_wifiStarted);
  appendRaw(body, sizeof(body), length, ",\"reconfiguring\":");
  appendBool(body, sizeof(body), length,
             m_wifiReconfigureRequested || m_wifiReconfiguring);
  appendRaw(body, sizeof(body), length, ",\"rollback\":");
  appendBool(body, sizeof(body), length,
             m_wifiRollbackRequested || m_wifiRollbackInProgress);
  appendRaw(body, sizeof(body), length, "}");
  sendResponse(m_currentRequest, 200, "application/json; charset=utf-8", body);
}

void App::handleWifiConfig() {
  noteHttpActivity("wcfg");
  char form[384];
  if (!readRequestBody(m_currentRequest, form, sizeof(form))) {
    sendResponse(
        m_currentRequest, 400, "text/plain; charset=utf-8",
        "Expected form body: ssid=...&password=...");
    return;
  }
  char ssid[33] = {};
  char password[65] = {};
  if (!copyFormArg(form, "ssid", ssid, sizeof(ssid), false) ||
      !copyFormArg(form, "password", password, sizeof(password), true)) {
    sendResponse(
        m_currentRequest, 400, "text/plain; charset=utf-8",
        "SSID and password fields are required");
    return;
  }
  if (!m_wifiProvisioningMode && m_wifiScanRunning) {
    sendResponse(
        m_currentRequest, 409, "text/plain; charset=utf-8",
        "Wi-Fi scan is still running; try again when it finishes");
    return;
  }
  if (!m_wifiProvisioningMode &&
      (m_wifiReconfigureRequested || m_wifiReconfiguring ||
       m_wifiRollbackRequested || m_wifiRollbackInProgress)) {
    sendResponse(
        m_currentRequest, 409, "text/plain; charset=utf-8",
        "Wi-Fi reconnect is still in progress; try again shortly");
    return;
  }
  const size_t ssidLength = strlen(ssid);
  const size_t passwordLength = strlen(password);
  if (ssidLength == 0 || ssidLength > 32 || passwordLength > 63 ||
      (passwordLength != 0 && passwordLength < 8)) {
    sendResponse(
        m_currentRequest, 400, "text/plain; charset=utf-8",
        "Invalid Wi-Fi credentials (SSID <=32 bytes, password 8-63 bytes or empty)");
    return;
  }
  if (m_wifiProvisioningMode) {
    if (!saveWifiCredentials(ssid, password)) {
      sendResponse(m_currentRequest, 500, "text/plain; charset=utf-8",
                   "Wi-Fi credentials could not be saved");
      return;
    }
    char response[192];
    size_t length = 0;
    response[0] = '\0';
    appendRaw(response, sizeof(response), length,
              "{\"ok\":true,\"restarting\":true,\"ssid\":\"");
    appendEscapedJson(response, sizeof(response), length, ssid);
    appendRaw(response, sizeof(response), length, "\"}");
    sendResponse(m_currentRequest, 200, "application/json; charset=utf-8", response);
    vTaskDelay(pdMS_TO_TICKS(250));
    esp_restart();
    return;
  }

  char response[192];
  size_t length = 0;
  response[0] = '\0';
  appendRaw(response, sizeof(response), length,
            "{\"ok\":true,\"reconnecting\":true,\"ssid\":\"");
  appendEscapedJson(response, sizeof(response), length, ssid);
  appendRaw(response, sizeof(response), length, "\"}");
  const esp_err_t responseResult =
      sendResponse(m_currentRequest, 200, "application/json; charset=utf-8", response);
  if (responseResult != ESP_OK) {
    Log::infof("Wi-Fi reconfigure response failed: %s",
               esp_err_to_name(responseResult));
    return;
  }
  // Keep the current TCP connection alive briefly after the response has been
  // handed to the socket.  esp_wifi_disconnect() aborts Wi-Fi TCP sockets.
  portENTER_CRITICAL(&m_wifiConfigMux);
  strncpy(m_wifiPendingSsid, ssid, sizeof(m_wifiPendingSsid) - 1);
  m_wifiPendingSsid[sizeof(m_wifiPendingSsid) - 1] = '\0';
  strncpy(m_wifiPendingPassword, password, sizeof(m_wifiPendingPassword) - 1);
  m_wifiPendingPassword[sizeof(m_wifiPendingPassword) - 1] = '\0';
  m_wifiReconfigureNotBeforeMs = millis() + kWifiResponseGraceMs;
  m_wifiReconfigureRequested = true;
  portEXIT_CRITICAL(&m_wifiConfigMux);
}

void App::handlePlayControl() {
  noteHttpActivity("play");
  copyServerArg(m_currentRequest, "state", g_httpArgState, sizeof(g_httpArgState));
  if (m_synthMutex != nullptr &&
      xSemaphoreTake(m_synthMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
    portENTER_CRITICAL(&m_syncMux);
    ++m_syncGeneration;
    m_audioConsumedFrames = 0;
    portEXIT_CRITICAL(&m_syncMux);
    if (strcmp(g_httpArgState, "on") == 0) {
      m_playing = true;
      if (m_songLoaded && m_audioStarted) {
        startSongPlayback();
      }
      Log::info("Playback enabled");
    } else if (strcmp(g_httpArgState, "off") == 0) {
      m_playing = false;
      portENTER_CRITICAL(&m_syncMux);
      ++m_syncGeneration;
      m_audioConsumedFrames = 0;
      portEXIT_CRITICAL(&m_syncMux);
      stopAllVoices();
      clearAudioRingBuffer();
      Log::info("Playback disabled");
    }
    xSemaphoreGive(m_synthMutex);
  }
  handleStatus();
}

void App::handleSynthConfig() {
  noteHttpActivity("cfg");
  copyServerArg(m_currentRequest, "voices", g_httpArgVoices, sizeof(g_httpArgVoices));
  copyServerArg(m_currentRequest, "sampleRateHz", g_httpArgSampleRate, sizeof(g_httpArgSampleRate));
  copyServerArg(m_currentRequest, "waveTableSet", g_httpArgWaveTableSet, sizeof(g_httpArgWaveTableSet));
  copyServerArg(m_currentRequest, "toneOverride", g_httpArgToneOverride, sizeof(g_httpArgToneOverride));
  copyServerArg(m_currentRequest, "toneClass", g_httpArgToneProgram, sizeof(g_httpArgToneProgram));
  if (m_synthMutex != nullptr &&
      xSemaphoreTake(m_synthMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
    if (g_httpArgVoices[0] != '\0') {
      const int requestedVoices = atoi(g_httpArgVoices);
      if (requestedVoices >= 1 && requestedVoices <= kMaxVoices) {
        m_activeVoiceLimit = static_cast<uint8_t>(requestedVoices);
        Log::infof("Voice limit updated: %u", static_cast<unsigned>(m_activeVoiceLimit));
        for (uint8_t i = m_activeVoiceLimit; i < kMaxVoices; ++i) {
          setVoiceActive(i, false);
          m_voices[i].hotCore.carrierFixedGainLeftQ15 = 0;
          m_voices[i].hotCore.carrierFixedGainRightQ15 = 0;
        }
      }
    }
    if (g_httpArgSampleRate[0] != '\0') {
      const uint32_t requestedSampleRate = static_cast<uint32_t>(strtoul(g_httpArgSampleRate, nullptr, 10));
      if (requestedSampleRate == 44100 || requestedSampleRate == 32000 ||
          requestedSampleRate == 16000) {
        const uint32_t oldSampleRate = m_sampleRateHz;
        m_requestedSampleRateHz = requestedSampleRate;
        if (requestedSampleRate != oldSampleRate) {
          m_sampleRateHz = requestedSampleRate;
          retimeActiveVoices(oldSampleRate, m_sampleRateHz);
          resetEffects();
          // 32k/16kをさらに間引く旧sample-holdは音質を大きく損なうため廃止。
          if (m_btReady && !m_a2dpConnected) {
            registerA2dpSourceEndpoint();
          }
          clearAudioRingBuffer();
          Log::infof(
              "Sample rate request updated: requested=%lu actual=%lu",
              static_cast<unsigned long>(m_requestedSampleRateHz),
              static_cast<unsigned long>(m_sampleRateHz));
        }
      }
    }
    if (strcmp(g_httpArgWaveTableSet, "real") == 0) {
      m_waveTableSet = WaveTableSet::Real;
      Log::info("Wave table set updated: real");
    } else if (strcmp(g_httpArgWaveTableSet, "famicom") == 0) {
      m_waveTableSet = WaveTableSet::Famicom;
      Log::info("Wave table set updated: famicom");
    } else if (strcmp(g_httpArgWaveTableSet, "soft") == 0) {
      m_waveTableSet = WaveTableSet::Soft;
      Log::info("Wave table set updated: soft");
    }
    if (g_httpArgToneProgram[0] != '\0') {
      char* numericEnd = nullptr;
      const unsigned long requestedTone =
          strtoul(g_httpArgToneProgram, &numericEnd, 10);
      if (numericEnd != g_httpArgToneProgram && *numericEnd == '\0' &&
          requestedTone < 128) {
        m_toneOverrideClass =
            static_cast<MidiEvent::ToneClass>(requestedTone);
        Log::infof(
            "Tone override class updated: %lu",
            requestedTone);
      }
    }
    if (g_httpArgToneOverride[0] != '\0') {
      bool requestedEnabled = m_toneOverrideEnabled;
      bool valid = true;
      if (strcmp(g_httpArgToneOverride, "1") == 0 ||
          strcmp(g_httpArgToneOverride, "true") == 0 ||
          strcmp(g_httpArgToneOverride, "on") == 0) {
        requestedEnabled = true;
      } else if (strcmp(g_httpArgToneOverride, "0") == 0 ||
                 strcmp(g_httpArgToneOverride, "false") == 0 ||
                 strcmp(g_httpArgToneOverride, "off") == 0) {
        requestedEnabled = false;
      } else {
        valid = false;
      }
      if (valid && requestedEnabled != m_toneOverrideEnabled) {
        m_toneOverrideEnabled = requestedEnabled;
        Log::infof(
            "Tone override %s",
            requestedEnabled ? "enabled" : "disabled");
      }
    }
    // Configuration changes preserve the current playback cursor. Restarting
    // a raw-MIDI parser at tick zero and immediately resuming at a later time
    // caused queued historical events to arrive in bursts. Active voices are
    // retimed above; newly triggered voices use the new rate/table directly.
    xSemaphoreGive(m_synthMutex);
  }
  handleStatus();
}

void App::handleTonePreview() {
  noteHttpActivity("preview");
  copyServerArg(m_currentRequest, "class", g_httpArgToneClass, sizeof(g_httpArgToneClass));
  copyServerArg(m_currentRequest, "note", g_httpArgNote, sizeof(g_httpArgNote));
  
  MidiEvent::ToneClass toneClass = MidiEvent::ToneClass::Piano;
  uint8_t note = 60;
  uint8_t velocity = 110;
  char* numericEnd = nullptr;
  const unsigned long numericClass = strtoul(g_httpArgToneClass, &numericEnd, 10);
  
  // Default notes for each class (legacy behavior)
  if (g_httpArgToneClass[0] != '\0' && numericEnd != g_httpArgToneClass &&
      *numericEnd == '\0' && numericClass < 128) {
    toneClass = static_cast<MidiEvent::ToneClass>(numericClass);
  } else if (strcmp(g_httpArgToneClass, "lead") == 0) {
    toneClass = MidiEvent::ToneClass::Lead; note = 72; velocity = 112;
  } else if (strcmp(g_httpArgToneClass, "hardlead") == 0) {
    toneClass = MidiEvent::ToneClass::HardLead; note = 76; velocity = 116;
  } else if (strcmp(g_httpArgToneClass, "softlead") == 0) {
    toneClass = MidiEvent::ToneClass::SoftLead; note = 74; velocity = 98;
  } else if (strcmp(g_httpArgToneClass, "bass") == 0) {
    toneClass = MidiEvent::ToneClass::Bass; note = 40; velocity = 120;
  } else if (strcmp(g_httpArgToneClass, "pickedbass") == 0) {
    toneClass = MidiEvent::ToneClass::PickedBass; note = 40; velocity = 118;
  } else if (strcmp(g_httpArgToneClass, "subbass") == 0) {
    toneClass = MidiEvent::ToneClass::SubBass; note = 31; velocity = 122;
  } else if (strcmp(g_httpArgToneClass, "punchbass") == 0) {
    toneClass = MidiEvent::ToneClass::PunchBass; note = 38; velocity = 124;
  } else if (strcmp(g_httpArgToneClass, "pad") == 0) {
    toneClass = MidiEvent::ToneClass::Pad; note = 60; velocity = 84;
  } else if (strcmp(g_httpArgToneClass, "warmpad") == 0) {
    toneClass = MidiEvent::ToneClass::WarmPad; note = 57; velocity = 82;
  } else if (strcmp(g_httpArgToneClass, "strings") == 0) {
    toneClass = MidiEvent::ToneClass::Strings; note = 62; velocity = 88;
  } else if (strcmp(g_httpArgToneClass, "choir") == 0) {
    toneClass = MidiEvent::ToneClass::Choir; note = 60; velocity = 90;
  } else if (strcmp(g_httpArgToneClass, "piano") == 0) {
    toneClass = MidiEvent::ToneClass::Piano; note = 60; velocity = 110;
  } else if (strcmp(g_httpArgToneClass, "brightpiano") == 0) {
    toneClass = MidiEvent::ToneClass::BrightPiano; note = 64; velocity = 116;
  } else if (strcmp(g_httpArgToneClass, "honkytonk") == 0) {
    toneClass = MidiEvent::ToneClass::HonkyTonk; note = 62; velocity = 112;
  } else if (strcmp(g_httpArgToneClass, "keys") == 0) {
    toneClass = MidiEvent::ToneClass::Keys; note = 64; velocity = 96;
  } else if (strcmp(g_httpArgToneClass, "epiano") == 0) {
    toneClass = MidiEvent::ToneClass::EPiano; note = 66; velocity = 102;
  } else if (strcmp(g_httpArgToneClass, "organ") == 0) {
    toneClass = MidiEvent::ToneClass::Organ; note = 61; velocity = 98;
  } else if (strcmp(g_httpArgToneClass, "accordion") == 0) {
    toneClass = MidiEvent::ToneClass::Accordion; note = 62; velocity = 104;
  } else if (strcmp(g_httpArgToneClass, "nylonguitar") == 0) {
    toneClass = MidiEvent::ToneClass::NylonGuitar; note = 57; velocity = 106;
  } else if (strcmp(g_httpArgToneClass, "cleanguitar") == 0) {
    toneClass = MidiEvent::ToneClass::CleanGuitar; note = 57; velocity = 108;
  } else if (strcmp(g_httpArgToneClass, "mutedguitar") == 0) {
    toneClass = MidiEvent::ToneClass::MutedGuitar; note = 57; velocity = 112;
  } else if (strcmp(g_httpArgToneClass, "brass") == 0) {
    toneClass = MidiEvent::ToneClass::Brass; note = 62; velocity = 114;
  } else if (strcmp(g_httpArgToneClass, "trumpet") == 0) {
    toneClass = MidiEvent::ToneClass::Trumpet; note = 67; velocity = 116;
  } else if (strcmp(g_httpArgToneClass, "sax") == 0) {
    toneClass = MidiEvent::ToneClass::Sax; note = 65; velocity = 108;
  } else if (strcmp(g_httpArgToneClass, "flute") == 0) {
    toneClass = MidiEvent::ToneClass::Flute; note = 79; velocity = 96;
  } else if (strcmp(g_httpArgToneClass, "clarinet") == 0) {
    toneClass = MidiEvent::ToneClass::Clarinet; note = 72; velocity = 100;
  } else if (strcmp(g_httpArgToneClass, "bell") == 0) {
    toneClass = MidiEvent::ToneClass::Bell; note = 84; velocity = 118;
  } else if (strcmp(g_httpArgToneClass, "metal") == 0) {
    toneClass = MidiEvent::ToneClass::Metal; note = 86; velocity = 120;
  } else if (strcmp(g_httpArgToneClass, "mallet") == 0) {
    toneClass = MidiEvent::ToneClass::Mallet; note = 79; velocity = 116;
  } else if (strcmp(g_httpArgToneClass, "pluck") == 0) {
    toneClass = MidiEvent::ToneClass::Pluck; note = 67; velocity = 108;
  } else if (strcmp(g_httpArgToneClass, "perc") == 0) {
    toneClass = MidiEvent::ToneClass::Perc; note = 52; velocity = 120;
  } else if (strcmp(g_httpArgToneClass, "kickperc") == 0) {
    toneClass = MidiEvent::ToneClass::KickPerc; note = 30; velocity = 126;
  }

  // Override note if explicitly requested by the UI (e.g. keyboard click)
  if (g_httpArgNote[0] != '\0') {
    note = static_cast<uint8_t>(atoi(g_httpArgNote));
  }
  if (m_synthMutex != nullptr &&
      xSemaphoreTake(m_synthMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
    if (m_a2dpConnected && !m_audioStarted) {
      esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_CHECK_SRC_RDY);
    }
    if (m_previewVoiceIndex >= 0 &&
        m_previewVoiceIndex < kMaxVoices &&
        m_voices[m_previewVoiceIndex].hotCore.active &&
        m_voices[m_previewVoiceIndex].cold.channel == 15 &&
        m_voices[m_previewVoiceIndex].cold.note == m_previewNote &&
        m_voices[m_previewVoiceIndex].cold.toneClass == m_previewToneClass) {
      setVoiceActive(static_cast<uint8_t>(m_previewVoiceIndex), false);
      m_voices[m_previewVoiceIndex].hotCore.carrierFixedGainLeftQ15 = 0;
      m_voices[m_previewVoiceIndex].hotCore.carrierFixedGainRightQ15 = 0;
    }
    m_previewVoiceIndex = noteOn(note, velocity, 15, toneClass);
    if (m_previewVoiceIndex >= 0) {
      m_previewNote = note;
      m_previewToneClass = toneClass;
      m_previewStopAtMs = millis() + 850;
    } else {
      m_previewNote = 0;
      m_previewToneClass = MidiEvent::ToneClass::Lead;
      m_previewStopAtMs = 0;
    }
    xSemaphoreGive(m_synthMutex);
  }
  sendResponse(m_currentRequest, 200, "text/plain; charset=utf-8", "ok");
}

void App::handleMidiUpload() {
  noteHttpActivity("upload");
  m_uploadError[0] = '\0';
  if (m_songPartition == nullptr) {
    strncpy(m_uploadError, "song partition missing", sizeof(m_uploadError) - 1);
    sendResponse(m_currentRequest, 500, "text/plain; charset=utf-8", m_uploadError);
    return;
  }
  if (m_currentRequest == nullptr || m_currentRequest->content_len == 0) {
    sendResponse(m_currentRequest, 400, "text/plain; charset=utf-8", "empty song upload");
    return;
  }
  if (m_currentRequest->content_len + sizeof(SongPartitionHeader) > m_songPartition->size) {
    sendResponse(m_currentRequest, 400, "text/plain; charset=utf-8", "MIDI file too large");
    return;
  }

  if (m_synthMutex != nullptr &&
      xSemaphoreTake(m_synthMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
    m_song.clear();
    m_songLoaded = false;
    m_playing = false;
    m_songStoredBytes = 0;
    m_lastUploadedFileSize = 0;
    m_partitionWriteOffset = 0;
    m_nextEventCached = false;
    m_rawMidiParserPaused = true;
    m_rawMidiParserRunning = false;
    m_rawMidiParserCommand = 0;
    resetRawMidiQueue();
    stopAllVoices();
    clearAudioRingBuffer();
    xSemaphoreGive(m_synthMutex);
  } else if (m_synthMutex != nullptr) {
    sendResponse(m_currentRequest, 503, "text/plain; charset=utf-8", "synth busy");
    return;
  }

  // Stop the streaming parser before erasing its backing partition.  Holding
  // this mutex through the write also prevents a CPU0 flash read racing with
  // the upload request.
  bool rawParserLocked = false;
  if (m_rawMidiParserMutex != nullptr) {
    if (xSemaphoreTake(m_rawMidiParserMutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
      strncpy(m_uploadError, "MIDI parser is busy", sizeof(m_uploadError) - 1);
      m_uploadError[sizeof(m_uploadError) - 1] = '\0';
      sendResponse(m_currentRequest, 503, "text/plain; charset=utf-8", m_uploadError);
      return;
    }
    rawParserLocked = true;
  }

  if (esp_partition_erase_range(
          m_songPartition,
          0,
          m_songPartition->size) != ESP_OK) {
    strncpy(m_uploadError, "failed to erase song partition", sizeof(m_uploadError) - 1);
    m_uploadError[sizeof(m_uploadError) - 1] = '\0';
    Log::info("Upload error: failed to erase song partition");
    if (rawParserLocked) xSemaphoreGive(m_rawMidiParserMutex);
    sendResponse(m_currentRequest, 500, "text/plain; charset=utf-8", m_uploadError);
    return;
  }

  Log::infof(
      "Song upload start: bytes=%lu",
      static_cast<unsigned long>(m_currentRequest->content_len));
  SongPartitionHeader header;
  memset(&header, 0, sizeof(header));
  memcpy(header.magic, "RAWMID1", 7);
  header.version = kSongFormatVersionRawMidi;
  header.headerSize = sizeof(SongPartitionHeader);
  header.durationMs = UINT32_MAX;
  header.dataBytes = m_currentRequest->content_len;
  strncpy(header.name, "Raw MIDI", sizeof(header.name) - 1);
  if (esp_partition_write(m_songPartition, 0, &header, sizeof(header)) != ESP_OK) {
    strncpy(m_uploadError, "failed to write MIDI header", sizeof(m_uploadError) - 1);
    m_uploadError[sizeof(m_uploadError) - 1] = '\0';
    if (rawParserLocked) xSemaphoreGive(m_rawMidiParserMutex);
    sendResponse(m_currentRequest, 500, "text/plain; charset=utf-8", m_uploadError);
    return;
  }
  uint8_t buffer[1024];
  size_t remaining = m_currentRequest->content_len;
  unsigned receiveTimeouts = 0;
  m_partitionWriteOffset = sizeof(SongPartitionHeader);
  while (remaining > 0) {
    const size_t requested = remaining < sizeof(buffer) ? remaining : sizeof(buffer);
    const int received = httpd_req_recv(
        m_currentRequest,
        reinterpret_cast<char*>(buffer),
        requested);
    if (received == HTTPD_SOCK_ERR_TIMEOUT) {
      if (++receiveTimeouts < 3) continue;
      strncpy(m_uploadError, "song upload timed out", sizeof(m_uploadError) - 1);
      break;
    }
    if (received <= 0) {
      strncpy(m_uploadError, "song upload receive failed", sizeof(m_uploadError) - 1);
      m_uploadError[sizeof(m_uploadError) - 1] = '\0';
      break;
    }
    receiveTimeouts = 0;
    if (esp_partition_write(
            m_songPartition,
      m_partitionWriteOffset,
            buffer,
            static_cast<size_t>(received)) != ESP_OK) {
      strncpy(m_uploadError, "failed to write song partition", sizeof(m_uploadError) - 1);
      m_uploadError[sizeof(m_uploadError) - 1] = '\0';
      break;
    }
    m_partitionWriteOffset += static_cast<size_t>(received);
    m_lastUploadedFileSize += static_cast<size_t>(received);
    remaining -= static_cast<size_t>(received);
  }

  bool loaded = false;
  if (m_uploadError[0] == '\0' && m_synthMutex != nullptr &&
      xSemaphoreTake(m_synthMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
    loaded = loadSongMetadataFromPartition();
    if (loaded) {
      m_rawMidiParserPaused = false;
      m_playing = true;
      if (m_audioStarted) {
        startSongPlayback();
      }
    }
    xSemaphoreGive(m_synthMutex);
  }
  if (!loaded) {
    if (rawParserLocked) xSemaphoreGive(m_rawMidiParserMutex);
    if (m_uploadError[0] == '\0') {
      strncpy(m_uploadError, "failed to load stored song", sizeof(m_uploadError) - 1);
      m_uploadError[sizeof(m_uploadError) - 1] = '\0';
    }
    Log::infof("Song upload failed: %s", m_uploadError);
    sendResponse(m_currentRequest, 500, "text/plain; charset=utf-8", m_uploadError);
    return;
  }

  if (rawParserLocked) xSemaphoreGive(m_rawMidiParserMutex);

  Log::infof(
      "Song uploaded to raw partition: events=%u duration=%lu ms bytes=%u",
      static_cast<unsigned>(m_song.eventCount),
      static_cast<unsigned long>(m_song.durationMs),
      static_cast<unsigned>(m_lastUploadedFileSize));
  sendResponse(
      m_currentRequest,
      200,
      "text/plain; charset=utf-8",
      "Song uploaded and loaded");
}

size_t App::buildStatusJson(char* dst, size_t capacity) const {
  uint8_t channelActiveCounts[16] = {0};
  uint32_t channelToneMasks[16] = {0};
  uint8_t channelPrograms[16];
  memset(channelPrograms, 0xff, sizeof(channelPrograms));
  for (uint8_t i = 0; i < m_activeVoiceLimit; ++i) {
    const VoiceState& voice = m_voices[i];
    if (!voice.hotCore.active) {
      continue;
    }
    const uint8_t channel = voice.cold.channel & 0x0f;
    if (channel < 16) {
      ++channelActiveCounts[channel];
      const uint8_t toneBit = static_cast<uint8_t>(voice.cold.toneClass);
      channelPrograms[channel] = toneBit;
      if (toneBit < 32) {
        channelToneMasks[channel] |= (static_cast<uint32_t>(1) << toneBit);
      }
    }
  }

  if (dst == nullptr || capacity == 0) {
    return 0;
  }

  size_t length = 0;
  dst[0] = '\0';
  appendRaw(dst, capacity, length, "{");
  appendRaw(dst, capacity, length, "\"btReady\":");
  appendBool(dst, capacity, length, m_btReady);
  appendRaw(dst, capacity, length, ",\"a2dpReady\":");
  appendBool(dst, capacity, length, m_a2dpReady);
  appendRaw(dst, capacity, length, ",\"a2dpConnected\":");
  appendBool(dst, capacity, length, m_a2dpConnected);
  appendRaw(dst, capacity, length, ",\"discoveryRunning\":");
  appendBool(dst, capacity, length, m_discoveryRunning);
  appendRaw(dst, capacity, length, ",\"playing\":");
  appendBool(dst, capacity, length, m_playing);
  appendRaw(dst, capacity, length, ",\"voiceLimit\":");
  appendUnsigned(dst, capacity, length, m_activeVoiceLimit);
  appendRaw(dst, capacity, length, ",\"toneOverrideEnabled\":");
  appendBool(dst, capacity, length, m_toneOverrideEnabled);
  appendRaw(dst, capacity, length, ",\"toneOverrideClass\":");
  appendUnsigned(
      dst,
      capacity,
      length,
      static_cast<uint32_t>(m_toneOverrideClass));
  appendRaw(dst, capacity, length, ",\"activeVoiceCount\":");
  appendUnsigned(dst, capacity, length, activeVoiceCount());
  appendRaw(dst, capacity, length, ",\"channelActiveCounts\":[");
  for (uint8_t channel = 0; channel < 16; ++channel) {
    if (channel > 0) appendChar(dst, capacity, length, ',');
    appendUnsigned(dst, capacity, length, channelActiveCounts[channel]);
  }
  appendRaw(dst, capacity, length, "]");
  appendRaw(dst, capacity, length, ",\"channelPrograms\":[");
  for (uint8_t channel = 0; channel < 16; ++channel) {
    if (channel > 0) appendChar(dst, capacity, length, ',');
    appendUnsigned(dst, capacity, length, channelPrograms[channel]);
  }
  appendRaw(dst, capacity, length, "]");
  appendRaw(dst, capacity, length, ",\"channelToneMasks\":[");
  for (uint8_t channel = 0; channel < 16; ++channel) {
    if (channel > 0) appendChar(dst, capacity, length, ',');
    appendUnsigned(dst, capacity, length, channelToneMasks[channel]);
  }
  appendRaw(dst, capacity, length, "]");
  appendRaw(dst, capacity, length, ",\"sampleRateHz\":");
  appendUnsigned(dst, capacity, length, m_sampleRateHz);
  appendRaw(dst, capacity, length, ",\"waveTableSet\":\"");
  appendEscapedJson(dst, capacity, length, waveTableSetToText(m_waveTableSet));
  appendRaw(dst, capacity, length, "\"");
  appendRaw(dst, capacity, length, ",\"connectingAddress\":\"");
  appendEscapedJson(dst, capacity, length, m_connectingAddress);
  appendRaw(dst, capacity, length, "\",\"connectedAddress\":\"");
  appendEscapedJson(dst, capacity, length, m_connectedAddress);
  appendRaw(dst, capacity, length, "\",\"ipAddress\":\"");
  appendRaw(dst, capacity, length, m_ipAddress);
  appendRaw(dst, capacity, length, "\",\"audio\":{\"underrunCount\":");
  appendUnsigned(dst, capacity, length, m_audioUnderrunCount);
  appendRaw(dst, capacity, length, "},\"song\":{\"loaded\":");
  appendBool(dst, capacity, length, m_songLoaded);
  appendRaw(dst, capacity, length, ",\"loadPending\":false,\"loadTaskRunning\":false,\"name\":\"");
  appendEscapedJson(dst, capacity, length, m_song.name);
  appendRaw(dst, capacity, length, "\",\"eventCount\":");
  appendUnsigned(dst, capacity, length, m_song.eventCount);
  appendRaw(dst, capacity, length, ",\"durationMs\":");
  appendUnsigned(dst, capacity, length, m_song.durationMs);
  appendRaw(dst, capacity, length, ",\"storedBytes\":");
  appendUnsigned(dst, capacity, length, getStoredSongSize());
  appendRaw(dst, capacity, length, ",\"lastUploadBytes\":");
  appendUnsigned(dst, capacity, length, m_lastUploadedFileSize);
  appendRaw(dst, capacity, length, ",\"error\":\"");
  appendEscapedJson(dst, capacity, length, m_uploadError);
  appendRaw(dst, capacity, length, "\"}}");
  return length;
}

size_t App::buildBtDevicesJson(char* dst, size_t capacity) const {
  if (dst == nullptr || capacity == 0) {
    return 0;
  }
  size_t length = 0;
  dst[0] = '\0';
  appendRaw(dst, capacity, length, "{\"devices\":[");
  bool first = true;
  for (uint8_t i = 0; i < Config::MaxBtDevices; ++i) {
    if (!m_btDevices[i].inUse) {
      continue;
    }
    if (!first) {
      appendChar(dst, capacity, length, ',');
    }
    first = false;
    appendRaw(dst, capacity, length, "{\"address\":\"");
    appendEscapedJson(dst, capacity, length, m_btDevices[i].address);
    appendRaw(dst, capacity, length, "\",\"name\":\"");
    appendEscapedJson(dst, capacity, length, m_btDevices[i].name);
    appendRaw(dst, capacity, length, "\",\"rssi\":");
    appendSigned(dst, capacity, length, m_btDevices[i].rssi);
    appendChar(dst, capacity, length, '}');
  }
  appendRaw(dst, capacity, length, "]}");
  return length;
}