import io.grpc.ClientStreamTracer;

import io.grpc.ClientStreamTracer.StreamInfo;

import io.grpc.ConnectivityState;

import io.grpc.EquivalentAddressGroup;

import io.grpc.LoadBalancer;

import io.grpc.LoadBalancerProvider;

import io.grpc.Metadata;

@VisibleForTesting

static final class ReadyPicker extends SubchannelPicker {

private final List<ChildLbState> childLbStates; // non-empty

private final List<SubchannelPicker> childPickers; // non-empty

private final List<AtomicInteger> childInFlights; // 1:1 with childPickers

private final List<EquivalentAddressGroup> childEags; // 1:1 with childPickers

private final int choiceCount;

private final ThreadSafeRandom random;

private final int hashCode;

ReadyPicker(List<ChildLbState> childLbStates, int choiceCount, ThreadSafeRandom random) {

checkArgument(!childLbStates.isEmpty(), "empty list");

this.childLbStates = childLbStates;

this.childPickers = new ArrayList<>(childLbStates.size());

this.childInFlights = new ArrayList<>(childLbStates.size());

this.childEags = new ArrayList<>(childLbStates.size());

for (ChildLbState state : childLbStates) {

childPickers.add(state.getCurrentPicker());

childInFlights.add(getInFlights(state));

childEags.add(state.getEag());

}

this.choiceCount = choiceCount;

this.random = checkNotNull(random, "random");

int sum = 0;

for (ChildLbState child : childLbStates) {

for (SubchannelPicker child : childPickers) {

sum += child.hashCode();

}

this.hashCode = sum ^ choiceCount;

}

@Override

public PickResult pickSubchannel(PickSubchannelArgs args) {

final ChildLbState childLbState = nextChildToUse();

PickResult childResult = childLbState.getCurrentPicker().pickSubchannel(args);

int child = nextChildToUse();

PickResult childResult = childPickers.get(child).pickSubchannel(args);

if (!childResult.getStatus().isOk() || childResult.getSubchannel() == null) {

return childResult;

} else {

// Wrap the subchannel

OutstandingRequestsTracingFactory factory =

new OutstandingRequestsTracingFactory(getInFlights(childLbState));

new OutstandingRequestsTracingFactory(childInFlights.get(child));

return PickResult.withSubchannel(childResult.getSubchannel(), factory);

}

}

@Override

public String toString() {

return MoreObjects.toStringHelper(ReadyPicker.class)

.add("list", childLbStates)

.add("list", childPickers)

.add("choiceCount", choiceCount)

.toString();

}

private ChildLbState nextChildToUse() {

ChildLbState candidate = childLbStates.get(random.nextInt(childLbStates.size()));

private int nextChildToUse() {

int candidate = random.nextInt(childPickers.size());

for (int i = 0; i < choiceCount - 1; ++i) {

ChildLbState sampled = childLbStates.get(random.nextInt(childLbStates.size()));

if (getInFlights(sampled).get() < getInFlights(candidate).get()) {

int sampled = random.nextInt(childPickers.size());

if (childInFlights.get(sampled).get() < childInFlights.get(candidate).get()) {

candidate = sampled;

}

}

return candidate;

}

@VisibleForTesting

List<ChildLbState> getChildLbStates() {

return childLbStates;

List<SubchannelPicker> getChildPickers() {

return childPickers;

}

@VisibleForTesting

List<EquivalentAddressGroup> getChildEags() {

return childEags;

}

@Override

// the lists cannot contain duplicate children

return hashCode == other.hashCode

&& choiceCount == other.choiceCount

&& childLbStates.size() == other.childLbStates.size()

&& new HashSet<>(childLbStates).containsAll(other.childLbStates);

&& childPickers.size() == other.childPickers.size()

&& new HashSet<>(childPickers).containsAll(other.childPickers);

}

}