transport.disconnect(true, true);
            } catch (Exception e) {
                log.debug("Error disconnecting unhealthy transport: {}", e.getMessage());
            }
        }

        if (!unhealthy.isEmpty()) {
            log.info("Removed {} unhealthy connections from pool", unhealthy.size());
        }

        // Perform maintenance tasks
        performMaintenanceTasks();
    }

    /**

        public void decrementConnections() {
            activeConnections.decrementAndGet();
        }

        public boolean isHealthy() {
            return isHealthy;
        }

        public void setHealthy(boolean healthy) {
            this.isHealthy = healthy;
            this.lastHealthCheck = System.currentTimeMillis();
        }

        public long getLastHealthCheck() {

        when(mockRequest.getTreeId()).thenReturn(123);

        // Should throw NoAvailableChannelException when no healthy channels
        assertThrows(ChannelLoadBalancer.NoAvailableChannelException.class, () -> loadBalancer.selectChannel(mockRequest),
                "Should throw exception when no healthy channels available");
    }

     */
    public long getIdleTime() {
        return System.currentTimeMillis() - lastActivityTime;
    }

    /**
     * Check if channel is in healthy state
     *
     * @return true if healthy
     */
    public boolean isHealthy() {
        return state == ChannelState.ACTIVE || state == ChannelState.ESTABLISHED;
    }

    /**
     * Get channel binding hash
     *

        assertFalse(channelInfo.isHealthy());

        channelInfo.setState(ChannelState.ESTABLISHED);
        assertEquals(ChannelState.ESTABLISHED, channelInfo.getState());
        assertTrue(channelInfo.isHealthy());

        channelInfo.setState(ChannelState.ACTIVE);
        assertTrue(channelInfo.isHealthy());

        channelInfo.setState(ChannelState.FAILED);

        return channels.values();
    }

    /**
     * Get healthy channels only
     *
     * @return collection of healthy channels
     */
    public Collection<ChannelInfo> getHealthyChannels() {
        return channels.values()
                .stream()
                .filter(ChannelInfo::isHealthy)

     * @throws NoAvailableChannelException if no healthy channels available
     */
    public ChannelInfo selectChannel(CommonServerMessageBlock message) throws NoAvailableChannelException {
        Collection<ChannelInfo> availableChannels = manager.getHealthyChannels();

        if (availableChannels.isEmpty()) {
            throw new NoAvailableChannelException("No healthy channels available");
        }

        this.lastActivityTime = System.currentTimeMillis();
    }
    
    public long getIdleTime() {
        return System.currentTimeMillis() - lastActivityTime;
    }
    
    public boolean isHealthy() {
        return state == ChannelState.ACTIVE || state == ChannelState.ESTABLISHED;
    }
    
    public double getErrorRate() {
        long total = requestsSent.get();
        if (total == 0) return 0.0;

    }

    @Test
    void testGetHealthyChannels() throws UnknownHostException {
        assertTrue(channelManager.getHealthyChannels().isEmpty());

        // Add a healthy channel manually for testing
        InetAddress addr = InetAddress.getByName("192.168.1.100");
        NetworkInterfaceInfo localInterface = new NetworkInterfaceInfo(addr, 1000);

        List<CommonServerMessageBlock> operationsCopy = List.copyOf(pendingOps);

        // Clear the failed channel's pending operations first
        failedChannel.clearPendingOperations();

        // Redistribute to healthy channels
        for (CommonServerMessageBlock op : operationsCopy) {
            try {
                ChannelInfo alternativeChannel = manager.getLoadBalancer().selectChannel(op);