@alteriom/painlessmesh 1.9.18 → 1.9.20

package/src/painlessmesh/gateway.hpp

@@ -345,22 +345,6 @@ struct SharedGatewayConfig {
    */
   bool hasRouterCredentials() const { return routerSSID.length() > 0; }
 
-  /**
-   * @brief Get the estimated memory footprint in bytes
-   *
-   * Returns an estimate of the memory used by this configuration instance.
-   * Useful for monitoring memory usage on constrained devices.
-   *
-   * @return Estimated memory usage in bytes
-   */
-  size_t estimatedMemoryFootprint() const {
-    size_t baseSize = sizeof(SharedGatewayConfig);
-    // Add dynamic string content (not included in sizeof)
-    baseSize += routerSSID.length();
-    baseSize += routerPassword.length();
-    baseSize += internetCheckHost.length();
-    return baseSize;
-  }
 };
 
 /**
@@ -890,21 +874,6 @@ class GatewayDataPackage : public plugin::SinglePackage {
     return ((nodeId & 0xFFFF) << 16) | counter;
   }
 
-  /**
-   * @brief Get the estimated memory footprint
-   *
-   * Returns an estimate of the memory used by this package instance.
-   *
-   * @return Estimated memory usage in bytes
-   */
-  size_t estimatedMemoryFootprint() const {
-    size_t baseSize = sizeof(GatewayDataPackage);
-    // Add dynamic string content (not included in sizeof)
-    baseSize += destination.length();
-    baseSize += payload.length();
-    baseSize += contentType.length();
-    return baseSize;
-  }
 };
 
 /**
@@ -1082,1039 +1051,9 @@ class GatewayAckPackage : public plugin::SinglePackage {
   }
 #endif
 
-  /**
-   * @brief Get the estimated memory footprint
-   *
-   * Returns an estimate of the memory used by this package instance.
-   *
-   * @return Estimated memory usage in bytes
-   */
-  size_t estimatedMemoryFootprint() const {
-    size_t baseSize = sizeof(GatewayAckPackage);
-    // Add dynamic string content (not included in sizeof)
-    baseSize += error.length();
-    return baseSize;
-  }
-};
-
-/**
- * @brief Gateway Heartbeat Package for primary gateway health monitoring
- *
- * This package is broadcast periodically by the primary gateway to inform all
- * nodes in the mesh about the gateway's health status. It provides essential
- * information for:
- * - Gateway availability monitoring
- * - Internet connectivity status
- * - Gateway election decision-making
- * - Failover detection
- *
- * BROADCAST INTERVAL
- * ==================
- * The primary gateway should broadcast heartbeats at the interval configured
- * in SharedGatewayConfig::gatewayHeartbeatInterval (default: 15 seconds).
- *
- * TIMEOUT DETECTION
- * =================
- * If no heartbeat is received within SharedGatewayConfig::gatewayFailureTimeout
- * (default: 45 seconds), the gateway should be considered failed and election
- * may begin.
- *
- * MEMORY FOOTPRINT
- * ================
- * The GatewayHeartbeatPackage structure has an estimated memory footprint of:
- * - Base fields (from BroadcastPackage): ~16 bytes
- * - Fixed fields (isPrimary, hasInternet, routerRSSI, uptime, timestamp): ~11 bytes
- * - Total estimated: ~27 bytes
- *
- * For ESP8266 with ~80KB RAM, this represents <0.1% of available memory.
- * For ESP32 with ~320KB RAM, this represents <0.01% of available memory.
- *
- * Example usage:
- * @code
- * // Primary gateway broadcasting heartbeat
- * GatewayHeartbeatPackage heartbeat;
- * heartbeat.from = mesh.getNodeId();
- * heartbeat.isPrimary = true;
- * heartbeat.hasInternet = internetChecker.hasLocalInternet();
- * heartbeat.routerRSSI = WiFi.RSSI();
- * heartbeat.uptime = millis() / 1000;  // Convert to seconds
- * heartbeat.timestamp = mesh.getNodeTime();
- *
- * mesh.sendPackage(&heartbeat);
- *
- * // Node receiving heartbeat
- * void onHeartbeat(GatewayHeartbeatPackage& heartbeat) {
- *     lastGatewayHeartbeat = millis();
- *     primaryGatewayId = heartbeat.from;
- *     hasGatewayInternet = heartbeat.hasInternet;
- * }
- * @endcode
- *
- * Type ID: 622 (GATEWAY_HEARTBEAT)
- * Base class: BroadcastPackage (sent to all nodes in mesh)
- */
-class GatewayHeartbeatPackage : public plugin::BroadcastPackage {
- public:
-  /**
-   * @brief Indicates if this is the primary gateway
-   *
-   * True if the node sending this heartbeat is the currently elected
-   * primary gateway. Secondary/standby gateways may also send heartbeats
-   * with isPrimary = false for coordination purposes.
-   */
-  bool isPrimary = false;
-
-  /**
-   * @brief Indicates if this gateway has Internet connectivity
-   *
-   * True if the gateway can currently reach the Internet.
-   * Used by other nodes to determine if data can be routed
-   * to Internet services through this gateway.
-   */
-  bool hasInternet = false;
-
-  /**
-   * @brief Signal strength to the router in dBm
-   *
-   * The RSSI value indicating signal quality to the external WiFi router.
-   * Range: typically -90 (weak) to -30 (strong) dBm.
-   * Used in gateway election to prefer gateways with better connections.
-   * Set to 0 if not connected to a router.
-   */
-  int8_t routerRSSI = 0;
-
-  /**
-   * @brief Gateway uptime in seconds
-   *
-   * How long this gateway has been running, in seconds.
-   * Used in election tiebreakers - longer uptime indicates stability.
-   */
-  uint32_t uptime = 0;
-
-  /**
-   * @brief Heartbeat timestamp
-   *
-   * Mesh time when this heartbeat was generated.
-   * Used for calculating latency and detecting stale heartbeats.
-   */
-  uint32_t timestamp = 0;
-
-  /**
-   * @brief Number of additional JSON fields in this package
-   *
-   * Used for jsonObjectSize() calculation in ArduinoJson v6.
-   * Count: primary, internet, rssi, uptime, ts = 5 fields
-   */
-  static constexpr int numPackageFields = 5;
-
-  /**
-   * @brief Default constructor
-   *
-   * Creates a GatewayHeartbeatPackage with type ID 622 (GATEWAY_HEARTBEAT).
-   */
-  GatewayHeartbeatPackage() : BroadcastPackage(protocol::GATEWAY_HEARTBEAT) {}
-
-  /**
-   * @brief Construct from JSON object
-   *
-   * Deserializes a GatewayHeartbeatPackage from a JSON object.
-   * Compatible with ArduinoJson v6 and v7.
-   *
-   * @param jsonObj JSON object containing package data
-   */
-  GatewayHeartbeatPackage(JsonObject jsonObj) : BroadcastPackage(jsonObj) {
-    isPrimary = jsonObj["primary"] | false;
-    hasInternet = jsonObj["internet"] | false;
-    routerRSSI = jsonObj["rssi"] | 0;
-    uptime = jsonObj["uptime"] | 0;
-    timestamp = jsonObj["ts"] | 0;
-  }
-
-  /**
-   * @brief Serialize to JSON object
-   *
-   * Adds all package fields to the provided JSON object.
-   *
-   * @param jsonObj JSON object to add fields to
-   * @return The modified JSON object
-   */
-  JsonObject addTo(JsonObject&& jsonObj) const {
-    jsonObj = BroadcastPackage::addTo(std::move(jsonObj));
-    jsonObj["primary"] = isPrimary;
-    jsonObj["internet"] = hasInternet;
-    jsonObj["rssi"] = routerRSSI;
-    jsonObj["uptime"] = uptime;
-    jsonObj["ts"] = timestamp;
-    return jsonObj;
-  }
-
-#if ARDUINOJSON_VERSION_MAJOR < 7
-  /**
-   * @brief Calculate JSON object size for ArduinoJson v6
-   *
-   * Used for buffer allocation when serializing.
-   *
-   * @return Estimated size in bytes
-   */
-  size_t jsonObjectSize() const {
-    // noJsonFields (from base class) + numPackageFields (our fields)
-    return JSON_OBJECT_SIZE(noJsonFields + numPackageFields);
-  }
-#endif
-
-  /**
-   * @brief Get the estimated memory footprint
-   *
-   * Returns an estimate of the memory used by this package instance.
-   *
-   * @return Estimated memory usage in bytes
-   */
-  size_t estimatedMemoryFootprint() const {
-    // No dynamic strings, so sizeof gives accurate footprint
-    return sizeof(GatewayHeartbeatPackage);
-  }
-
-  /**
-   * @brief Check if this heartbeat indicates a healthy gateway
-   *
-   * A gateway is considered healthy if it is primary and has Internet access.
-   *
-   * @return true if the gateway is healthy
-   */
-  bool isHealthy() const {
-    return isPrimary && hasInternet;
-  }
-
-  /**
-   * @brief Check if the router signal strength is acceptable
-   *
-   * Signal strength is considered acceptable if RSSI is better than -70 dBm.
-   * This is a typical threshold for reliable WiFi connectivity.
-   *
-   * @return true if signal strength is acceptable
-   */
-  bool hasAcceptableSignal() const {
-    // RSSI of 0 typically means not connected
-    // RSSI better than -70 dBm is considered acceptable
-    return routerRSSI != 0 && routerRSSI > -70;
-  }
-};
-
-/**
- * @brief Gateway Election Manager for coordinating primary gateway selection
- *
- * This class implements a deterministic election protocol for selecting a
- * primary gateway in the mesh network. It provides:
- * - Primary gateway failure detection via heartbeat monitoring
- * - Deterministic winner selection (highest RSSI, then highest node ID)
- * - Split-brain prevention during elections
- * - Cooldown period to prevent election thrashing
- *
- * ELECTION STATE MACHINE
- * ======================
- * The manager operates in three states:
- * 1. IDLE: Monitoring heartbeats, no election in progress
- * 2. ELECTION_RUNNING: Election triggered, collecting candidates
- * 3. COOLDOWN: Post-election cooldown to prevent rapid re-elections
- *
- * ELECTION ALGORITHM
- * ==================
- * Only nodes with Internet connectivity (hasInternet == true) can be candidates.
- * Winner is selected by:
- * 1. Highest RSSI wins
- * 2. If RSSI tie, highest node ID wins
- *
- * This ensures deterministic, consistent winner selection across all nodes.
- *
- * MEMORY FOOTPRINT
- * ================
- * The GatewayElectionManager has an estimated memory footprint of:
- * - Fixed fields: ~60 bytes
- * - Candidate map: ~40 bytes per candidate + map overhead
- * - Total estimated: ~200-500 bytes depending on candidate count
- *
- * Example usage:
- * @code
- * GatewayElectionManager election;
- * election.configure(gatewayConfig);
- * election.setNodeId(mesh.getNodeId());
- * election.setLocalCandidate(internetChecker.hasLocalInternet(), WiFi.RSSI());
- *
- * // In heartbeat callback
- * void onHeartbeat(GatewayHeartbeatPackage& heartbeat) {
- *     election.processHeartbeat(heartbeat);
- * }
- *
- * // In update loop (call periodically)
- * if (election.update(millis())) {
- *     // This node won the election, broadcast as primary
- *     broadcastPrimaryHeartbeat();
- * }
- *
- * // Register callback for election results
- * election.onElectionResult([](uint32_t winnerId, bool isLocal) {
- *     Serial.printf("Election winner: %u (local: %s)\n",
- *                   winnerId, isLocal ? "yes" : "no");
- * });
- * @endcode
- */
-class GatewayElectionManager {
- public:
-  /**
-   * @brief Election state machine states
-   */
-  enum class ElectionState {
-    IDLE,             ///< Monitoring heartbeats, no election in progress
-    ELECTION_RUNNING, ///< Election triggered, collecting candidates
-    COOLDOWN          ///< Post-election cooldown period
-  };
-
-  /**
-   * @brief Callback type for election result notifications
-   * @param winnerId The node ID of the election winner
-   * @param isLocalNode True if this node is the winner
-   */
-  typedef std::function<void(uint32_t winnerId, bool isLocalNode)>
-      ElectionResultCallback_t;
-
-  /**
-   * @brief Default constructor
-   *
-   * Creates a GatewayElectionManager with default configuration:
-   * - gatewayFailureTimeout: 45000ms
-   * - electionDuration: 5000ms
-   * - electionCooldownPeriod: 60000ms
-   */
-  GatewayElectionManager()
-      : state_(ElectionState::IDLE),
-        nodeId_(0),
-        localHasInternet_(false),
-        localRssi_(0),
-        primaryGatewayId_(0),
-        isElectedPrimary_(false),
-        lastPrimaryHeartbeatTime_(0),
-        electionStartTime_(0),
-        cooldownStartTime_(0),
-        gatewayFailureTimeout_(45000),
-        electionDuration_(5000),
-        electionCooldownPeriod_(60000) {}
-
-  /**
-   * @brief Configure the election manager using SharedGatewayConfig
-   *
-   * Updates the failure timeout from the provided configuration.
-   *
-   * @param config SharedGatewayConfig with timeout parameters
-   */
-  void configure(const SharedGatewayConfig& config) {
-    gatewayFailureTimeout_ = config.gatewayFailureTimeout;
-    Log(logger::GENERAL,
-        "GatewayElectionManager: Configured with failureTimeout=%ums\n",
-        gatewayFailureTimeout_);
-  }
-
-  /**
-   * @brief Set the local node ID
-   *
-   * Must be called before the manager can participate in elections.
-   *
-   * @param nodeId The local node's unique identifier
-   */
-  void setNodeId(uint32_t nodeId) {
-    nodeId_ = nodeId;
-    Log(logger::GENERAL, "GatewayElectionManager: Node ID set to %u\n", nodeId_);
-  }
-
-  /**
-   * @brief Set the local node's election candidacy parameters
-   *
-   * Updates whether this node can participate in elections based on
-   * Internet connectivity and signal strength.
-   *
-   * @param hasInternet True if this node has Internet connectivity
-   * @param rssi Signal strength to the router in dBm
-   */
-  void setLocalCandidate(bool hasInternet, int8_t rssi) {
-    localHasInternet_ = hasInternet;
-    localRssi_ = rssi;
-  }
-
-  /**
-   * @brief Process an incoming gateway heartbeat
-   *
-   * Updates internal state based on the received heartbeat:
-   * - If from primary, updates last heartbeat time
-   * - If during election, may defer to higher-priority primary
-   *
-   * @param heartbeat The received GatewayHeartbeatPackage
-   * @param currentTime Current time in milliseconds (e.g., millis())
-   */
-  void processHeartbeat(const GatewayHeartbeatPackage& heartbeat,
-                        uint32_t currentTime) {
-    // Track this node as a potential candidate if it has Internet
-    if (heartbeat.hasInternet) {
-      Candidate candidate;
-      candidate.nodeId = heartbeat.from;
-      candidate.rssi = heartbeat.routerRSSI;
-      candidate.hasInternet = heartbeat.hasInternet;
-      candidate.lastSeen = currentTime;
-      candidates_[heartbeat.from] = candidate;
-    }
-
-    // Handle heartbeat from a node claiming to be primary
-    if (heartbeat.isPrimary) {
-      // During election, check for split-brain prevention
-      if (state_ == ElectionState::ELECTION_RUNNING) {
-        // If sender has higher priority (higher RSSI, or same RSSI and higher
-        // nodeId), defer to them
-        if (shouldDeferTo(heartbeat.routerRSSI, heartbeat.from)) {
-          Log(logger::GENERAL,
-              "GatewayElectionManager: Deferring to primary node %u "
-              "(RSSI=%d)\n",
-              heartbeat.from, heartbeat.routerRSSI);
-          primaryGatewayId_ = heartbeat.from;
-          isElectedPrimary_ = false;
-          lastPrimaryHeartbeatTime_ = currentTime;
-          transitionToCooldown(currentTime);
-          return;
-        }
-      } else {
-        // Not in election, accept this node as primary
-        primaryGatewayId_ = heartbeat.from;
-        lastPrimaryHeartbeatTime_ = currentTime;
-
-        // If we were primary but another node claims primary with higher
-        // priority, step down
-        if (isElectedPrimary_ && heartbeat.from != nodeId_) {
-          if (shouldDeferTo(heartbeat.routerRSSI, heartbeat.from)) {
-            Log(logger::GENERAL,
-                "GatewayElectionManager: Stepping down, deferring to node %u\n",
-                heartbeat.from);
-            isElectedPrimary_ = false;
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * @brief Process an incoming gateway heartbeat (convenience overload)
-   *
-   * Calls processHeartbeat(heartbeat, millis()) for backward compatibility.
-   * For testing, prefer processHeartbeat(heartbeat, currentTime) for
-   * deterministic behavior.
-   *
-   * @param heartbeat The received GatewayHeartbeatPackage
-   */
-  void processHeartbeat(const GatewayHeartbeatPackage& heartbeat) {
-    processHeartbeat(heartbeat, millis());
-  }
-
-  /**
-   * @brief Update the election state machine
-   *
-   * Should be called periodically (e.g., every second) to:
-   * - Check for primary gateway timeout
-   * - Progress election state machine
-   * - Determine election winners
-   *
-   * @param currentTime Current time in milliseconds (e.g., millis())
-   * @return true if this node should broadcast as primary (won election)
-   */
-  bool update(uint32_t currentTime) {
-    bool shouldBroadcastAsPrimary = false;
-
-    switch (state_) {
-      case ElectionState::IDLE:
-        // Check if primary gateway has timed out
-        if (primaryGatewayId_ != 0 && lastPrimaryHeartbeatTime_ != 0) {
-          uint32_t timeSinceLastHeartbeat =
-              currentTime - lastPrimaryHeartbeatTime_;
-          if (timeSinceLastHeartbeat > gatewayFailureTimeout_) {
-            Log(logger::GENERAL,
-                "GatewayElectionManager: Primary gateway %u timed out "
-                "(no heartbeat for %ums)\n",
-                primaryGatewayId_, timeSinceLastHeartbeat);
-            // Primary failed, start election if we can participate
-            if (canParticipateInElection()) {
-              startElection(currentTime);
-            } else {
-              // Can't participate, just clear the primary
-              primaryGatewayId_ = 0;
-            }
-          }
-        } else if (primaryGatewayId_ == 0 && canParticipateInElection()) {
-          // No known primary and we can participate, start election
-          startElection(currentTime);
-        }
-        break;
-
-      case ElectionState::ELECTION_RUNNING:
-        // Check if election duration has elapsed
-        if (currentTime - electionStartTime_ >= electionDuration_) {
-          // Election complete, select winner
-          uint32_t winnerId = selectWinner();
-          if (winnerId != 0) {
-            primaryGatewayId_ = winnerId;
-            isElectedPrimary_ = (winnerId == nodeId_);
-
-            Log(logger::GENERAL,
-                "GatewayElectionManager: Election complete, winner=%u "
-                "(local=%s)\n",
-                winnerId, isElectedPrimary_ ? "yes" : "no");
-
-            // Notify via callback
-            if (electionResultCallback_) {
-              electionResultCallback_(winnerId, isElectedPrimary_);
-            }
-
-            if (isElectedPrimary_) {
-              shouldBroadcastAsPrimary = true;
-              lastPrimaryHeartbeatTime_ = currentTime;
-            }
-          } else {
-            Log(logger::GENERAL,
-                "GatewayElectionManager: Election complete, no valid candidates\n");
-            primaryGatewayId_ = 0;
-            isElectedPrimary_ = false;
-          }
-
-          transitionToCooldown(currentTime);
-        }
-        break;
-
-      case ElectionState::COOLDOWN:
-        // Check if cooldown period has elapsed
-        if (currentTime - cooldownStartTime_ >= electionCooldownPeriod_) {
-          Log(logger::GENERAL,
-              "GatewayElectionManager: Cooldown complete, returning to IDLE\n");
-          state_ = ElectionState::IDLE;
-        }
-        break;
-    }
-
-    return shouldBroadcastAsPrimary;
-  }
-
-  /**
-   * @brief Check if this node is the elected primary gateway
-   * @return true if this node won the last election
-   */
-  bool isElectedPrimary() const { return isElectedPrimary_; }
-
-  /**
-   * @brief Get the current election state
-   * @return Current ElectionState
-   */
-  ElectionState getState() const { return state_; }
-
-  /**
-   * @brief Get the current primary gateway node ID
-   * @return Primary gateway node ID, or 0 if none
-   */
-  uint32_t getPrimaryGatewayId() const { return primaryGatewayId_; }
-
-  /**
-   * @brief Register a callback for election results
-   *
-   * The callback is invoked when an election completes with the winner's
-   * node ID and whether this node is the winner.
-   *
-   * @param callback Function to call on election completion
-   */
-  void onElectionResult(ElectionResultCallback_t callback) {
-    electionResultCallback_ = callback;
-  }
-
-  /**
-   * @brief Force start an election
-   *
-   * Manually triggers an election, useful for testing or when a node
-   * needs to force re-election. Only starts if not already in election
-   * or cooldown.
-   *
-   * @param currentTime Current time in milliseconds (e.g., millis())
-   */
-  void startElection(uint32_t currentTime) {
-    if (state_ != ElectionState::IDLE) {
-      Log(logger::GENERAL,
-          "GatewayElectionManager: Cannot start election, state=%d\n",
-          static_cast<int>(state_));
-      return;
-    }
-
-    Log(logger::GENERAL,
-        "GatewayElectionManager: Starting election (nodeId=%u, "
-        "hasInternet=%s, rssi=%d)\n",
-        nodeId_, localHasInternet_ ? "yes" : "no", localRssi_);
-
-    state_ = ElectionState::ELECTION_RUNNING;
-    electionStartTime_ = currentTime;
-    isElectedPrimary_ = false;
-
-    // Clear old candidates and add self if eligible
-    candidates_.clear();
-    if (localHasInternet_ && nodeId_ != 0) {
-      Candidate localCandidate;
-      localCandidate.nodeId = nodeId_;
-      localCandidate.rssi = localRssi_;
-      localCandidate.hasInternet = localHasInternet_;
-      localCandidate.lastSeen = electionStartTime_;
-      candidates_[nodeId_] = localCandidate;
-    }
-  }
-
-  /**
-   * @brief Force start an election (convenience overload)
-   *
-   * Calls startElection(millis()) for backward compatibility.
-   * For testing, prefer startElection(currentTime) for deterministic behavior.
-   */
-  void startElection() { startElection(millis()); }
-
-  /**
-   * @brief Reset all election state
-   *
-   * Clears all state including primary gateway, candidates, and returns
-   * to IDLE state. Does not clear configuration or node ID.
-   */
-  void reset() {
-    state_ = ElectionState::IDLE;
-    primaryGatewayId_ = 0;
-    isElectedPrimary_ = false;
-    lastPrimaryHeartbeatTime_ = 0;
-    electionStartTime_ = 0;
-    cooldownStartTime_ = 0;
-    candidates_.clear();
-    Log(logger::GENERAL, "GatewayElectionManager: State reset\n");
-  }
-
-  /**
-   * @brief Set the election duration
-   * @param durationMs Duration in milliseconds (default: 5000)
-   */
-  void setElectionDuration(uint32_t durationMs) {
-    electionDuration_ = durationMs;
-  }
-
-  /**
-   * @brief Set the cooldown period
-   * @param periodMs Cooldown period in milliseconds (default: 60000)
-   */
-  void setCooldownPeriod(uint32_t periodMs) {
-    electionCooldownPeriod_ = periodMs;
-  }
-
-  /**
-   * @brief Get the number of known candidates
-   * @return Number of candidates in the current election
-   */
-  size_t getCandidateCount() const { return candidates_.size(); }
-
- private:
-  /**
-   * @brief Internal structure for tracking election candidates
-   */
-  struct Candidate {
-    uint32_t nodeId = 0;
-    int8_t rssi = 0;
-    bool hasInternet = false;
-    uint32_t lastSeen = 0;
-  };
-
-  /**
-   * @brief Check if this node can participate in elections
-   * @return true if node has Internet and valid node ID
-   */
-  bool canParticipateInElection() const {
-    return localHasInternet_ && nodeId_ != 0;
-  }
-
-  /**
-   * @brief Check if we should defer to another node
-   *
-   * Used for split-brain prevention. Defers to nodes with:
-   * 1. Higher RSSI, or
-   * 2. Same RSSI and higher node ID
-   *
-   * @param otherRssi The other node's RSSI
-   * @param otherNodeId The other node's ID
-   * @return true if we should defer to the other node
-   */
-  bool shouldDeferTo(int8_t otherRssi, uint32_t otherNodeId) const {
-    // Higher RSSI wins
-    if (otherRssi > localRssi_) return true;
-    if (otherRssi < localRssi_) return false;
-    // Same RSSI, higher node ID wins
-    return otherNodeId > nodeId_;
-  }
-
-  /**
-   * @brief Select the winner from current candidates
-   *
-   * Implements deterministic winner selection:
-   * 1. Highest RSSI wins
-   * 2. If RSSI tie, highest node ID wins
-   *
-   * @return Winner's node ID, or 0 if no valid candidates
-   */
-  uint32_t selectWinner() const {
-    uint32_t winnerId = 0;
-    int8_t winnerRssi = -128;  // Minimum possible RSSI
-
-    for (const auto& pair : candidates_) {
-      const Candidate& candidate = pair.second;
-
-      // Only consider candidates with Internet
-      if (!candidate.hasInternet) continue;
-
-      // Check if this candidate beats the current winner
-      bool isBetter = false;
-      if (candidate.rssi > winnerRssi) {
-        isBetter = true;
-      } else if (candidate.rssi == winnerRssi && candidate.nodeId > winnerId) {
-        isBetter = true;
-      }
-
-      if (isBetter) {
-        winnerId = candidate.nodeId;
-        winnerRssi = candidate.rssi;
-      }
-    }
-
-    return winnerId;
-  }
-
-  /**
-   * @brief Transition to cooldown state
-   * @param currentTime Current time in milliseconds
-   */
-  void transitionToCooldown(uint32_t currentTime) {
-    state_ = ElectionState::COOLDOWN;
-    cooldownStartTime_ = currentTime;
-    candidates_.clear();
-  }
-
-  // State
-  ElectionState state_;
-  uint32_t nodeId_;
-  bool localHasInternet_;
-  int8_t localRssi_;
-  uint32_t primaryGatewayId_;
-  bool isElectedPrimary_;
-  uint32_t lastPrimaryHeartbeatTime_;
-  uint32_t electionStartTime_;
-  uint32_t cooldownStartTime_;
-
-  // Configuration
-  uint32_t gatewayFailureTimeout_;
-  uint32_t electionDuration_;
-  uint32_t electionCooldownPeriod_;
-
-  // Candidates map: nodeId -> Candidate
-  std::map<uint32_t, Candidate> candidates_;
-
-  // Callback
-  ElectionResultCallback_t electionResultCallback_;
-};
-
-/**
- * @brief Metrics for monitoring GatewayMessageHandler duplicate detection
- *
- * This structure tracks statistics about message processing and duplicate
- * detection in the gateway message handler. Useful for monitoring system
- * health and debugging duplicate-related issues.
- *
- * Example usage:
- * @code
- * GatewayMessageHandler handler;
- * // ... process messages ...
- * GatewayMetrics metrics = handler.getMetrics();
- * Serial.printf("Duplicates: %u, Processed: %u\n",
- *               metrics.duplicatesDetected, metrics.messagesProcessed);
- * @endcode
- */
-struct GatewayMetrics {
-  /**
-   * @brief Count of duplicate messages detected and dropped
-   *
-   * Incremented each time an incoming message is identified as a duplicate
-   * and skipped from processing.
-   */
-  uint32_t duplicatesDetected = 0;
-
-  /**
-   * @brief Total count of messages successfully processed
-   *
-   * Incremented for each unique message that passes duplicate checking
-   * and is processed.
-   */
-  uint32_t messagesProcessed = 0;
-
-  /**
-   * @brief Count of acknowledgments sent
-   *
-   * Incremented each time an acknowledgment is sent for a message.
-   */
-  uint32_t acknowledgmentsSent = 0;
-
-  /**
-   * @brief Count of duplicate acknowledgments skipped
-   *
-   * Incremented when an acknowledgment would have been sent, but was
-   * skipped because one was already sent for that message.
-   */
-  uint32_t duplicateAcksSkipped = 0;
-
-  /**
-   * @brief Reset all metrics to zero
-   */
-  void reset() {
-    duplicatesDetected = 0;
-    messagesProcessed = 0;
-    acknowledgmentsSent = 0;
-    duplicateAcksSkipped = 0;
-  }
-
-  /**
-   * @brief Get the duplicate detection rate as a percentage
-   * @return Percentage of messages that were duplicates (0-100), or 0 if no messages
-   */
-  uint8_t getDuplicateRate() const {
-    uint64_t total = static_cast<uint64_t>(messagesProcessed) +
-                     static_cast<uint64_t>(duplicatesDetected);
-    if (total == 0) return 0;
-    // Use uint64_t arithmetic to prevent overflow
-    return static_cast<uint8_t>((static_cast<uint64_t>(duplicatesDetected) * 100) / total);
-  }
-
-  /**
-   * @brief Get the duplicate ack rate as a percentage
-   * @return Percentage of acks that were duplicates (0-100), or 0 if no acks
-   */
-  uint8_t getDuplicateAckRate() const {
-    uint64_t total = static_cast<uint64_t>(acknowledgmentsSent) +
-                     static_cast<uint64_t>(duplicateAcksSkipped);
-    if (total == 0) return 0;
-    // Use uint64_t arithmetic to prevent overflow
-    return static_cast<uint8_t>((static_cast<uint64_t>(duplicateAcksSkipped) * 100) / total);
-  }
 };
 
 }  // namespace gateway
-
-/**
- * @brief Gateway Message Handler with duplicate prevention
- *
- * This class integrates MessageTracker to prevent duplicate message processing
- * in gateway operations. It provides:
- * - Duplicate message detection and dropping
- * - Single acknowledgment per message enforcement
- * - Metrics for monitoring duplicate detection
- * - Configurable tracker limits via SharedGatewayConfig
- * - Logging for duplicate detection events
- *
- * MEMORY FOOTPRINT
- * ================
- * The GatewayMessageHandler uses a MessageTracker internally, which stores
- * message entries in a std::map. Memory usage depends on configuration:
- * - Default (500 messages): ~20KB estimated
- * - ESP8266 recommended (100 messages): ~4KB estimated
- * - Each tracked message: ~40 bytes (MessageKey + TrackedMessage + map overhead)
- *
- * Example usage:
- * @code
- * GatewayMessageHandler handler;
- *
- * // Configure from shared gateway config
- * SharedGatewayConfig config;
- * config.maxTrackedMessages = 500;
- * config.duplicateTrackingTimeout = 60000;
- * handler.configure(config);
- *
- * // Handle incoming message
- * GatewayDataPackage pkg;
- * // ... populate pkg ...
- *
- * if (handler.handleIncomingMessage(pkg)) {
- *     // Process the message - it's not a duplicate
- *     processGatewayRequest(pkg);
- *
- *     // Check if we should send an ack
- *     if (pkg.requiresAck && handler.shouldSendAcknowledgment(pkg.messageId, pkg.originNode)) {
- *         sendAck(pkg);
- *         handler.markAcknowledgmentSent(pkg.messageId, pkg.originNode);
- *     }
- * }
- *
- * // Periodically cleanup old entries
- * handler.cleanup();
- *
- * // Monitor metrics
- * auto metrics = handler.getMetrics();
- * @endcode
- */
-class GatewayMessageHandler {
- public:
-  /**
-   * @brief Default constructor
-   *
-   * Creates a GatewayMessageHandler with default configuration:
-   * - maxTrackedMessages: 500
-   * - duplicateTrackingTimeout: 60000ms (60 seconds)
-   */
-  GatewayMessageHandler() : tracker_(500, 60000) {}
-
-  /**
-   * @brief Configure the handler using SharedGatewayConfig parameters
-   *
-   * Updates the internal MessageTracker with configuration values from
-   * the provided SharedGatewayConfig. This should be called before
-   * processing messages to ensure proper configuration.
-   *
-   * @param config SharedGatewayConfig with tracker parameters
-   */
-  void configure(const gateway::SharedGatewayConfig& config) {
-    tracker_.setMaxMessages(config.maxTrackedMessages);
-    tracker_.setTimeoutMs(config.duplicateTrackingTimeout);
-    Log(logger::GENERAL,
-        "GatewayMessageHandler: Configured with maxMessages=%u, timeout=%ums\n",
-        config.maxTrackedMessages, config.duplicateTrackingTimeout);
-  }
-
-  /**
-   * @brief Handle an incoming GatewayDataPackage and check for duplicates
-   *
-   * Checks if the message has already been processed using the MessageTracker.
-   * If the message is a duplicate, it is dropped silently and metrics are updated.
-   * If the message is new, it is marked as processed and should be handled.
-   *
-   * @param pkg The incoming GatewayDataPackage to check
-   * @return true if the message should be processed (not a duplicate)
-   * @return false if the message is a duplicate and should be skipped
-   */
-  bool handleIncomingMessage(const gateway::GatewayDataPackage& pkg) {
-    // Check if this message was already processed
-    if (tracker_.isProcessed(pkg.messageId, pkg.originNode)) {
-      metrics_.duplicatesDetected++;
-      Log(logger::GENERAL,
-          "GatewayMessageHandler: Duplicate message detected (msgId=%u, origin=%u)\n",
-          pkg.messageId, pkg.originNode);
-      return false;
-    }
-
-    // Mark as processed and allow handling
-    tracker_.markProcessed(pkg.messageId, pkg.originNode);
-    metrics_.messagesProcessed++;
-    Log(logger::GENERAL,
-        "GatewayMessageHandler: Processing new message (msgId=%u, origin=%u)\n",
-        pkg.messageId, pkg.originNode);
-    return true;
-  }
-
-  /**
-   * @brief Check if an acknowledgment should be sent for a message
-   *
-   * Checks if an acknowledgment has already been sent for the specified
-   * message. This prevents sending duplicate acknowledgments during
-   * network partitions or message retries.
-   *
-   * @param messageId The unique message identifier
-   * @param originNode The node that originated the message
-   * @return true if acknowledgment should be sent (not already acked)
-   * @return false if acknowledgment was already sent (skip sending)
-   */
-  bool shouldSendAcknowledgment(uint32_t messageId, uint32_t originNode) {
-    // Check if we already sent an ack for this message
-    if (tracker_.isAcknowledged(messageId, originNode)) {
-      metrics_.duplicateAcksSkipped++;
-      Log(logger::GENERAL,
-          "GatewayMessageHandler: Duplicate ack skipped (msgId=%u, origin=%u)\n",
-          messageId, originNode);
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * @brief Mark that an acknowledgment has been sent for a message
-   *
-   * Records that an acknowledgment was sent for the specified message.
-   * Subsequent calls to shouldSendAcknowledgment() for this message
-   * will return false.
-   *
-   * @param messageId The unique message identifier
-   * @param originNode The node that originated the message
-   */
-  void markAcknowledgmentSent(uint32_t messageId, uint32_t originNode) {
-    // First ensure the message is tracked (in case ack is sent before processing)
-    if (!tracker_.isProcessed(messageId, originNode)) {
-      tracker_.markProcessed(messageId, originNode);
-    }
-
-    tracker_.markAcknowledged(messageId, originNode);
-    metrics_.acknowledgmentsSent++;
-    Log(logger::GENERAL,
-        "GatewayMessageHandler: Acknowledgment sent (msgId=%u, origin=%u)\n",
-        messageId, originNode);
-  }
-
-  /**
-   * @brief Cleanup old entries from the tracker
-   *
-   * Removes expired entries from the internal MessageTracker based on
-   * the configured timeout. Should be called periodically to free memory.
-   *
-   * @return Number of entries removed
-   */
-  uint32_t cleanup() {
-    return tracker_.cleanup();
-  }
-
-  /**
-   * @brief Get current metrics for monitoring
-   *
-   * Returns a copy of the current metrics structure containing
-   * statistics about duplicate detection and message processing.
-   *
-   * @return GatewayMetrics structure with current statistics
-   */
-  gateway::GatewayMetrics getMetrics() const {
-    return metrics_;
-  }
-
-  /**
-   * @brief Reset all metrics to zero
-   *
-   * Clears all metrics counters. Does not affect tracked messages.
-   */
-  void resetMetrics() {
-    metrics_.reset();
-    Log(logger::GENERAL, "GatewayMessageHandler: Metrics reset\n");
-  }
-
-  /**
-   * @brief Get the number of currently tracked messages
-   * @return Number of entries in the tracker
-   */
-  size_t getTrackedMessageCount() const {
-    return tracker_.size();
-  }
-
-  /**
-   * @brief Clear all tracked messages
-   *
-   * Removes all entries from the tracker. Does not affect metrics.
-   */
-  void clearTrackedMessages() {
-    tracker_.clear();
-  }
-
- private:
-  MessageTracker tracker_;
-  gateway::GatewayMetrics metrics_;
-};
-
 }  // namespace painlessmesh
 
 #endif  // _PAINLESS_MESH_GATEWAY_HPP_