MeshCoreTel-firmware/examples/simple_repeater/MyMesh.cpp

#include "MyMesh.h"
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <helpers/sensors/LPPDataHelpers.h>

#if defined(TBEAM_1W)
  #include <TBeam1WBoard.h>
#endif

#if defined(ESP32) && WITH_WEB_PANEL
  #include <WiFi.h>
#endif

#ifndef ARCHIVE_DEBUG
  #if defined(MQTT_DEBUG) && MQTT_DEBUG
    #define ARCHIVE_DEBUG 1
  #else
    #define ARCHIVE_DEBUG 0
  #endif
#endif

#if ARCHIVE_DEBUG
  #define ARCHIVE_LOG(fmt, ...) Serial.printf("[ARCHIVE] " fmt "\n", ##__VA_ARGS__)
#else
  #define ARCHIVE_LOG(...) do { } while (0)
#endif

namespace {

int clampBatteryPercentFromRange(uint16_t battery_mv, uint16_t min_mv, uint16_t max_mv) {
  if (max_mv <= min_mv) {
    return 0;
  }
  const long scaled = (static_cast<long>(battery_mv) - static_cast<long>(min_mv)) * 100L /
                      static_cast<long>(max_mv - min_mv);
  return std::max(0L, std::min(100L, scaled));
}

WebSensorSnapshot collectWebSensorSnapshot(mesh::MainBoard& board, SensorManager& sensors, uint16_t battery_mv) {
  WebSensorSnapshot snapshot;
  snapshot.has_battery = true;
  snapshot.battery_mv = battery_mv;

  CayenneLPP sensor_telemetry(200);
  sensor_telemetry.reset();
  sensor_telemetry.addVoltage(TELEM_CHANNEL_SELF, static_cast<float>(battery_mv) / 1000.0f);
  sensors.querySensors(0xFF, sensor_telemetry);

  const float board_temp_c = board.getMCUTemperature();
  if (!isnan(board_temp_c)) {
    sensor_telemetry.addTemperature(TELEM_CHANNEL_SELF, board_temp_c);
  }

  LocationProvider* location = sensors.getLocationProvider();
  if (location != nullptr) {
    snapshot.has_gps = true;
    snapshot.gps_enabled = location->isEnabled();
    snapshot.gps_fix = location->isValid();
    const long satellites = location->satellitesCount();
    if (snapshot.gps_enabled || satellites > 0) {
      snapshot.has_satellites = true;
      snapshot.satellites = max<long>(satellites, 0);
    }
    if (snapshot.gps_fix) {
      snapshot.has_gps_lat = true;
      snapshot.gps_lat = static_cast<float>(location->getLatitude()) / 1000000.0f;
      snapshot.has_gps_lon = true;
      snapshot.gps_lon = static_cast<float>(location->getLongitude()) / 1000000.0f;
      snapshot.has_gps_altitude = true;
      snapshot.gps_altitude_m = static_cast<float>(location->getAltitude()) / 1000.0f;
    }
  }

  float temperatures[4] = {NAN, NAN, NAN, NAN};
  size_t temperature_count = 0;

  LPPReader reader(sensor_telemetry.getBuffer(), sensor_telemetry.getSize());
  uint8_t channel = 0;
  uint8_t type = 0;
  while (reader.readHeader(channel, type)) {
    float value = NAN;
    switch (type) {
      case LPP_GPS: {
        float lat = NAN;
        float lon = NAN;
        float alt = NAN;
        if (reader.readGPS(lat, lon, alt) && !snapshot.has_gps && std::isfinite(lat) && std::isfinite(lon) && std::isfinite(alt)) {
          snapshot.has_gps = true;
          snapshot.gps_enabled = true;
          snapshot.gps_fix = true;
          snapshot.has_gps_lat = true;
          snapshot.gps_lat = lat;
          snapshot.has_gps_lon = true;
          snapshot.gps_lon = lon;
          snapshot.has_gps_altitude = true;
          snapshot.gps_altitude_m = alt;
        }
        break;
      }
      case LPP_VOLTAGE:
        if (reader.readVoltage(value) && channel == TELEM_CHANNEL_SELF && !snapshot.has_supply_voltage) {
          snapshot.has_supply_voltage = std::isfinite(value);
          snapshot.supply_voltage_v = value;
        }
        break;
      case LPP_TEMPERATURE:
        if (reader.readTemperature(value) && temperature_count < 4 && std::isfinite(value)) {
          temperatures[temperature_count++] = value;
        }
        break;
      case LPP_RELATIVE_HUMIDITY:
        if (reader.readRelativeHumidity(value) && !snapshot.has_humidity) {
          snapshot.has_humidity = std::isfinite(value);
          snapshot.humidity_pct = value;
        }
        break;
      case LPP_BAROMETRIC_PRESSURE:
        if (reader.readPressure(value) && !snapshot.has_pressure) {
          snapshot.has_pressure = std::isfinite(value);
          snapshot.pressure_hpa = value;
        }
        break;
      case LPP_ALTITUDE:
        if (reader.readAltitude(value) && !snapshot.has_pressure_altitude) {
          snapshot.has_pressure_altitude = std::isfinite(value);
          snapshot.pressure_altitude_m = value;
        }
        break;
      default:
        reader.skipData(type);
        break;
    }
  }

  if (temperature_count >= 2) {
    snapshot.has_sensor_temp = true;
    snapshot.sensor_temp_c = temperatures[0];
    snapshot.has_mcu_temp = true;
    snapshot.mcu_temp_c = temperatures[temperature_count - 1];
  } else if (temperature_count == 1) {
    if (snapshot.has_humidity || snapshot.has_pressure || snapshot.has_pressure_altitude) {
      snapshot.has_sensor_temp = true;
      snapshot.sensor_temp_c = temperatures[0];
    } else {
      snapshot.has_mcu_temp = true;
      snapshot.mcu_temp_c = temperatures[0];
    }
  }

  return snapshot;
}

bool appendJsonBoolField(char* reply, size_t reply_size, size_t& offset, bool& needs_comma, const char* key, bool value) {
  const int written = snprintf(&reply[offset], reply_size - offset, "%s\"%s\":%s", needs_comma ? "," : "", key, value ? "true" : "false");
  if (written < 0 || static_cast<size_t>(written) >= (reply_size - offset)) {
    return false;
  }
  offset += static_cast<size_t>(written);
  needs_comma = true;
  return true;
}

bool appendJsonLongField(char* reply, size_t reply_size, size_t& offset, bool& needs_comma, const char* key, long value) {
  const int written = snprintf(&reply[offset], reply_size - offset, "%s\"%s\":%ld", needs_comma ? "," : "", key, value);
  if (written < 0 || static_cast<size_t>(written) >= (reply_size - offset)) {
    return false;
  }
  offset += static_cast<size_t>(written);
  needs_comma = true;
  return true;
}

bool appendJsonFloatField(char* reply, size_t reply_size, size_t& offset, bool& needs_comma, const char* key, float value, int precision) {
  if (!std::isfinite(value)) {
    return true;
  }
  const int written = snprintf(&reply[offset], reply_size - offset, "%s\"%s\":%.*f", needs_comma ? "," : "", key, precision, value);
  if (written < 0 || static_cast<size_t>(written) >= (reply_size - offset)) {
    return false;
  }
  offset += static_cast<size_t>(written);
  needs_comma = true;
  return true;
}

constexpr unsigned long kArchiveNeighboursFlushIntervalMs = 60UL * 1000UL;
constexpr const char* kArchiveNeighboursSnapshotPath = "/stats/neighbours.snapshot";
constexpr const char* kArchiveNeighboursLatestPath = "/stats/neighbours.latest";

bool buildUtcDailyArchivePath(const char* prefix, uint32_t epoch_secs, char* path, size_t path_size) {
  if (prefix == nullptr || path == nullptr || path_size == 0) {
    return false;
  }
  if (epoch_secs == 0) {
    snprintf(path, path_size, "/stats/%s-unknown.log", prefix);
    return true;
  }
  const DateTime dt(epoch_secs);
  snprintf(path, path_size, "/stats/%s-%04d-%02d-%02d.log", prefix, dt.year(), dt.month(), dt.day());
  return true;
}

File openArchiveWrite(FILESYSTEM* fs, const char* filename) {
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
  fs->remove(filename);
  return fs->open(filename, FILE_O_WRITE);
#elif defined(RP2040_PLATFORM)
  return fs->open(filename, "w");
#else
  fs->remove(filename);
  return fs->open(filename, FILE_WRITE);
#endif
}

File openArchiveRead(FILESYSTEM* fs, const char* filename) {
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) || defined(RP2040_PLATFORM)
  return fs->open(filename, "r");
#else
  return fs->open(filename, FILE_READ);
#endif
}

File openArchiveWriteWithRecovery(ArchiveStorage* archive, const char* filename) {
  if (archive == nullptr) {
    return File();
  }
  FILESYSTEM* fs = archive->getFS();
  if (fs == nullptr) {
    return File();
  }
  File file = openArchiveWrite(fs, filename);
  if (file) {
    return file;
  }
  if (!archive->recover()) {
    return File();
  }
  fs = archive->getFS();
  return fs != nullptr ? openArchiveWrite(fs, filename) : File();
}

File openArchiveAppend(FILESYSTEM* fs, const char* filename) {
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) || defined(RP2040_PLATFORM)
  return fs->open(filename, "a");
#else
  return fs->open(filename, FILE_APPEND, true);
#endif
}

File openArchiveAppendWithRecovery(ArchiveStorage* archive, const char* filename) {
  if (archive == nullptr) {
    return File();
  }
  FILESYSTEM* fs = archive->getFS();
  if (fs == nullptr) {
    return File();
  }
  File file = openArchiveAppend(fs, filename);
  if (file) {
    return file;
  }
  if (!archive->recover()) {
    return File();
  }
  fs = archive->getFS();
  return fs != nullptr ? openArchiveAppend(fs, filename) : File();
}

File openArchiveReadWithRecovery(ArchiveStorage* archive, const char* filename) {
  if (archive == nullptr) {
    return File();
  }
  FILESYSTEM* fs = archive->getFS();
  if (fs == nullptr) {
    return File();
  }
  File file = openArchiveRead(fs, filename);
  if (file) {
    return file;
  }
  if (!archive->recover()) {
    return File();
  }
  fs = archive->getFS();
  return fs != nullptr ? openArchiveRead(fs, filename) : File();
}

void escapeJsonString(const char* input, char* output, size_t output_size) {
  if (output == nullptr || output_size == 0) {
    return;
  }

  size_t oi = 0;
  for (size_t i = 0; input != nullptr && input[i] != 0 && oi + 1 < output_size; ++i) {
    const char c = input[i];
    const char* escape = nullptr;
    switch (c) {
      case '\\':
        escape = "\\\\";
        break;
      case '"':
        escape = "\\\"";
        break;
      case '\n':
        escape = "\\n";
        break;
      case '\r':
        escape = "\\r";
        break;
      case '\t':
        escape = "\\t";
        break;
      default:
        break;
    }

    if (escape != nullptr) {
      while (*escape != 0 && oi + 1 < output_size) {
        output[oi++] = *escape++;
      }
    } else {
      output[oi++] = c;
    }
  }
  output[oi] = 0;
}

}  // namespace

/* ------------------------------ Config -------------------------------- */

#ifndef LORA_FREQ
  #define LORA_FREQ 915.0
#endif
#ifndef LORA_BW
  #define LORA_BW 250
#endif
#ifndef LORA_SF
  #define LORA_SF 10
#endif
#ifndef LORA_CR
  #define LORA_CR 5
#endif
#ifndef LORA_TX_POWER
  #define LORA_TX_POWER 20
#endif

#ifndef ADVERT_NAME
  #define ADVERT_NAME "repeater"
#endif
#ifndef ADVERT_LAT
  #define ADVERT_LAT 0.0
#endif
#ifndef ADVERT_LON
  #define ADVERT_LON 0.0
#endif

#ifndef ADMIN_PASSWORD
  #define ADMIN_PASSWORD "password"
#endif

#ifndef SERVER_RESPONSE_DELAY
  #define SERVER_RESPONSE_DELAY 300
#endif

#ifndef TXT_ACK_DELAY
  #define TXT_ACK_DELAY 200
#endif

#define FIRMWARE_VER_LEVEL       2

#define REQ_TYPE_GET_STATUS         0x01 // same as _GET_STATS
#define REQ_TYPE_KEEP_ALIVE         0x02
#define REQ_TYPE_GET_TELEMETRY_DATA 0x03
#define REQ_TYPE_GET_ACCESS_LIST    0x05
#define REQ_TYPE_GET_NEIGHBOURS     0x06
#define REQ_TYPE_GET_OWNER_INFO     0x07     // FIRMWARE_VER_LEVEL >= 2

#define RESP_SERVER_LOGIN_OK        0 // response to ANON_REQ

#define ANON_REQ_TYPE_REGIONS      0x01
#define ANON_REQ_TYPE_OWNER        0x02
#define ANON_REQ_TYPE_BASIC        0x03   // just remote clock

#define CLI_REPLY_DELAY_MILLIS      600

#define LAZY_CONTACTS_WRITE_DELAY    5000

void MyMesh::putNeighbour(const mesh::Identity &id, uint32_t timestamp, float snr) {
#if MAX_NEIGHBOURS // check if neighbours enabled
  // find existing neighbour, else use least recently updated
  uint32_t oldest_timestamp = 0xFFFFFFFF;
  NeighbourInfo *neighbour = &neighbours[0];
  for (int i = 0; i < MAX_NEIGHBOURS; i++) {
    // if neighbour already known, we should update it
    if (id.matches(neighbours[i].id)) {
      neighbour = &neighbours[i];
      break;
    }

    // otherwise we should update the least recently updated neighbour
    if (neighbours[i].heard_timestamp < oldest_timestamp) {
      neighbour = &neighbours[i];
      oldest_timestamp = neighbour->heard_timestamp;
    }
  }

  // update neighbour info
  neighbour->id = id;
  neighbour->advert_timestamp = timestamp;
  neighbour->heard_timestamp = getRTCClock()->getCurrentTime();
  neighbour->snr = (int8_t)(snr * 4);
  _archive_neighbours_dirty = true;
#endif
}

uint8_t MyMesh::handleLoginReq(const mesh::Identity& sender, const uint8_t* secret, uint32_t sender_timestamp, const uint8_t* data, bool is_flood) {
  ClientInfo* client = NULL;
  if (data[0] == 0) {   // blank password, just check if sender is in ACL
    client = acl.getClient(sender.pub_key, PUB_KEY_SIZE);
    if (client == NULL) {
    #if MESH_DEBUG
      MESH_DEBUG_PRINTLN("Login, sender not in ACL");
    #endif
    }
  }
  if (client == NULL) {
    uint8_t perms;
    if (strcmp((char *)data, _prefs.password) == 0) { // check for valid admin password
      perms = PERM_ACL_ADMIN;
    } else if (strcmp((char *)data, _prefs.guest_password) == 0) { // check guest password
      perms = PERM_ACL_GUEST;
    } else {
#if MESH_DEBUG
      MESH_DEBUG_PRINTLN("Invalid password: %s", data);
#endif
      return 0;
    }

    client = acl.putClient(sender, 0);  // add to contacts (if not already known)
    if (sender_timestamp <= client->last_timestamp) {
      MESH_DEBUG_PRINTLN("Possible login replay attack!");
      return 0;  // FATAL: client table is full -OR- replay attack
    }

    MESH_DEBUG_PRINTLN("Login success!");
    client->last_timestamp = sender_timestamp;
    client->last_activity = getRTCClock()->getCurrentTime();
    client->permissions &= ~0x03;
    client->permissions |= perms;
    memcpy(client->shared_secret, secret, PUB_KEY_SIZE);

    if (perms != PERM_ACL_GUEST) {   // keep number of FS writes to a minimum
      dirty_contacts_expiry = futureMillis(LAZY_CONTACTS_WRITE_DELAY);
    }
  }

  if (is_flood) {
    client->out_path_len = OUT_PATH_UNKNOWN;  // need to rediscover out_path
  }

  uint32_t now = getRTCClock()->getCurrentTimeUnique();
  memcpy(reply_data, &now, 4);   // response packets always prefixed with timestamp
  reply_data[4] = RESP_SERVER_LOGIN_OK;
  reply_data[5] = 0;  // Legacy: was recommended keep-alive interval (secs / 16)
  reply_data[6] = client->isAdmin() ? 1 : 0;
  reply_data[7] = client->permissions;
  getRNG()->random(&reply_data[8], 4);   // random blob to help packet-hash uniqueness
  reply_data[12] = FIRMWARE_VER_LEVEL;  // New field

  return 13;  // reply length
}

uint8_t MyMesh::handleAnonRegionsReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data) {
  if (anon_limiter.allow(rtc_clock.getCurrentTime())) {
    // request data has: {reply-path-len}{reply-path}
    reply_path_len = *data & 63;
    reply_path_hash_size = (*data >> 6) + 1;
    data++;

    memcpy(reply_path, data, ((uint8_t)reply_path_len) * reply_path_hash_size);
    // data += (uint8_t)reply_path_len * reply_path_hash_size;

    memcpy(reply_data, &sender_timestamp, 4);   // prefix with sender_timestamp, like a tag
    uint32_t now = getRTCClock()->getCurrentTime();
    memcpy(&reply_data[4], &now, 4);     // include our clock (for easy clock sync, and packet hash uniqueness)

    return 8 + region_map.exportNamesTo((char *) &reply_data[8], sizeof(reply_data) - 12, REGION_DENY_FLOOD);   // reply length
  }
  return 0;
}

uint8_t MyMesh::handleAnonOwnerReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data) {
  if (anon_limiter.allow(rtc_clock.getCurrentTime())) {
    // request data has: {reply-path-len}{reply-path}
    reply_path_len = *data & 63;
    reply_path_hash_size = (*data >> 6) + 1;
    data++;

    memcpy(reply_path, data, ((uint8_t)reply_path_len) * reply_path_hash_size);
    // data += (uint8_t)reply_path_len * reply_path_hash_size;

    memcpy(reply_data, &sender_timestamp, 4);   // prefix with sender_timestamp, like a tag
    uint32_t now = getRTCClock()->getCurrentTime();
    memcpy(&reply_data[4], &now, 4);     // include our clock (for easy clock sync, and packet hash uniqueness)
    sprintf((char *) &reply_data[8], "%s\n%s", _prefs.node_name, _prefs.owner_info);

    return 8 + strlen((char *) &reply_data[8]);   // reply length
  }
  return 0;
}

uint8_t MyMesh::handleAnonClockReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data) {
  if (anon_limiter.allow(rtc_clock.getCurrentTime())) {
    // request data has: {reply-path-len}{reply-path}
    reply_path_len = *data & 63;
    reply_path_hash_size = (*data >> 6) + 1;
    data++;

    memcpy(reply_path, data, ((uint8_t)reply_path_len) * reply_path_hash_size);
    // data += (uint8_t)reply_path_len * reply_path_hash_size;

    memcpy(reply_data, &sender_timestamp, 4);   // prefix with sender_timestamp, like a tag
    uint32_t now = getRTCClock()->getCurrentTime();
    memcpy(&reply_data[4], &now, 4);     // include our clock (for easy clock sync, and packet hash uniqueness)
    reply_data[8] = 0;  // features
#ifdef WITH_RS232_BRIDGE
    reply_data[8] |= 0x01;  // is bridge, type UART
#elif WITH_ESPNOW_BRIDGE
    reply_data[8] |= 0x03;  // is bridge, type ESP-NOW
#endif
    if (_prefs.disable_fwd) {   // is this repeater currently disabled
      reply_data[8] |= 0x80;  // is disabled
    }
    // TODO:  add some kind of moving-window utilisation metric, so can query 'how busy' is this repeater
    return 9;   // reply length
  }
  return 0;
}

int MyMesh::handleRequest(ClientInfo *sender, uint32_t sender_timestamp, uint8_t *payload, size_t payload_len) {
  // uint32_t now = getRTCClock()->getCurrentTimeUnique();
  // memcpy(reply_data, &now, 4);   // response packets always prefixed with timestamp
  memcpy(reply_data, &sender_timestamp, 4); // reflect sender_timestamp back in response packet (kind of like a 'tag')

  if (payload[0] == REQ_TYPE_GET_STATUS) {  // guests can also access this now
    RepeaterStats stats;
    stats.batt_milli_volts = getBatteryMilliVolts(true);
    stats.curr_tx_queue_len = _mgr->getOutboundTotal();
    stats.noise_floor = (int16_t)_radio->getNoiseFloor();
    stats.last_rssi = (int16_t)radio_driver.getLastRSSI();
    stats.n_packets_recv = radio_driver.getPacketsRecv();
    stats.n_packets_sent = radio_driver.getPacketsSent();
    stats.total_air_time_secs = getTotalAirTime() / 1000;
    stats.total_up_time_secs = uptime_millis / 1000;
    stats.n_sent_flood = getNumSentFlood();
    stats.n_sent_direct = getNumSentDirect();
    stats.n_recv_flood = getNumRecvFlood();
    stats.n_recv_direct = getNumRecvDirect();
    stats.err_events = _err_flags;
    stats.last_snr = (int16_t)(radio_driver.getLastSNR() * 4);
    stats.n_direct_dups = ((SimpleMeshTables *)getTables())->getNumDirectDups();
    stats.n_flood_dups = ((SimpleMeshTables *)getTables())->getNumFloodDups();
    stats.total_rx_air_time_secs = getReceiveAirTime() / 1000;
    stats.n_recv_errors = radio_driver.getPacketsRecvErrors();
    memcpy(&reply_data[4], &stats, sizeof(stats));

    return 4 + sizeof(stats); //  reply_len
  }
  if (payload[0] == REQ_TYPE_GET_TELEMETRY_DATA) {
    uint8_t perm_mask = ~(payload[1]); // NEW: first reserved byte (of 4), is now inverse mask to apply to permissions

    telemetry.reset();
    telemetry.addVoltage(TELEM_CHANNEL_SELF, (float)getBatteryMilliVolts(true) / 1000.0f);

    // query other sensors -- target specific
    if ((sender->permissions & PERM_ACL_ROLE_MASK) == PERM_ACL_GUEST) {
      perm_mask = 0x00;  // just base telemetry allowed
    }
    sensors.querySensors(perm_mask, telemetry);

	// This default temperature will be overridden by external sensors (if any)
    float temperature = board.getMCUTemperature();
    if(!isnan(temperature)) { // Supported boards with built-in temperature sensor. ESP32-C3 may return NAN
      telemetry.addTemperature(TELEM_CHANNEL_SELF, temperature); // Built-in MCU Temperature
    }

    uint8_t tlen = telemetry.getSize();
    memcpy(&reply_data[4], telemetry.getBuffer(), tlen);
    return 4 + tlen; // reply_len
  }
  if (payload[0] == REQ_TYPE_GET_ACCESS_LIST && sender->isAdmin()) {
    uint8_t res1 = payload[1];   // reserved for future  (extra query params)
    uint8_t res2 = payload[2];
    if (res1 == 0 && res2 == 0) {
      uint8_t ofs = 4;
      for (int i = 0; i < acl.getNumClients() && ofs + 7 <= sizeof(reply_data) - 4; i++) {
        auto c = acl.getClientByIdx(i);
        if (c->permissions == 0) continue;  // skip deleted entries
        memcpy(&reply_data[ofs], c->id.pub_key, 6); ofs += 6;  // just 6-byte pub_key prefix
        reply_data[ofs++] = c->permissions;
      }
      return ofs;
    }
  }
  if (payload[0] == REQ_TYPE_GET_NEIGHBOURS) {
    uint8_t request_version = payload[1];
    if (request_version == 0) {

      // reply data offset (after response sender_timestamp/tag)
      int reply_offset = 4;

      // get request params
      uint8_t count = payload[2]; // how many neighbours to fetch (0-255)
      uint16_t offset;
      memcpy(&offset, &payload[3], 2); // offset from start of neighbours list (0-65535)
      uint8_t order_by = payload[5]; // how to order neighbours. 0=newest_to_oldest, 1=oldest_to_newest, 2=strongest_to_weakest, 3=weakest_to_strongest
      uint8_t pubkey_prefix_length = payload[6]; // how many bytes of neighbour pub key we want
      // we also send a 4 byte random blob in payload[7...10] to help packet uniqueness

      MESH_DEBUG_PRINTLN("REQ_TYPE_GET_NEIGHBOURS count=%d, offset=%d, order_by=%d, pubkey_prefix_length=%d", count, offset, order_by, pubkey_prefix_length);

      // clamp pub key prefix length to max pub key length
      if(pubkey_prefix_length > PUB_KEY_SIZE){
        pubkey_prefix_length = PUB_KEY_SIZE;
        MESH_DEBUG_PRINTLN("REQ_TYPE_GET_NEIGHBOURS invalid pubkey_prefix_length=%d clamping to %d", pubkey_prefix_length, PUB_KEY_SIZE);
      }

      // create copy of neighbours list, skipping empty entries so we can sort it separately from main list
      int16_t neighbours_count = 0;
#if MAX_NEIGHBOURS
      NeighbourInfo* sorted_neighbours[MAX_NEIGHBOURS];
      for (int i = 0; i < MAX_NEIGHBOURS; i++) {
        auto neighbour = &neighbours[i];
        if (neighbour->heard_timestamp > 0) {
          sorted_neighbours[neighbours_count] = neighbour;
          neighbours_count++;
        }
      }

      // sort neighbours based on order
      if (order_by == 0) {
        // sort by newest to oldest
        MESH_DEBUG_PRINTLN("REQ_TYPE_GET_NEIGHBOURS sorting newest to oldest");
        std::sort(sorted_neighbours, sorted_neighbours + neighbours_count, [](const NeighbourInfo* a, const NeighbourInfo* b) {
          return a->heard_timestamp > b->heard_timestamp; // desc
        });
      } else if (order_by == 1) {
        // sort by oldest to newest
        MESH_DEBUG_PRINTLN("REQ_TYPE_GET_NEIGHBOURS sorting oldest to newest");
        std::sort(sorted_neighbours, sorted_neighbours + neighbours_count, [](const NeighbourInfo* a, const NeighbourInfo* b) {
          return a->heard_timestamp < b->heard_timestamp; // asc
        });
      } else if (order_by == 2) {
        // sort by strongest to weakest
        MESH_DEBUG_PRINTLN("REQ_TYPE_GET_NEIGHBOURS sorting strongest to weakest");
        std::sort(sorted_neighbours, sorted_neighbours + neighbours_count, [](const NeighbourInfo* a, const NeighbourInfo* b) {
          return a->snr > b->snr; // desc
        });
      } else if (order_by == 3) {
        // sort by weakest to strongest
        MESH_DEBUG_PRINTLN("REQ_TYPE_GET_NEIGHBOURS sorting weakest to strongest");
        std::sort(sorted_neighbours, sorted_neighbours + neighbours_count, [](const NeighbourInfo* a, const NeighbourInfo* b) {
          return a->snr < b->snr; // asc
        });
      }
#endif

      // build results buffer
      int results_count = 0;
      int results_offset = 0;
      uint8_t results_buffer[130];
      for(int index = 0; index < count && index + offset < neighbours_count; index++){
        
        // stop if we can't fit another entry in results
        int entry_size = pubkey_prefix_length + 4 + 1;
        if(results_offset + entry_size > sizeof(results_buffer)){
          MESH_DEBUG_PRINTLN("REQ_TYPE_GET_NEIGHBOURS no more entries can fit in results buffer");
          break;
        }

#if MAX_NEIGHBOURS
        // add next neighbour to results
        auto neighbour = sorted_neighbours[index + offset];
        uint32_t heard_seconds_ago = getRTCClock()->getCurrentTime() - neighbour->heard_timestamp;
        memcpy(&results_buffer[results_offset], neighbour->id.pub_key, pubkey_prefix_length); results_offset += pubkey_prefix_length;
        memcpy(&results_buffer[results_offset], &heard_seconds_ago, 4); results_offset += 4;
        memcpy(&results_buffer[results_offset], &neighbour->snr, 1); results_offset += 1;
        results_count++;
#endif

      }

      // build reply
      MESH_DEBUG_PRINTLN("REQ_TYPE_GET_NEIGHBOURS neighbours_count=%d results_count=%d", neighbours_count, results_count);
      memcpy(&reply_data[reply_offset], &neighbours_count, 2); reply_offset += 2;
      memcpy(&reply_data[reply_offset], &results_count, 2); reply_offset += 2;
      memcpy(&reply_data[reply_offset], &results_buffer, results_offset); reply_offset += results_offset;

      return reply_offset;
    }
  } else if (payload[0] == REQ_TYPE_GET_OWNER_INFO) {
    sprintf((char *) &reply_data[4], "%s\n%s\n%s", FIRMWARE_VERSION, _prefs.node_name, _prefs.owner_info);
    return 4 + strlen((char *) &reply_data[4]);
  }
  return 0; // unknown command
}

mesh::Packet *MyMesh::createSelfAdvert() {
  uint8_t app_data[MAX_ADVERT_DATA_SIZE];
  uint8_t app_data_len = _cli.buildAdvertData(ADV_TYPE_REPEATER, app_data);

  return createAdvert(self_id, app_data, app_data_len);
}

File MyMesh::openAppend(const char *fname) {
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
  return _fs->open(fname, FILE_O_WRITE);
#elif defined(RP2040_PLATFORM)
  return _fs->open(fname, "a");
#else
  return _fs->open(fname, "a", true);
#endif
}

static uint8_t max_loop_minimal[] =  { 0, /* 1-byte */  4, /* 2-byte */  2, /* 3-byte */  1 };
static uint8_t max_loop_moderate[] = { 0, /* 1-byte */  2, /* 2-byte */  1, /* 3-byte */  1 };
static uint8_t max_loop_strict[] =   { 0, /* 1-byte */  1, /* 2-byte */  1, /* 3-byte */  1 };

bool MyMesh::isLooped(const mesh::Packet* packet, const uint8_t max_counters[]) {
  uint8_t hash_size = packet->getPathHashSize();
  uint8_t hash_count = packet->getPathHashCount();
  uint8_t n = 0;
  const uint8_t* path = packet->path;
  while (hash_count > 0) {      // count how many times this node is already in the path
    if (self_id.isHashMatch(path, hash_size)) n++;
    hash_count--;
    path += hash_size;
  }
  return n >= max_counters[hash_size];
}

void MyMesh::sendFloodReply(mesh::Packet* packet, unsigned long delay_millis, uint8_t path_hash_size) {
  if (recv_pkt_region && !recv_pkt_region->isWildcard()) {  // if _request_ packet scope is known, send reply with same scope
    TransportKey scope;
    if (region_map.getTransportKeysFor(*recv_pkt_region, &scope, 1) > 0) {
      sendFloodScoped(scope, packet, delay_millis, path_hash_size);
    } else {
      sendFlood(packet, delay_millis, path_hash_size);  // send un-scoped
    }
  } else {
    sendFlood(packet, delay_millis, path_hash_size);  // send un-scoped
  }
}

bool MyMesh::allowPacketForward(const mesh::Packet *packet) {
  if (_prefs.disable_fwd) return false;
  if (packet->isRouteFlood()) {
    if (packet->getPathHashCount() >= _prefs.flood_max) return false;
    if (packet->getRouteType() == ROUTE_TYPE_FLOOD && packet->getPathHashCount() >= _prefs.flood_max_unscoped) return false;
    if (packet->getPayloadType() == PAYLOAD_TYPE_ADVERT && packet->getPathHashCount() >= _prefs.flood_max_advert) return false;
  }
  if (packet->isRouteFlood() && recv_pkt_region == NULL) {
    MESH_DEBUG_PRINTLN("allowPacketForward: unknown transport code, or wildcard not allowed for FLOOD packet");
    return false;
  }
  if (packet->isRouteFlood() && _prefs.loop_detect != LOOP_DETECT_OFF) {
    const uint8_t* maximums;
    if (_prefs.loop_detect == LOOP_DETECT_MINIMAL) {
      maximums = max_loop_minimal;
    } else if (_prefs.loop_detect == LOOP_DETECT_MODERATE) {
      maximums = max_loop_moderate;
    } else {
      maximums = max_loop_strict;
    }
    if (isLooped(packet, maximums)) {
      MESH_DEBUG_PRINTLN("allowPacketForward: FLOOD packet loop detected!");
      return false;
    }
  }
  return true;
}

const char *MyMesh::getLogDateTime() {
  static char tmp[32];
  uint32_t now = getRTCClock()->getCurrentTime();
  DateTime dt = DateTime(now);
  sprintf(tmp, "%02d:%02d:%02d - %d/%d/%d U", dt.hour(), dt.minute(), dt.second(), dt.day(), dt.month(),
          dt.year());
  return tmp;
}

void MyMesh::logRxRaw(float snr, float rssi, const uint8_t raw[], int len) {
#if MESH_PACKET_LOGGING
  Serial.print(getLogDateTime());
  Serial.print(" RAW: ");
  mesh::Utils::printHex(Serial, raw, len);
  Serial.println();
#endif
}

void MyMesh::logRx(mesh::Packet *pkt, int len, float score) {
#ifdef WITH_BRIDGE
  if (_prefs.bridge_pkt_src == 1) {
    bridge.sendPacket(pkt);
  }
#endif
#ifdef WITH_MQTT_UPLINK
  mqtt.publishPacket(*pkt, false, (int)_radio->getLastRSSI(), _radio->getLastSNR(), (int)(score * 1000),
                     (int)_radio->getEstAirtimeFor(len));
#endif

  if (_logging) {
    File f = openAppend(PACKET_LOG_FILE);
    if (f) {
      f.print(getLogDateTime());
      f.printf(": RX, len=%d (type=%d, route=%s, payload_len=%d) SNR=%d RSSI=%d score=%d", len,
               pkt->getPayloadType(), pkt->isRouteDirect() ? "D" : "F", pkt->payload_len,
               (int)_radio->getLastSNR(), (int)_radio->getLastRSSI(), (int)(score * 1000));

      if (pkt->getPayloadType() == PAYLOAD_TYPE_PATH || pkt->getPayloadType() == PAYLOAD_TYPE_REQ ||
          pkt->getPayloadType() == PAYLOAD_TYPE_RESPONSE || pkt->getPayloadType() == PAYLOAD_TYPE_TXT_MSG) {
        f.printf(" [%02X -> %02X]\n", (uint32_t)pkt->payload[1], (uint32_t)pkt->payload[0]);
      } else {
        f.printf("\n");
      }
      f.close();
    }
  }
}

void MyMesh::logTx(mesh::Packet *pkt, int len) {
#ifdef WITH_BRIDGE
  if (_prefs.bridge_pkt_src == 0) {
    bridge.sendPacket(pkt);
  }
#endif
#ifdef WITH_MQTT_UPLINK
  mqtt.publishPacket(*pkt, true, (int)_radio->getLastRSSI(), _radio->getLastSNR());
#endif

  if (_logging) {
    File f = openAppend(PACKET_LOG_FILE);
    if (f) {
      f.print(getLogDateTime());
      f.printf(": TX, len=%d (type=%d, route=%s, payload_len=%d)", len, pkt->getPayloadType(),
               pkt->isRouteDirect() ? "D" : "F", pkt->payload_len);

      if (pkt->getPayloadType() == PAYLOAD_TYPE_PATH || pkt->getPayloadType() == PAYLOAD_TYPE_REQ ||
          pkt->getPayloadType() == PAYLOAD_TYPE_RESPONSE || pkt->getPayloadType() == PAYLOAD_TYPE_TXT_MSG) {
        f.printf(" [%02X -> %02X]\n", (uint32_t)pkt->payload[1], (uint32_t)pkt->payload[0]);
      } else {
        f.printf("\n");
      }
      f.close();
    }
  }
}

void MyMesh::logTxFail(mesh::Packet *pkt, int len) {
  if (_logging) {
    File f = openAppend(PACKET_LOG_FILE);
    if (f) {
      f.print(getLogDateTime());
      f.printf(": TX FAIL!, len=%d (type=%d, route=%s, payload_len=%d)\n", len, pkt->getPayloadType(),
               pkt->isRouteDirect() ? "D" : "F", pkt->payload_len);
      f.close();
    }
  }
}

int MyMesh::calcRxDelay(float score, uint32_t air_time) const {
  if (_prefs.rx_delay_base <= 0.0f) return 0;
  return (int)((pow(_prefs.rx_delay_base, 0.85f - score) - 1.0) * air_time);
}

uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) {
  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.tx_delay_factor);
  return getRNG()->nextInt(0, 5*t + 1);
}
uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {
  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
  return getRNG()->nextInt(0, 5*t + 1);
}

bool MyMesh::filterRecvFloodPacket(mesh::Packet* pkt) {
  // just try to determine region for packet (apply later in allowPacketForward())
  if (pkt->getRouteType() == ROUTE_TYPE_TRANSPORT_FLOOD) {
    recv_pkt_region = region_map.findMatch(pkt, REGION_DENY_FLOOD);
  } else if (pkt->getRouteType() == ROUTE_TYPE_FLOOD) {
    if (region_map.getWildcard().flags & REGION_DENY_FLOOD) {
      recv_pkt_region = NULL;
    } else {
      recv_pkt_region =  &region_map.getWildcard();
    }
  } else {
    recv_pkt_region = NULL;
  }
  // do normal processing
  return false;
}

void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const mesh::Identity &sender,
                            uint8_t *data, size_t len) {
  if (packet->getPayloadType() == PAYLOAD_TYPE_ANON_REQ) { // received an initial request by a possible admin
                                                           // client (unknown at this stage)
    uint32_t timestamp;
    memcpy(&timestamp, data, 4);

    data[len] = 0;  // ensure null terminator
    uint8_t reply_len;

    reply_path_len = -1;
    if (data[4] == 0 || data[4] >= ' ') {   // is password, ie. a login request
      reply_len = handleLoginReq(sender, secret, timestamp, &data[4], packet->isRouteFlood());
    } else if (data[4] == ANON_REQ_TYPE_REGIONS && packet->isRouteDirect()) {
      reply_len = handleAnonRegionsReq(sender, timestamp, &data[5]);
    } else if (data[4] == ANON_REQ_TYPE_OWNER && packet->isRouteDirect()) {
      reply_len = handleAnonOwnerReq(sender, timestamp, &data[5]);
    } else if (data[4] == ANON_REQ_TYPE_BASIC && packet->isRouteDirect()) {
      reply_len = handleAnonClockReq(sender, timestamp, &data[5]);
    } else {
      reply_len = 0;  // unknown/invalid request type
    }

    if (reply_len == 0) return;   // invalid request

    if (packet->isRouteFlood()) {
      // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
      mesh::Packet* path = createPathReturn(sender, secret, packet->path, packet->path_len,
                                            PAYLOAD_TYPE_RESPONSE, reply_data, reply_len);
      if (path) sendFloodReply(path, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
    } else if (reply_path_len < 0) {
      mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, secret, reply_data, reply_len);
      if (reply) sendFloodReply(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
    } else {
      mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, secret, reply_data, reply_len);
      uint8_t path_len = ((reply_path_hash_size - 1) << 6) | (reply_path_len & 63);
      if (reply) sendDirect(reply, reply_path,  path_len, SERVER_RESPONSE_DELAY);
    }
  }
}

int MyMesh::searchPeersByHash(const uint8_t *hash) {
  int n = 0;
  for (int i = 0; i < acl.getNumClients(); i++) {
    if (acl.getClientByIdx(i)->id.isHashMatch(hash)) {
      matching_peer_indexes[n++] = i; // store the INDEXES of matching contacts (for subsequent 'peer' methods)
    }
  }
  return n;
}

void MyMesh::getPeerSharedSecret(uint8_t *dest_secret, int peer_idx) {
  int i = matching_peer_indexes[peer_idx];
  if (i >= 0 && i < acl.getNumClients()) {
    // lookup pre-calculated shared_secret
    memcpy(dest_secret, acl.getClientByIdx(i)->shared_secret, PUB_KEY_SIZE);
  } else {
    MESH_DEBUG_PRINTLN("getPeerSharedSecret: Invalid peer idx: %d", i);
  }
}

static bool isShare(const mesh::Packet *packet) {
  if (packet->hasTransportCodes()) {
    return packet->transport_codes[0] == 0 && packet->transport_codes[1] == 0;  // codes { 0, 0 } means 'send to nowhere'
  }
  return false;
}

void MyMesh::onAdvertRecv(mesh::Packet *packet, const mesh::Identity &id, uint32_t timestamp,
                          const uint8_t *app_data, size_t app_data_len) {
  mesh::Mesh::onAdvertRecv(packet, id, timestamp, app_data, app_data_len); // chain to super impl

  // if this a zero hop advert (and not via 'Share'), add it to neighbours
  if (packet->getPathHashCount() == 0 && !isShare(packet)) {
    AdvertDataParser parser(app_data, app_data_len);
    if (parser.isValid() && parser.getType() == ADV_TYPE_REPEATER) { // just keep neigbouring Repeaters
      putNeighbour(id, timestamp, packet->getSNR());
    }
  }
}

void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx, const uint8_t *secret,
                            uint8_t *data, size_t len) {
  int i = matching_peer_indexes[sender_idx];
  if (i < 0 || i >= acl.getNumClients()) { // get from our known_clients table (sender SHOULD already be known in this context)
    MESH_DEBUG_PRINTLN("onPeerDataRecv: invalid peer idx: %d", i);
    return;
  }
  ClientInfo* client = acl.getClientByIdx(i);

  if (type == PAYLOAD_TYPE_REQ) { // request (from a Known admin client!)
    uint32_t timestamp;
    memcpy(&timestamp, data, 4);

    if (timestamp > client->last_timestamp) { // prevent replay attacks
      int reply_len = handleRequest(client, timestamp, &data[4], len - 4);
      if (reply_len == 0) return; // invalid command

      client->last_timestamp = timestamp;
      client->last_activity = getRTCClock()->getCurrentTime();

      if (packet->isRouteFlood()) {
        // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
        mesh::Packet *path = createPathReturn(client->id, secret, packet->path, packet->path_len,
                                              PAYLOAD_TYPE_RESPONSE, reply_data, reply_len);
        if (path) sendFloodReply(path, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
      } else {
        mesh::Packet *reply =
            createDatagram(PAYLOAD_TYPE_RESPONSE, client->id, secret, reply_data, reply_len);
        if (reply) {
          if (client->out_path_len != OUT_PATH_UNKNOWN) { // we have an out_path, so send DIRECT
            sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
          } else {
            sendFloodReply(reply, SERVER_RESPONSE_DELAY, packet->getPathHashSize());
          }
        }
      }
    } else {
      MESH_DEBUG_PRINTLN("onPeerDataRecv: possible replay attack detected");
    }
  } else if (type == PAYLOAD_TYPE_TXT_MSG && len > 5 && client->isAdmin()) { // a CLI command
    uint32_t sender_timestamp;
    memcpy(&sender_timestamp, data, 4); // timestamp (by sender's RTC clock - which could be wrong)
    uint8_t flags = (data[4] >> 2);        // message attempt number, and other flags

    if (!(flags == TXT_TYPE_PLAIN || flags == TXT_TYPE_CLI_DATA)) {
      MESH_DEBUG_PRINTLN("onPeerDataRecv: unsupported text type received: flags=%02x", (uint32_t)flags);
    } else if (sender_timestamp >= client->last_timestamp) { // prevent replay attacks
      bool is_retry = (sender_timestamp == client->last_timestamp);
      client->last_timestamp = sender_timestamp;
      client->last_activity = getRTCClock()->getCurrentTime();

      // len can be > original length, but 'text' will be padded with zeroes
      data[len] = 0; // need to make a C string again, with null terminator

      if (flags == TXT_TYPE_PLAIN) { // for legacy CLI, send Acks
        uint32_t ack_hash; // calc truncated hash of the message timestamp + text + sender pub_key, to prove
                           // to sender that we got it
        mesh::Utils::sha256((uint8_t *)&ack_hash, 4, data, 5 + strlen((char *)&data[5]), client->id.pub_key,
                            PUB_KEY_SIZE);

        mesh::Packet *ack = createAck(ack_hash);
        if (ack) {
          if (client->out_path_len == OUT_PATH_UNKNOWN) {
            sendFloodReply(ack, TXT_ACK_DELAY, packet->getPathHashSize());
          } else {
            sendDirect(ack, client->out_path, client->out_path_len, TXT_ACK_DELAY);
          }
        }
      }

      uint8_t temp[166];
      char *command = (char *)&data[5];
      char *reply = (char *)&temp[5];
      if (is_retry) {
        *reply = 0;
      } else {
        handleCommand(sender_timestamp, command, reply);
      }
      int text_len = strlen(reply);
      if (text_len > 0) {
        uint32_t timestamp = getRTCClock()->getCurrentTimeUnique();
        if (timestamp == sender_timestamp) {
          // WORKAROUND: the two timestamps need to be different, in the CLI view
          timestamp++;
        }
        memcpy(temp, &timestamp, 4);        // mostly an extra blob to help make packet_hash unique
        temp[4] = (TXT_TYPE_CLI_DATA << 2); // NOTE: legacy was: TXT_TYPE_PLAIN

        auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, secret, temp, 5 + text_len);
        if (reply) {
          if (client->out_path_len == OUT_PATH_UNKNOWN) {
            sendFloodReply(reply, CLI_REPLY_DELAY_MILLIS, packet->getPathHashSize());
          } else {
            sendDirect(reply, client->out_path, client->out_path_len, CLI_REPLY_DELAY_MILLIS);
          }
        }
      }
    } else {
      MESH_DEBUG_PRINTLN("onPeerDataRecv: possible replay attack detected");
    }
  }
}

bool MyMesh::onPeerPathRecv(mesh::Packet *packet, int sender_idx, const uint8_t *secret, uint8_t *path,
                            uint8_t path_len, uint8_t extra_type, uint8_t *extra, uint8_t extra_len) {
  // TODO: prevent replay attacks
  int i = matching_peer_indexes[sender_idx];

  if (i >= 0 && i < acl.getNumClients()) { // get from our known_clients table (sender SHOULD already be known in this context)
    MESH_DEBUG_PRINTLN("PATH to client, path_len=%d", (uint32_t)path_len);
    auto client = acl.getClientByIdx(i);

    // store a copy of path, for sendDirect()
    client->out_path_len = mesh::Packet::copyPath(client->out_path, path, path_len);
    client->last_activity = getRTCClock()->getCurrentTime();
  } else {
    MESH_DEBUG_PRINTLN("onPeerPathRecv: invalid peer idx: %d", i);
  }

  // NOTE: no reciprocal path send!!
  return false;
}

#define CTL_TYPE_NODE_DISCOVER_REQ   0x80
#define CTL_TYPE_NODE_DISCOVER_RESP  0x90

void MyMesh::onControlDataRecv(mesh::Packet* packet) {
  uint8_t type = packet->payload[0] & 0xF0;    // just test upper 4 bits
  if (type == CTL_TYPE_NODE_DISCOVER_REQ && packet->payload_len >= 6
      && !_prefs.disable_fwd && discover_limiter.allow(rtc_clock.getCurrentTime())
  ) {
    int i = 1;
    uint8_t  filter = packet->payload[i++];
    uint32_t tag;
    memcpy(&tag, &packet->payload[i], 4); i += 4;
    uint32_t since;
    if (packet->payload_len >= i+4) {   // optional since field
      memcpy(&since, &packet->payload[i], 4); i += 4;
    } else {
      since = 0;
    }

    if ((filter & (1 << ADV_TYPE_REPEATER)) != 0 && _prefs.discovery_mod_timestamp >= since) {
      bool prefix_only = packet->payload[0] & 1;
      uint8_t data[6 + PUB_KEY_SIZE];
      data[0] = CTL_TYPE_NODE_DISCOVER_RESP | ADV_TYPE_REPEATER;   // low 4-bits for node type
      data[1] = packet->_snr;   // let sender know the inbound SNR ( x 4)
      memcpy(&data[2], &tag, 4);     // include tag from request, for client to match to
      memcpy(&data[6], self_id.pub_key, PUB_KEY_SIZE);
      auto resp = createControlData(data, prefix_only ? 6 + 8 : 6 + PUB_KEY_SIZE);
      if (resp) {
        sendZeroHop(resp, getRetransmitDelay(resp)*4);  // apply random delay (widened x4), as multiple nodes can respond to this
      }
    }
  } else if (type == CTL_TYPE_NODE_DISCOVER_RESP && packet->payload_len >= 6) {
    uint8_t node_type = packet->payload[0] & 0x0F;
    if (node_type != ADV_TYPE_REPEATER) {
      return;
    }
    if (packet->payload_len < 6 + PUB_KEY_SIZE) {
      MESH_DEBUG_PRINTLN("onControlDataRecv: DISCOVER_RESP pubkey too short: %d", (uint32_t)packet->payload_len);
      return;
    }

    if (pending_discover_tag == 0 || millisHasNowPassed(pending_discover_until)) {
      pending_discover_tag = 0;
      return;
    }
    uint32_t tag;
    memcpy(&tag, &packet->payload[2], 4);
    if (tag != pending_discover_tag) {
      return;
    }

    mesh::Identity id(&packet->payload[6]);
    if (id.matches(self_id)) {
      return;
    }
    putNeighbour(id, rtc_clock.getCurrentTime(), packet->getSNR());
  }
}

void MyMesh::sendNodeDiscoverReq() {
  uint8_t data[10];
  data[0] = CTL_TYPE_NODE_DISCOVER_REQ; // prefix_only=0
  data[1] = (1 << ADV_TYPE_REPEATER);
  getRNG()->random(&data[2], 4); // tag
  memcpy(&pending_discover_tag, &data[2], 4);
  pending_discover_until = futureMillis(60000);
  uint32_t since = 0;
  memcpy(&data[6], &since, 4);

  auto pkt = createControlData(data, sizeof(data));
  if (pkt) {
    sendZeroHop(pkt);
  }
}

MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondClock &ms, mesh::RNG &rng,
               mesh::RTCClock &rtc, mesh::MeshTables &tables)
    : mesh::Mesh(radio, ms, rng, rtc, *new StaticPoolPacketManager(32), tables),
      region_map(key_store), temp_map(key_store),
      _cli(board, rtc, sensors, region_map, acl, &_prefs, this),
      telemetry(MAX_PACKET_PAYLOAD - 4),
      discover_limiter(4, 120),  // max 4 every 2 minutes
      anon_limiter(4, 180)   // max 4 every 3 minutes
#if defined(WITH_RS232_BRIDGE)
      , bridge(&_prefs, WITH_RS232_BRIDGE, _mgr, &rtc)
#endif
#if defined(WITH_ESPNOW_BRIDGE)
      , bridge(&_prefs, _mgr, &rtc)
#endif
#if defined(WITH_MQTT_UPLINK)
      , mqtt(rtc, self_id)
#endif
{
  last_millis = 0;
  _archive = nullptr;
  uptime_millis = 0;
  next_archive_neighbours_flush_ms = 0;
  next_battery_sample_ms = 0;
  next_history_sample_ms = 0;
  next_local_advert = next_flood_advert = 0;
  dirty_contacts_expiry = 0;
  set_radio_at = revert_radio_at = 0;
  _logging = false;
  _archive_neighbours_dirty = false;
  _battery_sample_valid = false;
  _battery_mv_cache = 0;
  region_load_active = false;
  memset(&_stats_state, 0, sizeof(_stats_state));

#if MAX_NEIGHBOURS
  memset(neighbours, 0, sizeof(neighbours));
#endif

  // defaults
  memset(&_prefs, 0, sizeof(_prefs));
  _prefs.airtime_factor = 1.0;
  _prefs.rx_delay_base = 0.0f;   // turn off by default, was 10.0;
  _prefs.tx_delay_factor = 0.5f; // was 0.25f
  _prefs.direct_tx_delay_factor = 0.3f; // was 0.2
  StrHelper::strncpy(_prefs.node_name, ADVERT_NAME, sizeof(_prefs.node_name));
  _prefs.node_lat = ADVERT_LAT;
  _prefs.node_lon = ADVERT_LON;
  StrHelper::strncpy(_prefs.password, ADMIN_PASSWORD, sizeof(_prefs.password));
  _prefs.freq = LORA_FREQ;
  _prefs.sf = LORA_SF;
  _prefs.bw = LORA_BW;
  _prefs.cr = LORA_CR;
  _prefs.tx_power_dbm = LORA_TX_POWER;
  _prefs.advert_interval = 1;        // default to 2 minutes for NEW installs
  _prefs.flood_advert_interval = 47; // 47 hours
  _prefs.flood_max = 64;
  _prefs.flood_max_unscoped = 64;
  _prefs.flood_max_advert = 8;
  _prefs.interference_threshold = 0; // disabled

  // bridge defaults
  _prefs.bridge_enabled = 1;    // enabled
  _prefs.bridge_delay   = 500;  // milliseconds
  _prefs.bridge_pkt_src = 0;    // logTx
  _prefs.bridge_baud = 115200;  // baud rate
  _prefs.bridge_channel = 1;    // channel 1

  StrHelper::strncpy(_prefs.bridge_secret, "LVSITANOS", sizeof(_prefs.bridge_secret));

  // GPS defaults
  _prefs.gps_enabled = 0;
  _prefs.gps_interval = 0;
  _prefs.advert_loc_policy = ADVERT_LOC_PREFS;

  _prefs.adc_multiplier = 0.0f; // 0.0f means use default board multiplier
  _prefs.reserved_290 = 0;
  _prefs.fan_mode = 0; // auto
  _prefs.fan_timeout_secs = 30;

#if defined(USE_SX1262) || defined(USE_SX1268)
#ifdef SX126X_RX_BOOSTED_GAIN
  _prefs.rx_boosted_gain = SX126X_RX_BOOSTED_GAIN;
#else
  _prefs.rx_boosted_gain = 1; // enabled by default;
#endif
#endif

  pending_discover_tag = 0;
  pending_discover_until = 0;

  memset(default_scope.key, 0, sizeof(default_scope.key));
}

void MyMesh::begin(FILESYSTEM *fs, ArchiveStorage* archive) {
  mesh::Mesh::begin();
#if defined(ESP32)
  _cpu_tracker.begin();
#endif
  _fs = fs;
  _archive = archive;
  last_millis = millis();
  // load persisted prefs
  _cli.loadPrefs(_fs);
  acl.load(_fs, self_id);
  // TODO: key_store.begin();
  region_map.load(_fs);

  // establish default-scope
  {
    RegionEntry* r = region_map.getDefaultRegion();
    if (r) {
      region_map.getTransportKeysFor(*r, &default_scope, 1);
    } else {
#ifdef DEFAULT_FLOOD_SCOPE_NAME
      r = region_map.findByName(DEFAULT_FLOOD_SCOPE_NAME);
      if (r == NULL) {
        r = region_map.putRegion(DEFAULT_FLOOD_SCOPE_NAME, 0);  // auto-create the default scope region
        if (r) { r->flags = 0; }   // Allow-flood
      }
      if (r) {
        region_map.setDefaultRegion(r);
        region_map.getTransportKeysFor(*r, &default_scope, 1);
      }
#endif
    }
  }

#if defined(WITH_BRIDGE)
  if (_prefs.bridge_enabled) {
    bridge.begin();
  }
#endif
#if defined(ESP_PLATFORM)
  uint8_t legacy_wifi_powersave = 0;
  const char* legacy_wifi_ssid = nullptr;
  const char* legacy_wifi_pwd = nullptr;
#ifdef WITH_MQTT_UPLINK
  MQTTPrefs legacy_mqtt_prefs{};
  MQTTPrefsStore::setDefaults(legacy_mqtt_prefs);
  MQTTPrefsStore::load(_fs, legacy_mqtt_prefs);
  legacy_wifi_powersave = legacy_mqtt_prefs.legacy_wifi_powersave;
  legacy_wifi_ssid = legacy_mqtt_prefs.legacy_wifi_ssid;
  legacy_wifi_pwd = legacy_mqtt_prefs.legacy_wifi_pwd;
#endif
  network.begin(_fs, legacy_wifi_powersave, legacy_wifi_ssid, legacy_wifi_pwd);
#endif
#if defined(ESP_PLATFORM) && WITH_WEB_PANEL
  board.setInhibitSleep(true);
  web.setCommandRunner(this);
  web.setNetworkStateProvider(&network);
  web.begin(_fs);
  _stats_history.begin(web.isWebStatsEnabled(), _archive);
  if (web.isWebStatsEnabled() && !_stats_history.isLiveOnly() && _archive != nullptr && _archive->isMounted()) {
    restoreArchiveNeighbours();
    next_archive_neighbours_flush_ms = millis() + kArchiveNeighboursFlushIntervalMs;
  }
  if (web.isWebStatsEnabled()) {
    recordStatsEvent(HISTORY_EVENT_BOOT, board.getResetReason());
    if (_archive != nullptr) {
      recordStatsEvent(_archive->isMounted() ? HISTORY_EVENT_ARCHIVE_MOUNTED : HISTORY_EVENT_ARCHIVE_UNAVAILABLE);
    }
  }
#endif
#if defined(WITH_MQTT_UPLINK) && !(defined(ESP_PLATFORM) && WITH_WEB_PANEL)
  board.setInhibitSleep(true);
#endif
#ifdef WITH_MQTT_UPLINK
  mqtt.setNodeNameSource(_prefs.node_name);
#if defined(ESP_PLATFORM)
  mqtt.setNetworkStateProvider(&network);
#endif
  mqtt.begin(_fs);
#endif

  radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
  radio_driver.setTxPower(_prefs.tx_power_dbm);

  radio_driver.setRxBoostedGainMode(_prefs.rx_boosted_gain);
  MESH_DEBUG_PRINTLN("RX Boosted Gain Mode: %s",
                     radio_driver.getRxBoostedGainMode() ? "Enabled" : "Disabled");

  updateAdvertTimer();
  updateFloodAdvertTimer();

  board.setAdcMultiplier(_prefs.adc_multiplier);
#if defined(TBEAM_1W)
  auto& tbeam1w_board = static_cast<TBeam1WBoard&>(board);
  tbeam1w_board.setFanPostTxHoldMs(static_cast<uint32_t>(_prefs.fan_timeout_secs) * 1000UL);
  tbeam1w_board.setFanMode(static_cast<TBeam1WBoard::FanMode>(_prefs.fan_mode));
#endif

#if ENV_INCLUDE_GPS == 1
  applyGpsPrefs();
#endif

  next_history_sample_ms = futureMillis(1000);
}

void MyMesh::sendFloodScoped(const TransportKey& scope, mesh::Packet* pkt, uint32_t delay_millis, uint8_t path_hash_size) {
  if (scope.isNull()) {
    sendFlood(pkt, delay_millis, path_hash_size);
  } else {
    uint16_t codes[2];
    codes[0] = scope.calcTransportCode(pkt);
    codes[1] = 0;  // REVISIT: set to 'home' Region, for sender/return region?
    sendFlood(pkt, codes, delay_millis, path_hash_size);
  }
}

uint16_t MyMesh::getBatteryMilliVolts(bool force_refresh) {
  constexpr unsigned long kBatterySampleIntervalMs = 60000UL;

  if (force_refresh || !_battery_sample_valid || next_battery_sample_ms == 0 || millisHasNowPassed(next_battery_sample_ms)) {
    _battery_mv_cache = board.getBattMilliVolts();
    _battery_sample_valid = true;
    next_battery_sample_ms = millis() + kBatterySampleIntervalMs;
  }

  return _battery_mv_cache;
}

void MyMesh::applyTempRadioParams(float freq, float bw, uint8_t sf, uint8_t cr, int timeout_mins) {
  set_radio_at = futureMillis(2000); // give CLI reply some time to be sent back, before applying temp radio params
  pending_freq = freq;
  pending_bw = bw;
  pending_sf = sf;
  pending_cr = cr;

  revert_radio_at = futureMillis(2000 + timeout_mins * 60 * 1000); // schedule when to revert radio params
}

bool MyMesh::formatFileSystem() {
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
  return InternalFS.format();
#elif defined(RP2040_PLATFORM)
  return LittleFS.format();
#elif defined(ESP32)
  return SPIFFS.format();
#else
#error "need to implement file system erase"
  return false;
#endif
}

void MyMesh::sendSelfAdvertisement(int delay_millis, bool flood) {
  mesh::Packet *pkt = createSelfAdvert();
  if (pkt) {
    if (flood) {
      sendFloodScoped(default_scope, pkt, delay_millis, _prefs.path_hash_mode + 1);
    } else {
      sendZeroHop(pkt, delay_millis);
    }
  } else {
    MESH_DEBUG_PRINTLN("ERROR: unable to create advertisement packet!");
  }
}

void MyMesh::updateAdvertTimer() {
  if (_prefs.advert_interval > 0) { // schedule local advert timer
    next_local_advert = futureMillis(((uint32_t)_prefs.advert_interval) * 2 * 60 * 1000);
  } else {
    next_local_advert = 0; // stop the timer
  }
}

void MyMesh::updateFloodAdvertTimer() {
  if (_prefs.flood_advert_interval > 0) { // schedule flood advert timer
    next_flood_advert = futureMillis(((uint32_t)_prefs.flood_advert_interval) * 60 * 60 * 1000);
  } else {
    next_flood_advert = 0; // stop the timer
  }
}

void MyMesh::dumpLogFile() {
#if defined(RP2040_PLATFORM)
  File f = _fs->open(PACKET_LOG_FILE, "r");
#else
  File f = _fs->open(PACKET_LOG_FILE);
#endif
  if (f) {
    while (f.available()) {
      int c = f.read();
      if (c < 0) break;
      Serial.print((char)c);
    }
    f.close();
  }
}

void MyMesh::setTxPower(int8_t power_dbm) {
  radio_driver.setTxPower(power_dbm);
}

#if defined(USE_SX1262) || defined(USE_SX1268)
void MyMesh::setRxBoostedGain(bool enable) {
  radio_driver.setRxBoostedGainMode(enable);
}
#endif

void MyMesh::formatNeighborsReply(char *reply) {
  char *dp = reply;

#if MAX_NEIGHBOURS
  // create copy of neighbours list, skipping empty entries so we can sort it separately from main list
  int16_t neighbours_count = 0;
  NeighbourInfo* sorted_neighbours[MAX_NEIGHBOURS];
  for (int i = 0; i < MAX_NEIGHBOURS; i++) {
    auto neighbour = &neighbours[i];
    if (neighbour->heard_timestamp > 0) {
      sorted_neighbours[neighbours_count] = neighbour;
      neighbours_count++;
    }
  }

  // sort neighbours newest to oldest
  std::sort(sorted_neighbours, sorted_neighbours + neighbours_count, [](const NeighbourInfo* a, const NeighbourInfo* b) {
    return a->heard_timestamp > b->heard_timestamp; // desc
  });

  for (int i = 0; i < neighbours_count && dp - reply < 134; i++) {
    NeighbourInfo *neighbour = sorted_neighbours[i];

    // add new line if not first item
    if (i > 0) *dp++ = '\n';

    char hex[10];
    // get 4 bytes of neighbour id as hex
    mesh::Utils::toHex(hex, neighbour->id.pub_key, 4);

    // add next neighbour
    uint32_t secs_ago = getRTCClock()->getCurrentTime() - neighbour->heard_timestamp;
    sprintf(dp, "%s:%d:%d", hex, secs_ago, neighbour->snr);
    while (*dp)
      dp++; // find end of string
  }
#endif
  if (dp == reply) { // no neighbours, need empty response
    strcpy(dp, "-none-");
    dp += 6;
  }
  *dp = 0; // null terminator
}

void MyMesh::removeNeighbor(const uint8_t *pubkey, int key_len) {
#if MAX_NEIGHBOURS
  for (int i = 0; i < MAX_NEIGHBOURS; i++) {
    NeighbourInfo *neighbour = &neighbours[i];
    if (memcmp(neighbour->id.pub_key, pubkey, key_len) == 0) {
      neighbours[i] = NeighbourInfo(); // clear neighbour entry
      _archive_neighbours_dirty = true;
    }
  }
#endif
}

void MyMesh::formatStatsReply(char *reply, size_t reply_size) {
  snprintf(reply,
           reply_size,
           "{\"battery_mv\":%u,\"uptime_secs\":%u,\"core0_util\":%.1f,\"errors\":%u,\"queue_len\":%u}",
           getBatteryMilliVolts(true),
           _ms->getMillis() / 1000,
           _cpu_tracker.getCore0Util() * 100.0f,
           _err_flags,
           _mgr->getOutboundTotal());
}

void MyMesh::startRegionsLoad() {
  temp_map.resetFrom(region_map);   // rebuild regions in a temp instance
  memset(load_stack, 0, sizeof(load_stack));
  load_stack[0] = &temp_map.getWildcard();
  region_load_active = true;
}

bool MyMesh::saveRegions() {
  return region_map.save(_fs);
}

void MyMesh::onDefaultRegionChanged(const RegionEntry* r) {
  if (r) {
    region_map.getTransportKeysFor(*r, &default_scope, 1);
  } else {
    memset(default_scope.key, 0, sizeof(default_scope.key));
  }
}

void MyMesh::formatRadioStatsReply(char *reply, size_t reply_size) {
  StatsFormatHelper::formatRadioStats(reply, reply_size, _radio, radio_driver, getTotalAirTime(), getReceiveAirTime());
}

void MyMesh::formatPacketStatsReply(char *reply, size_t reply_size) {
  StatsFormatHelper::formatPacketStats(reply, reply_size, radio_driver, getNumSentFlood(), getNumSentDirect(),
                                       getNumRecvFlood(), getNumRecvDirect());
}

void MyMesh::formatMemoryReply(char *reply, size_t reply_size) {
  StatsFormatHelper::formatMemoryStats(reply, reply_size);
}

size_t MyMesh::getNeighbourCount() const {
#if MAX_NEIGHBOURS
  size_t count = 0;
  for (int i = 0; i < MAX_NEIGHBOURS; i++) {
    if (neighbours[i].heard_timestamp > 0) {
      count++;
    }
  }
  return count;
#else
  return 0;
#endif
}

bool MyMesh::restoreArchiveNeighbours() {
#if MAX_NEIGHBOURS
  if (_archive == nullptr || !_archive->isMounted()) {
    return false;
  }

  FILESYSTEM* fs = _archive->getFS();
  if (fs == nullptr) {
    return false;
  }

  const char* restore_path = nullptr;
  if (fs->exists(kArchiveNeighboursLatestPath)) {
    restore_path = kArchiveNeighboursLatestPath;
  } else if (fs->exists(kArchiveNeighboursSnapshotPath)) {
    restore_path = kArchiveNeighboursSnapshotPath;
  } else {
    return false;
  }

  File file = openArchiveReadWithRecovery(_archive, restore_path);
  if (!file) {
    ARCHIVE_LOG("neighbours restore open failed path=%s", restore_path);
    return false;
  }

  memset(neighbours, 0, sizeof(neighbours));
  char line[128];
  size_t line_len = 0;
  size_t restored = 0;
  while (file.available()) {
    const int raw = file.read();
    if (raw < 0) {
      break;
    }

    const char ch = static_cast<char>(raw);
    if (ch == '\r') {
      continue;
    }
    if (ch == '\n') {
      line[line_len] = 0;
      if (line_len > 0 && restored < MAX_NEIGHBOURS) {
        char full_hex[65];
        unsigned long advert_timestamp = 0;
        unsigned long heard_timestamp = 0;
        int snr = 0;
        memset(full_hex, 0, sizeof(full_hex));
        if (sscanf(line, "%64[^,],%lu,%lu,%d", full_hex, &advert_timestamp, &heard_timestamp, &snr) == 4) {
          uint8_t pub_key[PUB_KEY_SIZE];
          if (mesh::Utils::fromHex(pub_key, PUB_KEY_SIZE, full_hex)) {
            neighbours[restored].id = mesh::Identity(pub_key);
            neighbours[restored].advert_timestamp = static_cast<uint32_t>(advert_timestamp);
            neighbours[restored].heard_timestamp = static_cast<uint32_t>(heard_timestamp);
            neighbours[restored].snr = static_cast<int8_t>(constrain(snr, -128, 127));
            restored++;
          }
        }
      }
      line_len = 0;
      continue;
    }

    if (line_len + 1 < sizeof(line)) {
      line[line_len++] = ch;
    }
  }

  if (line_len > 0 && restored < MAX_NEIGHBOURS) {
    line[line_len] = 0;
    char full_hex[65];
    unsigned long advert_timestamp = 0;
    unsigned long heard_timestamp = 0;
    int snr = 0;
    memset(full_hex, 0, sizeof(full_hex));
    if (sscanf(line, "%64[^,],%lu,%lu,%d", full_hex, &advert_timestamp, &heard_timestamp, &snr) == 4) {
      uint8_t pub_key[PUB_KEY_SIZE];
      if (mesh::Utils::fromHex(pub_key, PUB_KEY_SIZE, full_hex)) {
        neighbours[restored].id = mesh::Identity(pub_key);
        neighbours[restored].advert_timestamp = static_cast<uint32_t>(advert_timestamp);
        neighbours[restored].heard_timestamp = static_cast<uint32_t>(heard_timestamp);
        neighbours[restored].snr = static_cast<int8_t>(constrain(snr, -128, 127));
        restored++;
      }
    }
  }

  file.close();
  _archive_neighbours_dirty = false;
  return restored > 0;
#else
  return false;
#endif
}

void MyMesh::flushArchiveNeighbours() {
#if MAX_NEIGHBOURS
  if (_archive == nullptr || !_archive->isMounted()) {
    return;
  }

  FILESYSTEM* fs = _archive->getFS();
  if (fs == nullptr) {
    return;
  }

  int16_t neighbours_count = 0;
  NeighbourInfo* sorted_neighbours[MAX_NEIGHBOURS];
  for (int i = 0; i < MAX_NEIGHBOURS; i++) {
    if (neighbours[i].heard_timestamp > 0) {
      sorted_neighbours[neighbours_count++] = &neighbours[i];
    }
  }

  std::sort(sorted_neighbours, sorted_neighbours + neighbours_count, [](const NeighbourInfo* a, const NeighbourInfo* b) {
    return a->heard_timestamp > b->heard_timestamp;
  });

  char latest_block[1536];
  size_t latest_len = 0;
  uint32_t latest_epoch_secs = 0;
  for (int i = 0; i < neighbours_count; ++i) {
    char full_hex[65];
    mesh::Utils::toHex(full_hex, sorted_neighbours[i]->id.pub_key, PUB_KEY_SIZE);
    latest_len += snprintf(&latest_block[latest_len], sizeof(latest_block) - latest_len,
                           "%s,%lu,%lu,%d\n",
                           full_hex,
                           static_cast<unsigned long>(sorted_neighbours[i]->advert_timestamp),
                           static_cast<unsigned long>(sorted_neighbours[i]->heard_timestamp),
                           static_cast<int>(sorted_neighbours[i]->snr));
    latest_epoch_secs = max<uint32_t>(latest_epoch_secs, sorted_neighbours[i]->heard_timestamp);
    if (latest_len >= sizeof(latest_block)) {
      latest_len = sizeof(latest_block) - 1;
      break;
    }
  }

  File latest_file = openArchiveWriteWithRecovery(_archive, kArchiveNeighboursLatestPath);
  if (!latest_file) {
    ARCHIVE_LOG("neighbours open failed path=%s", kArchiveNeighboursLatestPath);
    return;
  }
  const size_t latest_written = latest_file.print(latest_block);
  latest_file.flush();
  latest_file.close();

  char daily_path[52];
  buildUtcDailyArchivePath("neighbours", latest_epoch_secs, daily_path, sizeof(daily_path));
  File file = openArchiveAppendWithRecovery(_archive, daily_path);
  if (!file) {
    ARCHIVE_LOG("neighbours open failed path=%s", daily_path);
    return;
  }

  size_t total_written = 0;
  for (int i = 0; i < neighbours_count; ++i) {
    char full_hex[65];
    mesh::Utils::toHex(full_hex, sorted_neighbours[i]->id.pub_key, PUB_KEY_SIZE);
    total_written += file.printf("%s,%lu,%lu,%d\n",
                                 full_hex,
                                 static_cast<unsigned long>(sorted_neighbours[i]->advert_timestamp),
                                 static_cast<unsigned long>(sorted_neighbours[i]->heard_timestamp),
                                 static_cast<int>(sorted_neighbours[i]->snr));
  }
  file.flush();
  file.close();
  ARCHIVE_LOG("neighbours flushed latest=%s bytes=%u log=%s log_bytes=%u count=%d",
              kArchiveNeighboursLatestPath,
              static_cast<unsigned>(latest_written),
              daily_path,
              static_cast<unsigned>(total_written),
              static_cast<int>(neighbours_count));
  _archive_neighbours_dirty = false;
#endif
}

void MyMesh::maybeFlushArchiveNeighbours(unsigned long now_ms) {
#if MAX_NEIGHBOURS
  if (!_archive_neighbours_dirty || _archive == nullptr || !_archive->isMounted()) {
    return;
  }
  if (next_archive_neighbours_flush_ms == 0 || millisHasNowPassed(next_archive_neighbours_flush_ms)) {
    flushArchiveNeighbours();
    next_archive_neighbours_flush_ms = now_ms + kArchiveNeighboursFlushIntervalMs;
  }
#else
  (void)now_ms;
#endif
}

void MyMesh::recordStatsEvent(uint8_t type, int16_t value) {
  _stats_history.recordEvent(type, getRTCClock()->getCurrentTime(), static_cast<uint32_t>(uptime_millis / 1000), value);
}

void MyMesh::updateStatsHistory(unsigned long now_ms) {
#if defined(ESP_PLATFORM) && WITH_WEB_PANEL
  constexpr uint32_t kLowMemoryEnterBytes = 32UL * 1024UL;
  constexpr uint32_t kLowMemoryClearBytes = 48UL * 1024UL;
  constexpr uint32_t kLowMemoryEventCooldownSecs = 5UL * 60UL;
  _stats_history.setArchive(_archive);
  _stats_history.setEnabled(web.isWebStatsEnabled());
  if (!_stats_history.isEnabled()) {
    _stats_state.initialized = false;
    _archive_neighbours_dirty = false;
    return;
  }
  _stats_history.maybeReleaseIdleBuffers(now_ms);

  const bool wifi_connected = network.isWifiConnected();
#ifdef WITH_MQTT_UPLINK
  const bool mqtt_connected = mqtt.isAnyBrokerConnected();
#else
  const bool mqtt_connected = false;
#endif
  const bool web_panel_up = web.isPanelRunning();
  const bool archive_mounted = (_archive != nullptr) && _archive->isMounted();
#if defined(ESP32)
  const uint32_t free_heap = ESP.getFreeHeap();
  const uint32_t max_alloc_heap = ESP.getMaxAllocHeap();
  const uint32_t uptime_secs = static_cast<uint32_t>(uptime_millis / 1000);
  bool low_memory = _stats_state.low_memory;
  if (!_stats_state.initialized) {
    low_memory = free_heap <= kLowMemoryEnterBytes;
  } else if (low_memory) {
    low_memory = free_heap <= kLowMemoryClearBytes;
  } else {
    low_memory = free_heap <= kLowMemoryEnterBytes;
  }
#else
  const bool low_memory = false;
#endif

  if (!_stats_state.initialized) {
    _stats_state.initialized = true;
    _stats_state.wifi_connected = wifi_connected;
    _stats_state.mqtt_connected = mqtt_connected;
    _stats_state.web_panel_up = web_panel_up;
    _stats_state.archive_mounted = archive_mounted;
    _stats_state.low_memory = low_memory;
    _stats_state.last_low_memory_event_uptime_secs = 0;
  } else {
    if (_stats_state.mqtt_connected != mqtt_connected) {
      recordStatsEvent(mqtt_connected ? HISTORY_EVENT_MQTT_CONNECTED : HISTORY_EVENT_MQTT_DISCONNECTED);
      _stats_state.mqtt_connected = mqtt_connected;
    }
    if (_stats_state.web_panel_up != web_panel_up) {
      recordStatsEvent(web_panel_up ? HISTORY_EVENT_WEB_STARTED : HISTORY_EVENT_WEB_STOPPED);
      _stats_state.web_panel_up = web_panel_up;
    }
    if (_stats_state.archive_mounted != archive_mounted) {
      recordStatsEvent(archive_mounted ? HISTORY_EVENT_ARCHIVE_MOUNTED : HISTORY_EVENT_ARCHIVE_UNAVAILABLE);
      _stats_state.archive_mounted = archive_mounted;
      if (!_stats_history.isLiveOnly() && archive_mounted) {
        if (getNeighbourCount() == 0) {
          restoreArchiveNeighbours();
        }
        next_archive_neighbours_flush_ms = now_ms + kArchiveNeighboursFlushIntervalMs;
      }
    }
    if (!_stats_history.isLiveOnly() && !_stats_state.low_memory && low_memory) {
#if defined(ESP32)
      if (_stats_state.last_low_memory_event_uptime_secs == 0 ||
          (uptime_secs - _stats_state.last_low_memory_event_uptime_secs) >= kLowMemoryEventCooldownSecs) {
        recordStatsEvent(HISTORY_EVENT_LOW_MEMORY, static_cast<int16_t>(min<uint32_t>(free_heap / 1024, 32767)));
        _stats_state.last_low_memory_event_uptime_secs = uptime_secs;
      }
#endif
    }
    _stats_state.wifi_connected = wifi_connected;
    _stats_state.low_memory = low_memory;
  }

#if defined(ESP32)
  const bool live_stats_headroom_low =
      _stats_history.isLiveOnly() && (free_heap <= kLowMemoryClearBytes || max_alloc_heap <= (24UL * 1024UL));
#else
  const bool live_stats_headroom_low = false;
#endif
  if (next_history_sample_ms == 0 || millisHasNowPassed(next_history_sample_ms)) {
    if (!live_stats_headroom_low) {
      const uint16_t battery_mv = getBatteryMilliVolts();
      WebSensorSnapshot sensor_snapshot = collectWebSensorSnapshot(board, sensors, battery_mv);
      HistorySample sample{};
      sample.epoch_secs = getRTCClock()->getCurrentTime();
      sample.uptime_secs = static_cast<uint32_t>(uptime_millis / 1000);
      sample.packets_sent = radio_driver.getPacketsSent();
      sample.packets_recv = radio_driver.getPacketsRecv();
      sample.battery_mv = battery_mv;
      sample.queue_len = static_cast<uint16_t>(_mgr->getOutboundTotal());
      sample.error_flags = _err_flags;
      sample.recv_errors = radio_driver.getPacketsRecvErrors();
      sample.neighbour_count = static_cast<uint16_t>(min<size_t>(getNeighbourCount(), 0xFFFF));
      sample.direct_dups =
          static_cast<uint16_t>(min<uint32_t>(((SimpleMeshTables *)getTables())->getNumDirectDups(), 0xFFFF));
      sample.flood_dups =
          static_cast<uint16_t>(min<uint32_t>(((SimpleMeshTables *)getTables())->getNumFloodDups(), 0xFFFF));
      sample.last_rssi_x4 = static_cast<int16_t>(radio_driver.getLastRSSI() * 4.0f);
      sample.last_snr_x4 = static_cast<int16_t>(radio_driver.getLastSNR() * 4.0f);
      sample.noise_floor = static_cast<int16_t>(_radio->getNoiseFloor());
      sample.battery_pct = static_cast<int8_t>(board.getBatteryPercent());
      if (sensor_snapshot.has_supply_voltage && std::isfinite(sensor_snapshot.supply_voltage_v)) {
        sample.sensor_flags |= HISTORY_SENSOR_SUPPLY_VOLTAGE;
        sample.supply_voltage_centi_v =
            static_cast<uint16_t>(min<int>(lroundf(sensor_snapshot.supply_voltage_v * 100.0f), 0xFFFF));
      }
      if (sensor_snapshot.has_sensor_temp && std::isfinite(sensor_snapshot.sensor_temp_c)) {
        sample.sensor_flags |= HISTORY_SENSOR_TEMP;
        sample.sensor_temp_deci_c =
            static_cast<int16_t>(max<long>(-32768L, min<long>(32767L, lroundf(sensor_snapshot.sensor_temp_c * 10.0f))));
      }
      if (sensor_snapshot.has_mcu_temp && std::isfinite(sensor_snapshot.mcu_temp_c)) {
        sample.sensor_flags |= HISTORY_SENSOR_MCU_TEMP;
        sample.mcu_temp_deci_c =
            static_cast<int16_t>(max<long>(-32768L, min<long>(32767L, lroundf(sensor_snapshot.mcu_temp_c * 10.0f))));
      }
      if (sensor_snapshot.has_humidity && std::isfinite(sensor_snapshot.humidity_pct)) {
        sample.sensor_flags |= HISTORY_SENSOR_HUMIDITY;
        sample.humidity_deci_pct =
            static_cast<uint16_t>(min<int>(lroundf(sensor_snapshot.humidity_pct * 10.0f), 0xFFFF));
      }
      if (sensor_snapshot.has_pressure && std::isfinite(sensor_snapshot.pressure_hpa)) {
        sample.sensor_flags |= HISTORY_SENSOR_PRESSURE;
        sample.pressure_deci_hpa =
            static_cast<uint16_t>(min<int>(lroundf(sensor_snapshot.pressure_hpa * 10.0f), 0xFFFF));
      }
      if (sensor_snapshot.has_pressure_altitude && std::isfinite(sensor_snapshot.pressure_altitude_m)) {
        sample.sensor_flags |= HISTORY_SENSOR_PRESSURE_ALTITUDE;
        sample.pressure_altitude_m =
            static_cast<int16_t>(max<long>(-32768L, min<long>(32767L, lroundf(sensor_snapshot.pressure_altitude_m))));
      }
      if (sensor_snapshot.has_gps) sample.sensor_flags |= HISTORY_SENSOR_GPS_PRESENT;
      if (sensor_snapshot.gps_enabled) sample.sensor_flags |= HISTORY_SENSOR_GPS_ENABLED;
      if (sensor_snapshot.gps_fix) sample.sensor_flags |= HISTORY_SENSOR_GPS_FIX;
      if (sensor_snapshot.has_gps_lat && std::isfinite(sensor_snapshot.gps_lat)) {
        sample.sensor_flags |= HISTORY_SENSOR_GPS_LAT;
        sample.gps_lat_e6 = static_cast<int32_t>(lroundf(sensor_snapshot.gps_lat * 1000000.0f));
      }
      if (sensor_snapshot.has_gps_lon && std::isfinite(sensor_snapshot.gps_lon)) {
        sample.sensor_flags |= HISTORY_SENSOR_GPS_LON;
        sample.gps_lon_e6 = static_cast<int32_t>(lroundf(sensor_snapshot.gps_lon * 1000000.0f));
      }
      if (sensor_snapshot.has_gps_altitude && std::isfinite(sensor_snapshot.gps_altitude_m)) {
        sample.sensor_flags |= HISTORY_SENSOR_GPS_ALTITUDE;
        sample.gps_altitude_m =
            static_cast<int16_t>(max<long>(-32768L, min<long>(32767L, lroundf(sensor_snapshot.gps_altitude_m))));
      }
      if (sensor_snapshot.has_satellites) {
        sample.sensor_flags |= HISTORY_SENSOR_GPS_SATELLITES;
        sample.gps_satellites = static_cast<uint8_t>(min<long>(sensor_snapshot.satellites, 255));
      }
#if defined(ESP32)
      sample.heap_free = free_heap;
      sample.heap_min = ESP.getMinFreeHeap();
      sample.psram_free = ESP.getFreePsram();
      sample.psram_min = ESP.getMinFreePsram();
      sample.core0_util_pct = (uint8_t)(_cpu_tracker.getCore0Util() * 100.0f + 0.5f);
#endif
      if (board.isExternalPowered()) sample.flags |= HISTORY_FLAG_EXTERNAL_POWER;
      if (board.isCharging()) sample.flags |= HISTORY_FLAG_CHARGING;
      if (board.isVbusPresent()) sample.flags |= HISTORY_FLAG_VBUS;
      if (wifi_connected) sample.flags |= HISTORY_FLAG_WIFI_CONNECTED;
      if (mqtt_connected) sample.flags |= HISTORY_FLAG_MQTT_CONNECTED;
      if (web.isWebEnabled()) sample.flags |= HISTORY_FLAG_WEB_ENABLED;
      if (web_panel_up) sample.flags |= HISTORY_FLAG_WEB_PANEL_UP;
      if (archive_mounted) sample.flags |= HISTORY_FLAG_ARCHIVE_MOUNTED;
      _stats_history.pushSample(sample);
    }
    next_history_sample_ms = now_ms + 60000UL;
  }

  _stats_history.maybeFlush(now_ms);
  if (!_stats_history.isLiveOnly()) {
    maybeFlushArchiveNeighbours(now_ms);
  }
#else
  (void)now_ms;
#endif
}

bool MyMesh::appendJsonEvents(char* reply, size_t reply_size, size_t& offset) const {
  offset += snprintf(&reply[offset], reply_size - offset, "\"events\":[");
  const size_t max_events = min<size_t>(_stats_history.getEventCount(), 6);
  const uint32_t now_epoch_secs = getRTCClock()->getCurrentTime();
  const uint32_t now_uptime_secs = static_cast<uint32_t>(uptime_millis / 1000);
  for (size_t i = 0; i < max_events; ++i) {
    HistoryEvent event{};
    if (!_stats_history.getRecentEvent(i, event)) {
      break;
    }
    const uint32_t age_secs = (now_epoch_secs >= event.epoch_secs && event.epoch_secs > 0)
        ? (now_epoch_secs - event.epoch_secs)
        : ((now_uptime_secs >= event.uptime_secs) ? (now_uptime_secs - event.uptime_secs) : event.uptime_secs);
    offset += snprintf(&reply[offset], reply_size - offset,
                       "%s{\"t\":%lu,\"type\":\"%s\",\"value\":%d}",
                       i == 0 ? "" : ",",
                       static_cast<unsigned long>(age_secs),
                       StatsHistory::getEventTypeName(event.type),
                       static_cast<int>(event.value));
    if (offset >= reply_size) {
      return false;
    }
  }
  offset += snprintf(&reply[offset], reply_size - offset, "]");
  return offset < reply_size;
}

bool MyMesh::appendJsonNeighbours(char* reply, size_t reply_size, size_t& offset) const {
  offset += snprintf(&reply[offset], reply_size - offset, "\"neighbors_detail\":[");
  if (offset >= reply_size) {
    return false;
  }

#if MAX_NEIGHBOURS
  constexpr size_t kMaxNeighboursJson = 10;
  int16_t neighbours_count = 0;
  NeighbourInfo* sorted_neighbours[MAX_NEIGHBOURS];
  for (int i = 0; i < MAX_NEIGHBOURS; i++) {
    auto neighbour = const_cast<NeighbourInfo*>(&neighbours[i]);
    if (neighbour->heard_timestamp > 0) {
      sorted_neighbours[neighbours_count++] = neighbour;
    }
  }

  std::sort(sorted_neighbours, sorted_neighbours + neighbours_count, [](const NeighbourInfo* a, const NeighbourInfo* b) {
    return a->heard_timestamp > b->heard_timestamp;
  });

  const size_t emit_count = min<size_t>(neighbours_count, kMaxNeighboursJson);
  const uint32_t now_secs = getRTCClock()->getCurrentTime();
  for (size_t i = 0; i < emit_count; ++i) {
    const NeighbourInfo* neighbour = sorted_neighbours[i];
    char hex[7];
    char full_hex[65];
    mesh::Utils::toHex(hex, neighbour->id.pub_key, 3);
    mesh::Utils::toHex(full_hex, neighbour->id.pub_key, PUB_KEY_SIZE);
    const uint32_t heard_secs_ago = now_secs - neighbour->heard_timestamp;
    const uint32_t advert_secs_ago = now_secs - neighbour->advert_timestamp;
    offset += snprintf(&reply[offset], reply_size - offset,
                       "%s{\"id\":\"%s\",\"full_id\":\"%s\",\"heard_secs_ago\":%lu,\"advert_secs_ago\":%lu,\"snr_db\":%.2f}",
                       i == 0 ? "" : ",",
                       hex,
                       full_hex,
                       static_cast<unsigned long>(heard_secs_ago),
                       static_cast<unsigned long>(advert_secs_ago),
                       static_cast<double>(neighbour->snr) / 4.0);
    if (offset >= reply_size) {
      return false;
    }
  }
#endif

  offset += snprintf(&reply[offset], reply_size - offset, "]");
  return offset < reply_size;
}

void MyMesh::saveIdentity(const mesh::LocalIdentity &new_id) {
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
  IdentityStore store(*_fs, "");
#elif defined(ESP32)
  IdentityStore store(*_fs, "/identity");
#elif defined(RP2040_PLATFORM)
  IdentityStore store(*_fs, "/identity");
#else
#error "need to define saveIdentity()"
#endif
  store.save("_main", new_id);
}

void MyMesh::clearStats() {
  radio_driver.resetStats();
  resetStats();
  ((SimpleMeshTables *)getTables())->resetStats();
}

void MyMesh::prepareForOTAStart() {
#if defined(ESP_PLATFORM) && WITH_WEB_PANEL
  web.prepareForOTAStart();
#endif
}

void MyMesh::handleCommand(uint32_t sender_timestamp, char *command, char *reply) {
  if (region_load_active) {
    if (StrHelper::isBlank(command)) {  // empty/blank line, signal to terminate 'load' operation
      region_map = temp_map;  // copy over the temp instance as new current map
      region_load_active = false;

      sprintf(reply, "OK - loaded %d regions", region_map.getCount());
    } else {
      char *np = command;
      while (*np == ' ') np++;   // skip indent
      int indent = np - command;

      char *ep = np;
      while (RegionMap::is_name_char(*ep)) ep++;
      if (*ep) { *ep++ = 0; }  // set null terminator for end of name

      while (*ep && *ep != 'F') ep++;  // look for (optional) flags

      if (indent > 0 && indent < 8 && strlen(np) > 0) {
        auto parent = load_stack[indent - 1];
        if (parent) {
          auto old = region_map.findByName(np);
          auto nw = temp_map.putRegion(np, parent->id, old ? old->id : 0);  // carry-over the current ID (if name already exists)
          if (nw) {
            nw->flags = old ? old->flags : (*ep == 'F' ? 0 : REGION_DENY_FLOOD);   // carry-over flags from curr

            load_stack[indent] = nw;  // keep pointers to parent regions, to resolve parent_id's
          }
        }
      }
      reply[0] = 0;
    }
    return;
  }

  while (*command == ' ') command++; // skip leading spaces

  if (strlen(command) > 4 && command[2] == '|') { // optional prefix (for companion radio CLI)
    memcpy(reply, command, 3);                    // reflect the prefix back
    reply += 3;
    command += 3;
  }

  // handle ACL related commands
  if (memcmp(command, "setperm ", 8) == 0) {   // format:  setperm {pubkey-hex} {permissions-int8}
    char* hex = &command[8];
    char* sp = strchr(hex, ' ');   // look for separator char
    if (sp == NULL) {
      strcpy(reply, "Err - bad params");
    } else {
      *sp++ = 0;   // replace space with null terminator

      uint8_t pubkey[PUB_KEY_SIZE];
      int hex_len = min(sp - hex, PUB_KEY_SIZE*2);
      if (mesh::Utils::fromHex(pubkey, hex_len / 2, hex)) {
        uint8_t perms = atoi(sp);
        if (acl.applyPermissions(self_id, pubkey, hex_len / 2, perms)) {
          dirty_contacts_expiry = futureMillis(LAZY_CONTACTS_WRITE_DELAY);   // trigger acl.save()
          strcpy(reply, "OK");
        } else {
          strcpy(reply, "Err - invalid params");
        }
      } else {
        strcpy(reply, "Err - bad pubkey");
      }
    }
  } else if (sender_timestamp == 0 && strcmp(command, "get acl") == 0) {
    Serial.println("ACL:");
    for (int i = 0; i < acl.getNumClients(); i++) {
      auto c = acl.getClientByIdx(i);
      if (c->permissions == 0) continue;  // skip deleted (or guest) entries

      Serial.printf("%02X ", c->permissions);
      mesh::Utils::printHex(Serial, c->id.pub_key, PUB_KEY_SIZE);
      Serial.printf("\n");
    }
    reply[0] = 0;
  } else if (memcmp(command, "discover.neighbors", 18) == 0) {
    const char* sub = command + 18;
    while (*sub == ' ') sub++;
    if (*sub != 0) {
      strcpy(reply, "Err - discover.neighbors has no options");
    } else {
      sendNodeDiscoverReq();
      strcpy(reply, "OK - Discover sent");
    }
#if defined(ESP_PLATFORM) && WITH_WEB_PANEL
  } else if (strcmp(command, "get web.status") == 0 || strcmp(command, "get web") == 0) {
    web.formatWebStatusReply(reply, 160);
  } else if (strcmp(command, "get web.stats.status") == 0) {
    snprintf(reply, 160,
             "> enabled:%s history:%s mode:%s psram:%s psram_bytes:%lu boot_auto:%s samples:%u/%u events:%u/%u archive:%s",
             web.isWebStatsEnabled() ? "on" : "off",
             (_stats_history.isEnabled() && _stats_history.isRecentHistoryAvailable()) ? "active" : "inactive",
             _stats_history.isLiveOnly() ? "live" : "full",
             _stats_history.isPsramBacked() ? "yes" : "no",
             static_cast<unsigned long>(_stats_history.getDetectedPsramSizeBytes()),
             _stats_history.isBootAutoCaptureExpected() ? "yes" : "no",
             static_cast<unsigned>(_stats_history.getSampleCount()),
             static_cast<unsigned>(_stats_history.getSampleCapacity()),
             static_cast<unsigned>(_stats_history.getEventCount()),
             static_cast<unsigned>(_stats_history.getEventCapacity()),
             (_archive != nullptr && _archive->isMounted()) ? "mounted" : "unavailable");
#endif
#if defined(TBEAM_1W)
  } else if (strcmp(command, "get fan") == 0) {
    auto& tbeam1w_board = static_cast<TBeam1WBoard&>(board);
    const float temp_c = tbeam1w_board.getLastBoardTemperatureC();
    if (isnan(temp_c)) {
      snprintf(reply, 160, "> mode:%s state:%s timeout:%lus temp:unavailable",
               tbeam1w_board.getFanModeName(),
               tbeam1w_board.isFanEnabled() ? "on" : "off",
               static_cast<unsigned long>(tbeam1w_board.getFanPostTxHoldMs() / 1000UL));
    } else {
      snprintf(reply, 160, "> mode:%s state:%s timeout:%lus temp:%.2fC",
               tbeam1w_board.getFanModeName(),
               tbeam1w_board.isFanEnabled() ? "on" : "off",
               static_cast<unsigned long>(tbeam1w_board.getFanPostTxHoldMs() / 1000UL),
               temp_c);
    }
  } else if (memcmp(command, "set fan ", 8) == 0) {
    auto& tbeam1w_board = static_cast<TBeam1WBoard&>(board);
    const char* mode = &command[8];
    if (memcmp(mode, "auto", 4) == 0) {
      _prefs.fan_mode = static_cast<uint8_t>(TBeam1WBoard::FanMode::Auto);
      tbeam1w_board.setFanMode(TBeam1WBoard::FanMode::Auto);
      savePrefs();
      strcpy(reply, "OK - fan auto");
    } else if (memcmp(mode, "on", 2) == 0) {
      _prefs.fan_mode = static_cast<uint8_t>(TBeam1WBoard::FanMode::On);
      tbeam1w_board.setFanMode(TBeam1WBoard::FanMode::On);
      savePrefs();
      strcpy(reply, "OK - fan on");
    } else if (memcmp(mode, "off", 3) == 0) {
      _prefs.fan_mode = static_cast<uint8_t>(TBeam1WBoard::FanMode::Off);
      tbeam1w_board.setFanMode(TBeam1WBoard::FanMode::Off);
      savePrefs();
      strcpy(reply, "OK - fan off");
    } else if (memcmp(mode, "timeout ", 8) == 0) {
      char* end = nullptr;
      const unsigned long timeout_s = strtoul(&mode[8], &end, 10);
      while (end != nullptr && *end == ' ') end++;
      if (end != nullptr && *end == 's' && *(end + 1) == 0 && tbeam1w_board.setFanPostTxHoldMs(static_cast<uint32_t>(timeout_s * 1000UL))) {
        _prefs.fan_timeout_secs = static_cast<uint16_t>(timeout_s);
        savePrefs();
        snprintf(reply, 160, "OK - fan timeout %lus", timeout_s);
      } else {
        strcpy(reply, "Err - use 0s..600s");
      }
    } else {
      strcpy(reply, "Err - use auto|on|off|timeout <Ns>");
    }
#endif
#if defined(ESP_PLATFORM)
  } else if (memcmp(command, "get wifi.status", 15) == 0) {
    network.formatWifiStatusReply(reply, 160);
  } else if (memcmp(command, "get wifi.ssid", 13) == 0) {
    sprintf(reply, "> %s", network.getWifiSSID()[0] ? network.getWifiSSID() : "-");
  } else if (memcmp(command, "get wifi.powersaving", 20) == 0) {
    sprintf(reply, "> %s", network.getWifiPowerSave());
#endif
#if defined(ESP_PLATFORM) && WITH_WEB_PANEL
  } else if (memcmp(command, "set web ", 8) == 0) {
    web.setWebEnabled(memcmp(&command[8], "on", 2) == 0);
    strcpy(reply, "OK");
  } else if (memcmp(command, "set.web ", 8) == 0) {
    web.setWebEnabled(memcmp(&command[8], "on", 2) == 0);
    strcpy(reply, "OK");
  } else if (memcmp(command, "set web.stats ", 14) == 0 || memcmp(command, "set.web.stats ", 15) == 0) {
    const char* value = (memcmp(command, "set web.stats ", 14) == 0) ? &command[14] : &command[15];
    const bool enabled = memcmp(value, "on", 2) == 0;
    if (web.setWebStatsEnabled(enabled)) {
      _stats_history.setEnabled(enabled);
      recordStatsEvent(enabled ? HISTORY_EVENT_STATS_ENABLED : HISTORY_EVENT_STATS_DISABLED);
      if (enabled) {
        next_history_sample_ms = millis();
      } else {
        _stats_state.initialized = false;
      }
      strcpy(reply, enabled ? "OK - web.stats on" : "OK - web.stats off");
    } else {
      strcpy(reply, "Err - unable to update web.stats");
    }
#endif
#if defined(ESP_PLATFORM)
  } else if (memcmp(command, "set wifi.ssid ", 14) == 0) {
    if (network.setWifiSSID(&command[14])) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - bad wifi.ssid");
    }
  } else if (memcmp(command, "set wifi.pwd ", 13) == 0) {
    if (network.setWifiPassword(&command[13])) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - bad wifi.pwd");
    }
  } else if (memcmp(command, "set wifi.powersaving ", 21) == 0) {
    if (network.setWifiPowerSave(&command[21])) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - use none|min|max");
    }
#endif
#ifdef WITH_MQTT_UPLINK
  } else if (memcmp(command, "mqtt.owner ", 11) == 0) {
    if (mqtt.setOwnerPublicKey(&command[11])) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - owner must be 64 hex chars");
    }
  } else if (memcmp(command, "mqtt.email ", 11) == 0) {
    if (mqtt.setOwnerEmail(&command[11])) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - bad mqtt.email");
    }
  } else if (strcmp(command, "send mqtt.status") == 0) {
    if (mqtt.sendStatusNow()) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - mqtt status unavailable");
    }
  } else if (strcmp(command, "get mqtt.statuscfg") == 0) {
    sprintf(reply, "> %s", mqtt.isStatusEnabled() ? "on" : "off");
  } else if (strcmp(command, "get mqtt.status") == 0) {
    mqtt.formatStatusReply(reply, 160);
  } else if (strcmp(command, "get mqtt.client_version") == 0) {
    sprintf(reply, "> %s", mqtt.getClientVersion());
  } else if (memcmp(command, "get mqtt.iata", 13) == 0) {
    sprintf(reply, "> %s", mqtt.getIata());
  } else if (memcmp(command, "get mqtt.owner", 14) == 0) {
    sprintf(reply, "> %s", mqtt.getOwnerPublicKey()[0] ? mqtt.getOwnerPublicKey() : "-");
  } else if (memcmp(command, "get mqtt.email", 14) == 0) {
    sprintf(reply, "> %s", mqtt.getOwnerEmail()[0] ? mqtt.getOwnerEmail() : "-");
  } else if (memcmp(command, "get mqtt.packets", 16) == 0) {
    sprintf(reply, "> %s", mqtt.isPacketsEnabled() ? "on" : "off");
  } else if (memcmp(command, "get mqtt.raw", 12) == 0) {
    sprintf(reply, "> %s", mqtt.isRawEnabled() ? "on" : "off");
  } else if (memcmp(command, "get mqtt.tx", 11) == 0) {
    sprintf(reply, "> %s", mqtt.isTxEnabled() ? "on" : "off");
  } else if (memcmp(command, "get mqtt.meshcoretel", 21) == 0) {
    sprintf(reply, "> %s", mqtt.isEndpointEnabled(0x01) ? "on" : "off");
  } else if (memcmp(command, "get mqtt.letsmesh-eu", 21) == 0 || memcmp(command, "get mqtt.letsmesh.eu", 21) == 0) {
    sprintf(reply, "> %s", mqtt.isEndpointEnabled(0x02) ? "on" : "off");
  } else if (memcmp(command, "get mqtt.letsmesh-us", 21) == 0 || memcmp(command, "get mqtt.letsmesh.us", 21) == 0) {
    sprintf(reply, "> %s", mqtt.isEndpointEnabled(0x04) ? "on" : "off");
  } else if (memcmp(command, "set mqtt.tx ", 12) == 0) {
    mqtt.setTxEnabled(memcmp(&command[12], "on", 2) == 0);
    strcpy(reply, "OK");
  } else if (memcmp(command, "set mqtt.iata ", 14) == 0) {
    if (mqtt.setIata(&command[14])) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - bad mqtt.iata");
    }
  } else if (memcmp(command, "set mqtt.owner ", 15) == 0) {
    if (mqtt.setOwnerPublicKey(&command[15])) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - owner must be 64 hex chars");
    }
  } else if (memcmp(command, "set mqtt.email ", 15) == 0) {
    if (mqtt.setOwnerEmail(&command[15])) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - bad mqtt.email");
    }
  } else if (memcmp(command, "set mqtt.packets ", 17) == 0) {
    mqtt.setPacketsEnabled(memcmp(&command[17], "on", 2) == 0);
    strcpy(reply, "OK");
  } else if (memcmp(command, "set mqtt.raw ", 13) == 0) {
    mqtt.setRawEnabled(memcmp(&command[13], "on", 2) == 0);
    strcpy(reply, "OK");
  } else if (memcmp(command, "set mqtt.status ", 16) == 0) {
    mqtt.setStatusEnabled(memcmp(&command[16], "on", 2) == 0);
    strcpy(reply, "OK");
  } else if (memcmp(command, "set mqtt.meshcoretel ", 21) == 0) {
    if (mqtt.setEndpointEnabled(0x01, memcmp(&command[21], "on", 2) == 0)) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - max 2 mqtt brokers");
    }
  } else if (memcmp(command, "set mqtt.letsmesh-eu ", 21) == 0 || memcmp(command, "set mqtt.letsmesh.eu ", 21) == 0) {
    if (mqtt.setEndpointEnabled(0x02, memcmp(&command[21], "on", 2) == 0)) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - max 2 mqtt brokers");
    }
  } else if (memcmp(command, "set mqtt.letsmesh-us ", 21) == 0 || memcmp(command, "set mqtt.letsmesh.us ", 21) == 0) {
    if (mqtt.setEndpointEnabled(0x04, memcmp(&command[21], "on", 2) == 0)) {
      strcpy(reply, "OK");
    } else {
      strcpy(reply, "Err - max 2 mqtt brokers");
    }
#endif
  } else{
    _cli.handleCommand(sender_timestamp, command, reply);  // common CLI commands
  }
}

void MyMesh::runWebCommand(const char* command, char* reply, size_t reply_size) {
  if (reply_size == 0) {
    return;
  }
  reply[0] = 0;
  if (command == nullptr) {
    strncpy(reply, "Err - empty command", reply_size - 1);
    reply[reply_size - 1] = 0;
    return;
  }

  char command_buf[192];
  StrHelper::strncpy(command_buf, command, sizeof(command_buf));
  handleCommand(0, command_buf, reply);
  reply[reply_size - 1] = 0;
}

bool MyMesh::isWebStatsEnabled() const {
#if defined(ESP_PLATFORM) && WITH_WEB_PANEL
  return web.isWebStatsEnabled();
#else
  return false;
#endif
}

bool MyMesh::formatWebStatsSummaryJson(char* reply, size_t reply_size) {
  if (reply == nullptr || reply_size == 0) {
    return false;
  }
  reply[0] = 0;

#if !defined(ESP_PLATFORM) || !WITH_WEB_PANEL
  return false;
#else
  char wifi_ssid[48];
  char wifi_status[20];
  char wifi_state[24];
  char wifi_ip[20];
  char wifi_signal[16];
  char wifi_powersave[12];
  escapeJsonString(network.getWifiSSID()[0] ? network.getWifiSSID() : "-", wifi_ssid, sizeof(wifi_ssid));
  escapeJsonString(network.getWifiPowerSave(), wifi_powersave, sizeof(wifi_powersave));
  int wifi_rssi = 0;
  int wifi_quality = 0;
  int wifi_code = 0;

#if defined(ESP32)
  if (network.getWifiSSID()[0] == 0) {
    strncpy(wifi_status, "unconfigured", sizeof(wifi_status) - 1);
    wifi_status[sizeof(wifi_status) - 1] = 0;
    strncpy(wifi_state, "unconfigured", sizeof(wifi_state) - 1);
    wifi_state[sizeof(wifi_state) - 1] = 0;
    strncpy(wifi_ip, "--", sizeof(wifi_ip) - 1);
    wifi_ip[sizeof(wifi_ip) - 1] = 0;
    strncpy(wifi_signal, "--", sizeof(wifi_signal) - 1);
    wifi_signal[sizeof(wifi_signal) - 1] = 0;
  } else if (network.isWifiConnected()) {
    strncpy(wifi_status, "connected", sizeof(wifi_status) - 1);
    wifi_status[sizeof(wifi_status) - 1] = 0;
    strncpy(wifi_state, "connected", sizeof(wifi_state) - 1);
    wifi_state[sizeof(wifi_state) - 1] = 0;
    String ip = WiFi.localIP().toString();
    escapeJsonString(ip.c_str(), wifi_ip, sizeof(wifi_ip));
    wifi_rssi = WiFi.RSSI();
    wifi_code = static_cast<int>(WiFi.status());
    if (wifi_rssi <= -100) {
      wifi_quality = 0;
      strncpy(wifi_signal, "poor", sizeof(wifi_signal) - 1);
    } else if (wifi_rssi >= -50) {
      wifi_quality = 100;
      strncpy(wifi_signal, "excellent", sizeof(wifi_signal) - 1);
    } else {
      wifi_quality = 2 * (wifi_rssi + 100);
      if (wifi_rssi >= -60) {
        strncpy(wifi_signal, "excellent", sizeof(wifi_signal) - 1);
      } else if (wifi_rssi >= -67) {
        strncpy(wifi_signal, "good", sizeof(wifi_signal) - 1);
      } else if (wifi_rssi >= -75) {
        strncpy(wifi_signal, "fair", sizeof(wifi_signal) - 1);
      } else {
        strncpy(wifi_signal, "poor", sizeof(wifi_signal) - 1);
      }
    }
    wifi_signal[sizeof(wifi_signal) - 1] = 0;
  } else {
    strncpy(wifi_status, "connecting", sizeof(wifi_status) - 1);
    wifi_status[sizeof(wifi_status) - 1] = 0;
    wifi_code = static_cast<int>(WiFi.status());
    switch (WiFi.status()) {
      case WL_IDLE_STATUS:
        strncpy(wifi_state, "idle", sizeof(wifi_state) - 1);
        break;
      case WL_NO_SSID_AVAIL:
        strncpy(wifi_state, "no_ssid", sizeof(wifi_state) - 1);
        break;
      case WL_SCAN_COMPLETED:
        strncpy(wifi_state, "scan_completed", sizeof(wifi_state) - 1);
        break;
      case WL_CONNECT_FAILED:
        strncpy(wifi_state, "connect_failed", sizeof(wifi_state) - 1);
        break;
      case WL_CONNECTION_LOST:
        strncpy(wifi_state, "connection_lost", sizeof(wifi_state) - 1);
        break;
      case WL_DISCONNECTED:
        strncpy(wifi_state, "disconnected", sizeof(wifi_state) - 1);
        break;
      default:
        strncpy(wifi_state, "unknown", sizeof(wifi_state) - 1);
        break;
    }
    wifi_state[sizeof(wifi_state) - 1] = 0;
    strncpy(wifi_ip, "--", sizeof(wifi_ip) - 1);
    wifi_ip[sizeof(wifi_ip) - 1] = 0;
    strncpy(wifi_signal, "--", sizeof(wifi_signal) - 1);
    wifi_signal[sizeof(wifi_signal) - 1] = 0;
  }
#else
  strncpy(wifi_status, "unsupported", sizeof(wifi_status) - 1);
  wifi_status[sizeof(wifi_status) - 1] = 0;
  strncpy(wifi_state, "unsupported", sizeof(wifi_state) - 1);
  wifi_state[sizeof(wifi_state) - 1] = 0;
  strncpy(wifi_ip, "--", sizeof(wifi_ip) - 1);
  wifi_ip[sizeof(wifi_ip) - 1] = 0;
  strncpy(wifi_signal, "--", sizeof(wifi_signal) - 1);
  wifi_signal[sizeof(wifi_signal) - 1] = 0;
#endif

  const uint16_t battery_mv = getBatteryMilliVolts(true);
  const int battery_pct = board.getBatteryPercent();
  const uint16_t battery_min_mv = board.getBatteryMinMilliVolts();
  const uint16_t battery_max_mv = board.getBatteryMaxMilliVolts();
  const int battery_display_pct =
      (battery_pct >= 0) ? std::max(0, std::min(100, battery_pct))
                         : clampBatteryPercentFromRange(battery_mv, battery_min_mv, battery_max_mv);
  const WebSensorSnapshot sensor_snapshot = collectWebSensorSnapshot(board, sensors, battery_mv);
  const bool archive_available = (_archive != nullptr) && _archive->isMounted();
#ifdef WITH_MQTT_UPLINK
  const bool mqtt_connected = mqtt.isAnyBrokerConnected();
  const char* mqtt_state = mqtt.getAggregateBrokerState();
#else
  const bool mqtt_connected = false;
  const char* mqtt_state = "down";
#endif
  const bool web_panel_up = web.isPanelRunning();
  const char* archive_name = (_archive != nullptr) ? _archive->getLogicalName() : "archive";
  const char* archive_path = (_archive != nullptr) ? _archive->getLogicalStatsPath() : "archive:/stats";
  const char* archive_type = (_archive != nullptr) ? _archive->getCardTypeName() : "unavailable";
  _stats_history.noteAccess(millis());
  const uint32_t heap_free = ESP.getFreeHeap();
  const uint32_t heap_min = ESP.getMinFreeHeap();
  const uint32_t heap_max = ESP.getMaxAllocHeap();
  const uint32_t psram_free = ESP.getFreePsram();
  const uint32_t psram_min = ESP.getMinFreePsram();
  const uint32_t psram_max = ESP.getMaxAllocPsram();

  size_t offset = 0;
  offset += snprintf(&reply[offset], reply_size - offset,
                     "{\"enabled\":true,"
                     "\"history\":{\"active\":%s,\"psram\":%s,\"degraded\":%s,\"live_only\":%s,\"samples\":%u,\"sample_capacity\":%u,\"sample_interval_secs\":%lu,"
                     "\"archive_restored\":%s,\"archive_restored_samples\":%u,\"archive_summary_interval_secs\":%lu,"
                     "\"events\":%u,\"event_capacity\":%u},"
                     "\"archive\":{\"logical\":\"%s\",\"available\":%s,\"path\":\"%s\",\"type\":\"%s\","
                     "\"total_bytes\":%llu,\"used_bytes\":%llu},"
                     "\"core\":{\"battery_mv\":%u,\"battery_pct\":%d,\"battery_display_pct\":%d,\"battery_min_mv\":%u,\"battery_max_mv\":%u,"
                     "\"uptime_secs\":%lu,\"core0_util\":%.1f,\"errors\":%u,\"queue_len\":%u,"
                     "\"external_power\":%s,\"charging\":%s,\"vbus\":%s},"
                     "\"radio\":{\"noise_floor\":%d,\"last_rssi\":%.2f,\"last_snr\":%.2f,\"tx_air_secs\":%lu,\"rx_air_secs\":%lu},"
                     "\"packets\":{\"recv\":%u,\"sent\":%u,\"flood_tx\":%u,\"direct_tx\":%u,\"flood_rx\":%u,\"direct_rx\":%u,"
                     "\"recv_errors\":%u,\"direct_dups\":%u,\"flood_dups\":%u,\"neighbors\":%u},"
                     "\"memory\":{\"heap_free\":%u,\"heap_min\":%u,\"heap_max\":%u,\"psram_free\":%u,\"psram_min\":%u,\"psram_max\":%u},"
                     "\"wifi\":{\"ssid\":\"%s\",\"status\":\"%s\",\"connected\":%s,\"state\":\"%s\",\"code\":%d,\"ip\":\"%s\",\"rssi\":%d,\"quality\":%d,\"signal\":\"%s\",\"powersave\":\"%s\"},"
                     "\"services\":{\"mqtt_connected\":%s,\"mqtt_state\":\"%s\",\"web_enabled\":%s,\"web_panel_up\":%s,\"web_auth\":\"%s\","
                     "\"archive_available\":%s}",
                     (_stats_history.isEnabled() && _stats_history.isRecentHistoryAvailable()) ? "true" : "false",
                     _stats_history.isPsramBacked() ? "true" : "false",
                     _stats_history.isDegraded() ? "true" : "false",
                     _stats_history.isLiveOnly() ? "true" : "false",
                     static_cast<unsigned>(_stats_history.getSampleCount()),
                     static_cast<unsigned>(_stats_history.getSampleCapacity()),
                     static_cast<unsigned long>(StatsHistory::getSampleIntervalSecs()),
                     _stats_history.hasArchiveRestore() ? "true" : "false",
                     static_cast<unsigned>(_stats_history.getRestoredSampleCount()),
                     static_cast<unsigned long>(StatsHistory::getArchiveSummaryIntervalSecs()),
                     static_cast<unsigned>(_stats_history.getEventCount()),
                     static_cast<unsigned>(_stats_history.getEventCapacity()),
                     archive_name,
                     archive_available ? "true" : "false",
                     archive_path,
                     archive_type,
                     static_cast<unsigned long long>(_archive != nullptr ? _archive->getTotalBytes() : 0),
                     static_cast<unsigned long long>(_archive != nullptr ? _archive->getUsedBytes() : 0),
                     battery_mv,
                     battery_pct,
                     battery_display_pct,
                     battery_min_mv,
                     battery_max_mv,
                     static_cast<unsigned long>(uptime_millis / 1000),
                     _cpu_tracker.getCore0Util() * 100.0f,
                     _err_flags,
                     static_cast<unsigned>(_mgr->getOutboundTotal()),
                     board.isExternalPowered() ? "true" : "false",
                     board.isCharging() ? "true" : "false",
                     board.isVbusPresent() ? "true" : "false",
                     static_cast<int>(_radio->getNoiseFloor()),
                     radio_driver.getLastRSSI(),
                     radio_driver.getLastSNR(),
                     static_cast<unsigned long>(getTotalAirTime() / 1000),
                     static_cast<unsigned long>(getReceiveAirTime() / 1000),
                     static_cast<unsigned>(radio_driver.getPacketsRecv()),
                     static_cast<unsigned>(radio_driver.getPacketsSent()),
                     static_cast<unsigned>(getNumSentFlood()),
                     static_cast<unsigned>(getNumSentDirect()),
                     static_cast<unsigned>(getNumRecvFlood()),
                     static_cast<unsigned>(getNumRecvDirect()),
                     static_cast<unsigned>(radio_driver.getPacketsRecvErrors()),
                     static_cast<unsigned>(((SimpleMeshTables *)getTables())->getNumDirectDups()),
                     static_cast<unsigned>(((SimpleMeshTables *)getTables())->getNumFloodDups()),
                     static_cast<unsigned>(getNeighbourCount()),
                     heap_free,
                     heap_min,
                     heap_max,
                     psram_free,
                     psram_min,
                     psram_max,
                     wifi_ssid,
                     wifi_status,
                     network.isWifiConnected() ? "true" : "false",
                     wifi_state,
                     wifi_code,
                     wifi_ip,
                     wifi_rssi,
                     wifi_quality,
                     wifi_signal,
                     wifi_powersave,
                     mqtt_connected ? "true" : "false",
                     mqtt_state,
                     web.isWebEnabled() ? "true" : "false",
                     web_panel_up ? "true" : "false",
                     web.isPanelUnlocked() ? "unlocked" : "locked",
                     archive_available ? "true" : "false");
  if (offset >= reply_size) {
    return false;
  }

  offset += snprintf(&reply[offset], reply_size - offset, ",");
  if (!appendJsonSensors(reply, reply_size, offset, sensor_snapshot)) {
    return false;
  }
  offset += snprintf(&reply[offset], reply_size - offset, ",");
  if (!appendJsonEvents(reply, reply_size, offset)) {
    return false;
  }
  offset += snprintf(&reply[offset], reply_size - offset, ",");
  if (!appendJsonNeighbours(reply, reply_size, offset)) {
    return false;
  }
  offset += snprintf(&reply[offset], reply_size - offset, "}");
  return offset < reply_size;
#endif
}

bool MyMesh::formatWebStatsSeriesJson(const char* series, char* reply, size_t reply_size) {
#if defined(ESP_PLATFORM) && WITH_WEB_PANEL
  if (!web.isWebStatsEnabled()) {
    if (reply != nullptr && reply_size > 0) {
      reply[0] = 0;
    }
    return false;
  }
  _stats_history.noteAccess(millis());
  return _stats_history.buildSeriesJson(
      series,
      reply,
      reply_size,
      getRTCClock()->getCurrentTime(),
      static_cast<uint32_t>(uptime_millis / 1000));
#else
  (void)series;
  if (reply != nullptr && reply_size > 0) {
    reply[0] = 0;
  }
  return false;
#endif
}

bool MyMesh::appendJsonSensors(char* reply, size_t reply_size, size_t& offset, const WebSensorSnapshot& snapshot) const {
#if defined(ESP_PLATFORM) && WITH_WEB_PANEL
  bool needs_comma = false;
  const int open_written = snprintf(&reply[offset], reply_size - offset, "\"sensors\":{");
  if (open_written < 0 || static_cast<size_t>(open_written) >= (reply_size - offset)) {
    return false;
  }
  offset += static_cast<size_t>(open_written);

  if (snapshot.has_gps) {
    if (!appendJsonBoolField(reply, reply_size, offset, needs_comma, "gps_enabled", snapshot.gps_enabled)) {
      return false;
    }
    if (!appendJsonBoolField(reply, reply_size, offset, needs_comma, "gps_fix", snapshot.gps_fix)) {
      return false;
    }
  }
  if (snapshot.has_satellites) {
    if (!appendJsonLongField(reply, reply_size, offset, needs_comma, "satellites", snapshot.satellites)) {
      return false;
    }
  }
  if (snapshot.has_gps_lat) {
    if (!appendJsonFloatField(reply, reply_size, offset, needs_comma, "gps_lat", snapshot.gps_lat, 6)) {
      return false;
    }
  }
  if (snapshot.has_gps_lon) {
    if (!appendJsonFloatField(reply, reply_size, offset, needs_comma, "gps_lon", snapshot.gps_lon, 6)) {
      return false;
    }
  }
  if (snapshot.has_gps_altitude) {
    if (!appendJsonFloatField(reply, reply_size, offset, needs_comma, "gps_altitude_m", snapshot.gps_altitude_m, 0)) {
      return false;
    }
  }
  if (snapshot.has_supply_voltage) {
    if (!appendJsonFloatField(reply, reply_size, offset, needs_comma, "supply_voltage_v", snapshot.supply_voltage_v, 2)) {
      return false;
    }
  }
  if (snapshot.has_sensor_temp) {
    if (!appendJsonFloatField(reply, reply_size, offset, needs_comma, "sensor_temp_c", snapshot.sensor_temp_c, 1)) {
      return false;
    }
  }
  if (snapshot.has_humidity) {
    if (!appendJsonFloatField(reply, reply_size, offset, needs_comma, "humidity_pct", snapshot.humidity_pct, 0)) {
      return false;
    }
  }
  if (snapshot.has_pressure) {
    if (!appendJsonFloatField(reply, reply_size, offset, needs_comma, "pressure_hpa", snapshot.pressure_hpa, 1)) {
      return false;
    }
  }
  if (snapshot.has_pressure_altitude) {
    if (!appendJsonFloatField(reply, reply_size, offset, needs_comma, "pressure_altitude_m", snapshot.pressure_altitude_m, 0)) {
      return false;
    }
  }
  if (snapshot.has_mcu_temp) {
    if (!appendJsonFloatField(reply, reply_size, offset, needs_comma, "mcu_temp_c", snapshot.mcu_temp_c, 1)) {
      return false;
    }
  }

  const int close_written = snprintf(&reply[offset], reply_size - offset, "}");
  if (close_written < 0 || static_cast<size_t>(close_written) >= (reply_size - offset)) {
    return false;
  }
  offset += static_cast<size_t>(close_written);
  return true;
#else
  (void)reply;
  (void)reply_size;
  (void)offset;
  return false;
#endif
}

void MyMesh::loop() {
#ifdef WITH_BRIDGE
  bridge.loop();
#endif

  const uint32_t now = millis();
  uptime_millis += now - last_millis;
  last_millis = now;

  mesh::Mesh::loop();

  if (next_flood_advert && millisHasNowPassed(next_flood_advert)) {
    mesh::Packet *pkt = createSelfAdvert();
    uint32_t delay_millis = 0;
    if (pkt) sendFloodScoped(default_scope, pkt, delay_millis, _prefs.path_hash_mode + 1);

    updateFloodAdvertTimer(); // schedule next flood advert
    updateAdvertTimer();      // also schedule local advert (so they don't overlap)
  } else if (next_local_advert && millisHasNowPassed(next_local_advert)) {
    mesh::Packet *pkt = createSelfAdvert();
    if (pkt) sendZeroHop(pkt);

    updateAdvertTimer(); // schedule next local advert
  }

  if (set_radio_at && millisHasNowPassed(set_radio_at)) { // apply pending (temporary) radio params
    set_radio_at = 0;                                     // clear timer
    radio_driver.setParams(pending_freq, pending_bw, pending_sf, pending_cr);
    MESH_DEBUG_PRINTLN("Temp radio params");
  }

  if (revert_radio_at && millisHasNowPassed(revert_radio_at)) { // revert radio params to orig
    revert_radio_at = 0;                                        // clear timer
    radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
    MESH_DEBUG_PRINTLN("Radio params restored");
  }

  // is pending dirty contacts write needed?
  if (dirty_contacts_expiry && millisHasNowPassed(dirty_contacts_expiry)) {
    acl.save(_fs);
    dirty_contacts_expiry = 0;
  }

#if defined(ESP_PLATFORM)
  bool network_required = false;
#if WITH_WEB_PANEL
  network_required = web.isWebEnabled();
#endif
#ifdef WITH_MQTT_UPLINK
  network_required = network_required || mqtt.isActive();
#endif
  network.loop(network_required);
#if WITH_WEB_PANEL
  web.loop();
#endif
#endif
#ifdef WITH_MQTT_UPLINK
  MQTTStatusSnapshot mqtt_status{};
  mqtt_status.battery_mv = static_cast<int>(getBatteryMilliVolts());
  mqtt_status.uptime_secs = static_cast<uint32_t>(uptime_millis / 1000);
  mqtt_status.error_flags = _err_flags;
  mqtt_status.queue_len = static_cast<uint16_t>(_mgr->getOutboundTotal());
  mqtt_status.noise_floor = static_cast<int>(_radio->getNoiseFloor());
  mqtt_status.tx_air_secs = static_cast<uint32_t>(getTotalAirTime() / 1000);
  mqtt_status.rx_air_secs = static_cast<uint32_t>(getReceiveAirTime() / 1000);
  mqtt_status.recv_errors = radio_driver.getPacketsRecvErrors();
  mqtt_status.radio_freq = _prefs.freq;
  mqtt_status.radio_bw = _prefs.bw;
  mqtt_status.radio_sf = _prefs.sf;
  mqtt_status.radio_cr = _prefs.cr;
  mqtt.loop(mqtt_status);
#endif
#if defined(ESP_PLATFORM) && WITH_WEB_PANEL
  updateStatsHistory(now);
#endif
}

// To check if there is pending work
bool MyMesh::hasPendingWork() const {
#if defined(WITH_BRIDGE)
  if (bridge.isRunning()) return true;  // bridge needs WiFi radio, can't sleep
#endif
#if defined(WITH_MQTT_UPLINK)
  if (mqtt.isActive()) return true;
#endif
#if defined(ESP_PLATFORM) && WITH_WEB_PANEL
  if (web.isWebEnabled()) return true;
#endif
  return _mgr->getOutboundTotal() > 0;
}