import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;
import org.gradle.model.internal.type.ModelType;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Set;

public interface ModelNode {

    boolean hasLink(String name);

    boolean hasLink(String name, ModelType<?> type);

    // Note: order is crucial here. Nodes are traversed through these states in the order defined below
    enum State {

        def rule1 = rule("path", ModelNode.State.Finalized)
        def rule2 = rule(Long, ModelNode.State.Finalized)
        def rule3 = rule("path", ModelNode.State.Finalized)
        def rule4 = rule(Long, ModelNode.State.Finalized)
        def rule5 = rule(Long, ModelNode.State.Finalized)
        def rule6 = rule("path", ModelNode.State.Finalized)

        given:
        bindings.add(rule1)

                    }
                }
            ))
            .build();
    }

    protected void initializePrivateData(MutableModelNode modelNode) {
    }

    private <V> void addProjection(MutableModelNode modelNode, StructSchema<V> viewSchema, ManagedProxyFactory proxyFactory, TypeConverter typeConverter) {

                                public void execute(MutableModelNode modelNode) {
                                    NamedEntityInstantiator<T> instantiator = instantiatorTransform.transform(modelNode.getParent());
                                    S item = instantiator.create(modelNode.getPath().getName(), type.getConcreteClass());
                                    modelNode.setPrivateData(type, item);
                                }

            return;
        }

        Map<String, ModelNode> links = new TreeMap<>();
        for (ModelNode node : model.getLinks(ModelType.untyped())) {
            links.put(node.getPath().getName(), node);
        }
        output.collection(links.values(), this);
    }

    public void printNodeName(ModelNode model, StyledTextOutput styledTextoutput) {
        Optional<String> value = getNodeValue(model);

        this.type = type;
        this.modelNode = modelNode;
        this.instantiator = instantiator;
    }

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {
        // Task dependencies may be calculated more than once.
        // This guard is purely an optimisation.
        if (modelNode != null && realized.compareAndSet(false, true)) {

        modelNode.executedRules[0] == descriptor

        where:
        fireCount << [1, 2]
    }

    def "should not fire for unbound binders"() {
        setup:
        ModelNodeInternal modelNode = new TestNode(registration)
        def executionBinder = Mock(RuleBinder)
        executionBinder.isBound() >> false

        when:
        modelNode.notifyFired(executionBinder)

        then:

        reference.untyped
        reference.state == ModelNode.State.GraphClosed
    }

    def "path only"() {
        expect:
        def reference = ModelReference.of("some.path")
        reference.scope == null
        reference.path == ModelPath.path("some.path")
        reference.type == ModelType.of(Object)
        reference.untyped
        reference.state == ModelNode.State.GraphClosed
    }

    def "type only"() {

        this.typeConverter = typeConverter;
    }

    @Override
    protected ModelView<M> toView(final MutableModelNode modelNode, final ModelRuleDescriptor ruleDescriptor, final boolean writable) {
        final DefaultModelViewState state = new DefaultModelViewState(modelNode.getPath(), getType(), ruleDescriptor, writable, true);
        return new ModelView<M>() {

            ModelType<ModelSet<T>> setType = ModelTypes.modelSet(elementType);
            DefaultModelViewState state = new DefaultModelViewState(modelNode.getPath(), setType, ruleDescriptor, mutable, !mutable);
            ChildNodeInitializerStrategy<T> childStrategy = Cast.uncheckedCast(modelNode.getPrivateData(ChildNodeInitializerStrategy.class));