// Line 195-196: Bug in copy constructor with grown capacity can cause segmentation fault
static size_t baseCapacity = 512;
auto variant = std::make_shared<protocol::Variant>(pkg, pkg.length() + baseCapacity);

while (variant->error == DeserializationError::NoMemory && baseCapacity <= 20480) {
    baseCapacity += 256;
    variant = std::make_shared<protocol::Variant>(pkg, pkg.length() + baseCapacity);
}

// Calculate capacity based on JSON structure depth
size_t calculateJsonCapacity(const TSTRING& pkg) {
    size_t baseSize = pkg.length();
    size_t nestingDepth = std::count(pkg.begin(), pkg.end(), '{') + 
                         std::count(pkg.begin(), pkg.end(), '[');
    
    // Each nesting level adds overhead for pointers and metadata
    size_t overhead = JSON_OBJECT_SIZE(10) * nestingDepth + 256;
    return baseSize + overhead;
}

// Usage
auto variant = std::make_shared<protocol::Variant>(
    pkg, calculateJsonCapacity(pkg)
);

if (variant->error != DeserializationError::Ok) {
    Log(ERROR, "routePackage(): JSON parse error: %d\n", variant->error);
    return; // Fail fast instead of retrying
}

// Use generous fixed capacity based on mesh constraints
constexpr size_t MAX_MESSAGE_SIZE = 4096; // Documented mesh limit
constexpr size_t JSON_CAPACITY = MAX_MESSAGE_SIZE + JSON_OBJECT_SIZE(20) + 512;

auto variant = std::make_shared<protocol::Variant>(pkg, JSON_CAPACITY);

if (variant->error != DeserializationError::Ok) {
    Log(ERROR, "routePackage(): Message too large (%u bytes) or malformed\n", 
        pkg.length());
    // Increment metrics for oversized packets
    return;
}

// Consider migrating to ArduinoJson v7 with improved memory management
#if ARDUINOJSON_VERSION_MAJOR >= 7
    // v7 has better automatic capacity management
    JsonDocument doc;
    DeserializationError error = deserializeJson(doc, pkg);
    
    if (error) {
        Log(ERROR, "routePackage(): Parse error: %s\n", error.c_str());
        return;
    }
    
    auto variant = protocol::Variant(doc.as<JsonObject>());
#else
    // Fallback for v6
    // ...existing implementation with fixes...
#endif

int getHopCount(uint32_t nodeId) {
    // TODO: Implement proper hop count calculation
    
    // Check if node exists in mesh
    bool nodeExists = false;
    auto nodes = getNodeList();
    for (auto node : nodes) {
        if (node == nodeId) {
            nodeExists = true;
            break;
        }
    }
    
    if (!nodeExists) return -1;
    
    // For now, return 2 for any node in the mesh
    return 2; // Stub implementation
}

int getHopCount(uint32_t nodeId) {
    if (nodeId == this->nodeId) return 0; // Self
    
    auto topology = asNodeTree();
    
    // BFS queue: pair of (node, hop_count)
    std::queue<std::pair<layout::NodeTree, int>> queue;
    std::set<uint32_t> visited;
    
    queue.push({topology, 0});
    visited.insert(topology.nodeId);
    
    while (!queue.empty()) {
        auto [current, hops] = queue.front();
        queue.pop();
        
        // Check all children of current node
        for (const auto& child : current.subs) {
            if (child.nodeId == nodeId) {
                return hops + 1; // Found target
            }
            
            if (visited.find(child.nodeId) == visited.end()) {
                visited.insert(child.nodeId);
                queue.push({child, hops + 1});
            }
        }
    }
    
    return -1; // Node not found in mesh
}

class Mesh {
private:
    // Cache hop counts after topology changes
    std::map<uint32_t, int> hopCountCache_;
    uint32_t topologyVersion_ = 0; // Increment on topology changes
    
public:
    int getHopCount(uint32_t nodeId) {
        // Check cache
        auto it = hopCountCache_.find(nodeId);
        if (it != hopCountCache_.end()) {
            return it->second;
        }
        
        // Calculate and cache
        int hops = calculateHopCountBFS(nodeId);
        hopCountCache_[nodeId] = hops;
        return hops;
    }
    
    // Call when topology changes (onNewConnection, onDroppedConnection)
    void invalidateHopCountCache() {
        hopCountCache_.clear();
        topologyVersion_++;
    }
    
private:
    int calculateHopCountBFS(uint32_t nodeId) {
        // ... BFS implementation from above ...
    }
};

void onNewConnection(uint32_t nodeId) {
    invalidateHopCountCache();
    // ... existing logic ...
}

void onDroppedConnection(uint32_t nodeId) {
    invalidateHopCountCache();
    // ... existing logic ...
}

void onChangedConnections() {
    invalidateHopCountCache();
    // ... existing logic ...
}

// test/catch/catch_mesh_hop_count.cpp
SCENARIO("Hop count calculation for multi-hop mesh") {
    GIVEN("A linear topology: A -> B -> C -> D") {
        // A is root
        REQUIRE(meshA.getHopCount(meshA.getNodeId()) == 0); // Self
        REQUIRE(meshA.getHopCount(meshB.getNodeId()) == 1); // Direct child
        REQUIRE(meshA.getHopCount(meshC.getNodeId()) == 2); // Grandchild
        REQUIRE(meshA.getHopCount(meshD.getNodeId()) == 3); // Great-grandchild
    }
    
    GIVEN("A star topology: B,C,D all connect to A") {
        REQUIRE(meshA.getHopCount(meshB.getNodeId()) == 1);
        REQUIRE(meshA.getHopCount(meshC.getNodeId()) == 1);
        REQUIRE(meshA.getHopCount(meshD.getNodeId()) == 1);
    }
    
    GIVEN("Node not in mesh") {
        REQUIRE(meshA.getHopCount(99999) == -1);
    }
}

std::map<uint32_t, std::vector<uint32_t>> getRoutingTable() {
    std::map<uint32_t, std::vector<uint32_t>> routingTable;
    
    // TODO: Implement proper routing table lookup for multi-hop paths
    // Currently only returns direct connections
    
    auto connections = getNodeList();
    for (auto nodeId : connections) {
        routingTable[nodeId] = {nodeId}; // Direct path only
    }
    
    return routingTable;
}

struct RouteEntry {
    uint32_t destination;     // Target node ID
    uint32_t nextHop;         // Next hop to reach destination
    int hopCount;             // Number of hops to destination
    uint32_t lastUpdated;     // Timestamp for staleness detection
};

class Mesh {
private:
    std::map<uint32_t, RouteEntry> routingTable_;
    
public:
    // Build routing table using Dijkstra's algorithm
    void rebuildRoutingTable() {
        routingTable_.clear();
        auto topology = asNodeTree();
        
        // Priority queue: (hop_count, current_node, first_hop)
        using QueueEntry = std::tuple<int, uint32_t, uint32_t>;
        std::priority_queue<QueueEntry, std::vector<QueueEntry>, 
                          std::greater<QueueEntry>> pq;
        
        std::set<uint32_t> visited;
        
        // Initialize with direct connections
        for (const auto& conn : topology.subs) {
            pq.push({1, conn.nodeId, conn.nodeId});
        }
        
        while (!pq.empty()) {
            auto [hops, currentNode, firstHop] = pq.top();
            pq.pop();
            
            if (visited.find(currentNode) != visited.end()) continue;
            visited.insert(currentNode);
            
            // Add to routing table
            routingTable_[currentNode] = {
                currentNode,
                firstHop,
                hops,
                getNodeTime()
            };
            
            // Find neighbors of currentNode
            auto subtree = findNodeInTree(topology, currentNode);
            if (subtree) {
                for (const auto& neighbor : subtree->subs) {
                    if (visited.find(neighbor.nodeId) == visited.end()) {
                        pq.push({hops + 1, neighbor.nodeId, firstHop});
                    }
                }
            }
        }
    }
    
    // Lookup next hop for destination
    std::optional<uint32_t> getNextHop(uint32_t destination) {
        auto it = routingTable_.find(destination);
        if (it != routingTable_.end()) {
            return it->second.nextHop;
        }
        return std::nullopt; // No route
    }
    
    // Get full routing table (for diagnostics/MQTT bridge)
    std::map<uint32_t, std::vector<uint32_t>> getRoutingTable() {
        std::map<uint32_t, std::vector<uint32_t>> result;
        
        for (const auto& [dest, entry] : routingTable_) {
            // Reconstruct full path by following next hops
            std::vector<uint32_t> path = reconstructPath(dest);
            result[dest] = path;
        }
        
        return result;
    }
    
private:
    std::vector<uint32_t> reconstructPath(uint32_t destination) {
        std::vector<uint32_t> path;
        uint32_t current = destination;
        
        // Walk backwards from destination
        while (current != nodeId) {
            path.push_back(current);
            
            // Find parent of current in topology
            auto parent = findParentNode(current);
            if (!parent) break;
            current = *parent;
        }
        
        std::reverse(path.begin(), path.end());
        return path;
    }
};

template <class T, class U>
bool sendToNode(T& package, uint32_t destNodeId, layout::Layout<U> tree) {
    // Check if direct connection
    auto directConn = router::findRoute(tree, destNodeId);
    if (directConn) {
        return router::send(package, directConn);
    }
    
    // Lookup next hop from routing table
    auto nextHop = mesh.getNextHop(destNodeId);
    if (!nextHop) {
        Log(ERROR, "No route to node %u\n", destNodeId);
        return false;
    }
    
    // Forward to next hop
    auto nextHopConn = router::findRoute(tree, *nextHop);
    if (nextHopConn) {
        return router::send(package, nextHopConn);
    }
    
    Log(ERROR, "Next hop %u not found for destination %u\n", 
        *nextHop, destNodeId);
    return false;
}

// Rebuild routing table on topology changes
void onChangedConnections() {
    rebuildRoutingTable();
    invalidateHopCountCache();
    // ... existing logic ...
}

// Periodic routing table refresh (optional)
Task routingTableRefresh(300000, TASK_FOREVER, []() {
    mesh.rebuildRoutingTable();
    Log(DEBUG, "Routing table refreshed\n");
});

// test/catch/catch_routing_table.cpp
SCENARIO("Routing table for complex topology") {
    GIVEN("Mesh topology: A -> B -> C, A -> D -> C") {
        // From A's perspective
        REQUIRE(meshA.getNextHop(meshB) == meshB); // Direct
        REQUIRE(meshA.getNextHop(meshC) == meshB); // Via B (shorter)
        REQUIRE(meshA.getNextHop(meshD) == meshD); // Direct
        
        auto routes = meshA.getRoutingTable();
        REQUIRE(routes[meshC] == std::vector<uint32_t>{meshB, meshC});
    }
    
    GIVEN("Node becomes unreachable") {
        // Disconnect B
        meshB.stop();
        meshA.rebuildRoutingTable();
        
        REQUIRE(meshA.getNextHop(meshC) == meshD); // Reroute via D
    }
}

enum Type {
  TIME_DELAY = 3,
  TIME_SYNC = 4,
  NODE_SYNC_REQUEST = 5,
  NODE_SYNC_REPLY = 6,
  CONTROL = 7,    // deprecated
  BROADCAST = 8,  // application data for everyone
  SINGLE = 9      // application data for a single node
};

// Add deprecation warning (C++14 compatible)
enum Type {
  TIME_DELAY = 3,
  TIME_SYNC = 4,
  NODE_SYNC_REQUEST = 5,
  NODE_SYNC_REPLY = 6,
  
  // DEPRECATED: Use SINGLE or BROADCAST instead
  // Will be removed in v2.0.0
  CONTROL __attribute__((deprecated("Use SINGLE or BROADCAST"))) = 7,
  
  BROADCAST = 8,
  SINGLE = 9
};

// Simply remove from enum
enum Type {
  TIME_DELAY = 3,
  TIME_SYNC = 4,
  NODE_SYNC_REQUEST = 5,
  NODE_SYNC_REPLY = 6,
  // CONTROL = 7 removed in v1.8.0
  BROADCAST = 8,
  SINGLE = 9
};

auto size = callback(pkg, buffer);
// Handle zero size
if (!size) {
  // No data is available by the user app.
  
  // todo - doubtful, shall we return true or false. What is the purpose
  // of this return value.
  return true;
}

auto size = callback(pkg, buffer);

// Zero size indicates no data available (valid end of stream or cache miss)
// Return true to acknowledge request was processed successfully
if (!size) {
    Log(DEBUG, "OTA: No data for chunk %d (end of stream)\n", pkg.partNo);
    return true; // Request handled, no retry needed
}

auto size = callback(pkg, buffer);

if (!size) {
    if (pkg.partNo >= pkg.noPart) {
        // End of file reached, this is expected
        Log(DEBUG, "OTA: Chunk %d exceeds file size, ignoring\n", pkg.partNo);
        return true; // Valid end of stream
    } else {
        // Data should exist but callback failed
        Log(ERROR, "OTA: Callback failed to provide chunk %d/%d\n", 
            pkg.partNo, pkg.noPart);
        return false; // Retry might help
    }
}

enum class PackageHandleResult {
    SUCCESS = 0,      // Handled successfully
    RETRY = 1,        // Temporary failure, retry
    IGNORE = 2,       // Invalid request, don't retry
    ERROR = 3         // Fatal error
};

// Update callback signature
mesh.onPackage(
    (int)OTA_OP_CODES::DATA_REQUEST,
    [](auto variant) -> PackageHandleResult {
        // ...
        if (!size) {
            return PackageHandleResult::IGNORE; // Clear intent
        }
        return PackageHandleResult::SUCCESS;
    }
);

if (mySubCount == remoteSubCount) {
    // TODO: there is a change here that a middle node also lower is than the
    // two others and will start switching between both. Maybe should do it
    // randomly instead?
    return mesh.nodeId < connection.nodeId;
}

// Add to Connection class
struct ConnectionState {
    uint32_t preferredParent = 0;
    uint32_t lastParentSwitch = 0;
};

// In adopt() function
if (mySubCount == remoteSubCount) {
    // If we already have a preferred parent and it's still valid, stick with it
    if (connection->state.preferredParent != 0 &&
        mesh.connectionExists(connection->state.preferredParent)) {
        return connection->state.preferredParent == connection.nodeId;
    }
    
    // If no preference or parent changed, use random choice with hysteresis
    uint32_t now = mesh.getNodeTime();
    if (now - connection->state.lastParentSwitch < 30000) {
        // Less than 30s since last switch, keep current parent
        return false; // Don't switch
    }
    
    // Random choice to break ties
    bool shouldAdopt = (mesh.nodeId ^ connection.nodeId) & 1;
    
    if (shouldAdopt) {
        connection->state.preferredParent = connection.nodeId;
        connection->state.lastParentSwitch = now;
    }
    
    return shouldAdopt;
}

if (mySubCount == remoteSubCount) {
    // Prefer connection with better signal quality
    int8_t mySignal = connection->getSignalStrength();
    int8_t otherSignal = getConnectionSignal(otherNodeId);
    
    if (abs(mySignal - otherSignal) > 10) { // 10 dBm hysteresis
        return mySignal > otherSignal;
    }
    
    // Fall back to deterministic if signals equivalent
    return mesh.nodeId < connection.nodeId;
}

// In mesh.update() - main entry point
void update() {
    try {
        // All mesh processing
        scheduler.execute();
        handleConnections();
        processMessages();
    } catch (const std::bad_alloc& e) {
        Log(ERROR, "Out of memory in mesh.update()\n");
        // Attempt graceful degradation
        purgeOldMessages();
        closeOldConnections();
    } catch (const std::exception& e) {
        Log(ERROR, "Exception in mesh.update(): %s\n", e.what());
    } catch (...) {
        Log(ERROR, "Unknown exception in mesh.update()\n");
        // Critical: restart mesh?
    }
}

// Add to platformio.ini or CMakeLists.txt
build_flags = -fno-exceptions -fno-rtti

// Use std::optional or error codes
std::optional<protocol::Variant> parseMessage(const TSTRING& msg) {
    auto variant = protocol::Variant(msg, calculateCapacity(msg));
    
    if (variant.error != DeserializationError::Ok) {
        return std::nullopt; // Explicit failure
    }
    
    return variant;
}

// Usage
auto result = parseMessage(msg);
if (!result) {
    Log(ERROR, "Failed to parse message\n");
    return;
}
auto variant = *result;

// Document ownership in comments
class Mesh {
    // Mesh owns connections (strong ownership)
    std::list<std::shared_ptr<Connection>> connections_;
    
    // Router holds weak references (non-owning)
    std::map<uint32_t, std::weak_ptr<Connection>> routeCache_;
    
    // Connection holds weak reference back to mesh (avoid cycle)
    std::weak_ptr<Mesh> mesh_;
};

// If connection is uniquely owned by mesh
std::list<std::unique_ptr<Connection>> connections_;

// Pass raw pointers for temporary access (no ownership transfer)
void handleMessage(Connection* conn, const TSTRING& msg);

// Periodic cleanup task
Task memoryCleanupTask(60000, TASK_FOREVER, []() {
    // Remove expired weak_ptr from caches
    mesh.cleanupExpiredReferences();
    
    // Log memory stats
    Log(DEBUG, "Free heap: %u bytes\n", ESP.getFreeHeap());
});