import org.gradle.api.artifacts.ModuleIdentifier;

import java.util.LinkedHashSet;
import java.util.Set;

public class PendingDependencies {
    private final ModuleIdentifier moduleIdentifier;
    private final Set<NodeState> constraintProvidingNodes;
    private int hardEdges;
    private boolean reportActivePending;

    PendingDependencies(ModuleIdentifier moduleIdentifier) {

        private final Set<ModuleIdentifier> participants;

        private HasConflict(Set<ModuleIdentifier> participants) {
            this.participants = participants;
        }

        @Override
        public void withParticipatingModules(Action<ModuleIdentifier> action) {
            for (ModuleIdentifier participant : participants) {
                action.execute(participant);

        this.modules = modules;
    }

    public static StrictVersionConstraints of(Set<ModuleIdentifier> modules) {
        if (modules.isEmpty()) {
            return EMPTY;
        }
        return new StrictVersionConstraints(modules);
    }

    public Set<ModuleIdentifier> getModules() {
        return modules;
    }

    public boolean isEmpty() {

        def same = new MavenUniqueSnapshotComponentIdentifier(moduleIdentifier, "1.0-SNAPSHOT", "timestamp")
        def differentVersion = new MavenUniqueSnapshotComponentIdentifier(moduleIdentifier, "1.1-SNAPSHOT", "timestamp")
        def differentTimestamp = new MavenUniqueSnapshotComponentIdentifier(moduleIdentifier, "1.0-SNAPSHOT", "other")

        then:

    }

    private static void detectCycles(Map<ModuleIdentifier, Replacement> replacements, ModuleIdentifier source, ModuleIdentifier target) {
        if (source.equals(target)) {
            throw new InvalidUserDataException(String.format("Cannot declare module replacement that replaces self: %s->%s", source, target));
        }

        ModuleIdentifier m = unwrap(replacements.get(target));
        if (m == null) {

    @Override
    public ModuleIdentifier module(String group, String name) {
        Map<String, ModuleIdentifier> byName = groupIdToModules.get(group);
        if (byName == null) {
            byName = groupIdToModules.computeIfAbsent(group, k -> new ConcurrentHashMap<>());
        }
        ModuleIdentifier moduleIdentifier = byName.get(name);
        if (moduleIdentifier == null) {

            boolean hasConflict = !name.equals(childDependency.getName());
            LinkedHashMap<String, Object> map = new LinkedHashMap<>(6);
            ModuleIdentifier moduleIdentifier = getModuleIdentifier(childDependency);
            map.put("module", moduleIdentifier == null ? null : moduleIdentifier.toString());
            map.put("name", name);
            map.put("resolvable", childDependency.getResolutionState());

    public String getGroup() {
        return moduleIdentifier.getGroup();
    }

    @Override
    public String getName() {
        return moduleIdentifier.getName();
    }

    @Override
    public VersionConstraint getVersionConstraint() {
        return this.versionConstraint;
    }

    @Override
    public ModuleIdentifier getModule() {
        return moduleIdentifier;
    }

    @Override

    }

    private static PluginRequestInternal createDevelocityPluginRequest() {
        ModuleIdentifier moduleIdentifier = DefaultModuleIdentifier.newId(AutoAppliedDevelocityPlugin.GROUP, AutoAppliedDevelocityPlugin.NAME);
        ModuleVersionSelector artifact = DefaultModuleVersionSelector.newSelector(moduleIdentifier, AutoAppliedDevelocityPlugin.VERSION);
        return new DefaultPluginRequest(

        return new DefaultModuleIdSetExclude(ImmutableSet.copyOf(ids));
    }

    private DefaultModuleIdSetExclude(ImmutableSet<ModuleIdentifier> moduleIds) {
        this.moduleIds = moduleIds;
        this.hashCode = moduleIds.hashCode();
    }

    @Override
    public Set<ModuleIdentifier> getModuleIds() {
        return moduleIds;
    }

    @Override