* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.multichannel;

/**
 * Load balancing strategies for multi-channel connections
 */
public enum LoadBalancingStrategy {
    /**
     * Round-robin selection through available channels
     */
    ROUND_ROBIN,

    /**
     * Select the least busy channel based on pending operations
     */
    LEAST_LOADED,

    void testStrategyChange() {
        assertEquals(LoadBalancingStrategy.ADAPTIVE, loadBalancer.getStrategy());

        loadBalancer.setStrategy(LoadBalancingStrategy.ROUND_ROBIN);
        assertEquals(LoadBalancingStrategy.ROUND_ROBIN, loadBalancer.getStrategy());
    }

    @Test
    void testZeroScoreChannels() {
        loadBalancer.setStrategy(LoadBalancingStrategy.WEIGHTED_RANDOM);

        // Test setting different strategies
        LoadBalancingStrategy[] strategies = { LoadBalancingStrategy.ROUND_ROBIN, LoadBalancingStrategy.LEAST_LOADED,
                LoadBalancingStrategy.WEIGHTED_RANDOM, LoadBalancingStrategy.AFFINITY_BASED, LoadBalancingStrategy.ADAPTIVE };

        for (LoadBalancingStrategy strategy : strategies) {
            loadBalancer.setStrategy(strategy);

    // Multi-channel configuration
    private final Configuration config;
    private final int maxChannels;
    private final LoadBalancingStrategy loadBalancingStrategy;
    private final long healthCheckInterval;

    // Channel management
    private final ConcurrentMap<String, ChannelGroup> sessionChannels = new ConcurrentHashMap<>();

    private final ChannelManager manager;
    private LoadBalancingStrategy strategy;
    private final AtomicInteger roundRobinCounter;

    /**
     * Create channel load balancer
     *
     * @param manager channel manager
     */
    public ChannelLoadBalancer(ChannelManager manager) {
        this.manager = manager;
        this.strategy = LoadBalancingStrategy.ADAPTIVE;
        this.roundRobinCounter = new AtomicInteger(0);

            props.setProperty("jcifs.smb.client.loadBalancingStrategy", strategy);
            PropertyConfiguration config = new PropertyConfiguration(props);
            assertEquals(strategy, config.getLoadBalancingStrategy());
        }

        // Test case insensitivity
        props.setProperty("jcifs.smb.client.loadBalancingStrategy", "ADAPTIVE");

import java.util.*;
import java.util.concurrent.ThreadLocalRandom;

public class ChannelLoadBalancer {
    private final ChannelManager manager;
    private LoadBalancingStrategy strategy;
    
    public enum LoadBalancingStrategy {
        ROUND_ROBIN,      // Rotate through channels
        LEAST_LOADED,     // Select least busy channel
        WEIGHTED_RANDOM,  // Random selection weighted by score

        if (value != null) {
            this.channelBindingPolicy = initChannelBindingPolicy(value);
        }

        value = props.getProperty("jcifs.smb.client.loadBalancingStrategy");
        if (value != null && !value.trim().isEmpty()) {
            this.loadBalancingStrategy = value.trim();
        }

        value = props.getProperty("jcifs.smb.client.channelHealthCheckInterval");
        if (value != null) {
            try {

        }
        if (this.channelHealthCheckInterval == 0) {
            this.channelHealthCheckInterval = 10;
        }
        if (this.loadBalancingStrategy == null) {
            this.loadBalancingStrategy = "adaptive";
        }

        // Initialize RDMA defaults
        if (this.rdmaProvider == null) {
            this.rdmaProvider = "auto";
        }

     *
     * @return channel binding policy
     */
    int getChannelBindingPolicy();

    /**
     * Load balancing strategy for multi-channel
     *
     * Property {@code jcifs.smb.client.loadBalancingStrategy} (String, default "adaptive")
     * Values: "round_robin", "least_loaded", "weighted_random", "affinity_based", "adaptive"
     *
     * @return load balancing strategy
     */