"istio.io/istio/pkg/config/resource"
	"istio.io/istio/pkg/config/schema/gvk"
)

// SelectorAnalyzer validates, per namespace, that:
// * sidecar resources that define a workload selector match at least one pod
// * there aren't multiple sidecar resources that select overlapping pods
type SelectorAnalyzer struct{}

var _ analysis.Analyzer = &SelectorAnalyzer{}

// Metadata implements Analyzer

	// Using an index for selectoes is problematic because selector != label
	// We can match a label to a selector, but we can't generate a selector from a label.
	c.ForEach(gvk.Telemetry, func(rs *resource.Instance) bool {
		s := rs.Message.(*v1alpha1.Telemetry)

		// For this analysis, ignore Telemetries with no selectors specified at all.
		if s.Selector == nil || len(s.GetSelector().MatchLabels) == 0 {
			return true
		}

	}
	if f.selects != nil {
		attrs = append(attrs, fmt.Sprintf("selects=%v", f.selects))
	}
	if f.labels != nil {
		attrs = append(attrs, fmt.Sprintf("labels=%v", f.labels))
	}
	if f.generic != nil {
		attrs = append(attrs, "generic")
	}
	res := strings.Join(attrs, ",")
	return fmt.Sprintf("{%s}", res)
}

// FilterObjectName selects a Kubernetes object by name.

// And finally, fixup the flag user.
(CMPconst <t> [0] (Select0 z:((ADD|AND|ANDN|OR|SUB|NOR|XOR)CC x y))) => (Select1 <t> z)
(CMPconst <t> [0] (Select0 z:((ADDCCconst|ANDCCconst|NEGCC|CNTLZDCC|RLDICLCC) y))) => (Select1 <t> z)

// After trying to convert ANDconst to ANDCCconst above, if the CC result is not needed, try to avoid using
// ANDconst which clobbers CC.

        this.artifactSetResolver = artifactSetResolver;
        this.artifactVariantSelector = artifactVariantSelector;
    }

    @Override
    public SelectedArtifactSet select(ArtifactSelectionSpec spec) {
        SelectedArtifactResults artifacts = artifactsResults.select(artifactVariantSelector, spec, false);
        return new DefaultSelectedArtifactSet(artifactSetResolver, graphResults, artifacts.getArtifacts(), resolutionHost);
    }

public interface VisitedArtifactResults {
    /**
     * Selects the artifacts for the matching variant of each node seen during traversal.
     * The implementation should attempt to select artifacts eagerly, but may be lazy where
     * the selection cannot happen until the results are queried.
     *
     * @param variantSelector Performs variant selection
     * @param spec Governs how artifacts are selected

    ) {
        // If a specific variant is requested by name, select it.
        if (dependencyConfiguration != null) {
            VariantGraphResolveState selected = variantSelector.selectVariantByConfigurationName(dependencyConfiguration, consumerAttributes, targetComponentState, consumerSchema);
            return new GraphVariantSelectionResult(Collections.singletonList(selected), false);
        }

        def spec = new ArtifactSelectionSpec(ImmutableAttributes.EMPTY, { false }, selectFromAll, false, ResolutionStrategy.SortOrder.DEFAULT)
        def selected = artifactSet.select(selector, spec)

        then:
        0 * selector.select(_, _, _, _)
        selected == ResolvedArtifactSet.EMPTY

        where:
        selectFromAll << [true, false]
    }

 */
public interface VisitedArtifactSet {
    /**
     * Creates a set that selects the artifacts from this set that match the given criteria.
     * Implementations are lazy, so that the selection happens only when the contents are queried.
     *
     * @param spec Parameters controlling the artifact selection process
     */
    SelectedArtifactSet select(ArtifactSelectionSpec spec);

          if (protocol in protocols) {
            selected = protocol
            return selected
          }
        }
        selected = protocols[0] // On no intersection, try peer's first protocol.
        return selected
      } else if ((methodName == "protocolSelected" || methodName == "selected") && callArgs.size == 1) {
        this.selected = callArgs[0] as String // Server selected this protocol.
        return null