package org.gradle.internal.rules;

import java.util.List;

/**
 * An action representing a rule, taking declared inputs and performing an action on a subject.
 *
 * @param <T> The subject type
 */
public interface RuleAction<T> {
    List<Class<?>> getInputTypes();
    void execute(T subject, List<?> inputs);

    def ruleAction = Stub(RuleAction)
    def mavenMetadataFactory = DependencyManagementTestUtil.mavenMetadataFactory()
    def ivyMetadataFactory = DependencyManagementTestUtil.ivyMetadataFactory()
    MetadataResolutionContext context = Mock()

        def ruleAction = Stub(RuleAction) {
            getInputTypes() >> { [String] }
        }

        expect:
        ruleValidator.validate(ruleAction) == ruleAction
    }

    def "accepts valid type with multiple valid types"() {
        def ruleValidator = new DefaultRuleActionValidator(String, Long)
        def ruleAction = Stub(RuleAction) {
            getInputTypes() >> { [parameterType] }

    }

    @Override
    public Rule addRule(String description, Closure ruleAction) {
        return getDelegate().addRule(description, ruleAction);
    }

    @Override
    public Rule addRule(String description, Action<String> ruleAction) {
        return getDelegate().addRule(description, ruleAction);
    }

    @Override
    public Rule addRule(Rule rule) {

    }

    @Override
    public <T> RuleAction<? super T> validate(RuleAction<? super T> ruleAction) {
        validateInputTypes(ruleAction);
        return ruleAction;
    }

    private void validateInputTypes(RuleAction<?> ruleAction) {
        for (Class<?> inputType : ruleAction.getInputTypes()) {
            if (!validInputType.contains(inputType)) {

        def noInputsAction = ruleAction(baseAction)

        expect:
        Matchers.strictlyEquals(noInputsAction, ruleAction(baseAction))
        noInputsAction != ruleAction({String val -> } as Action<String>)
    }

    RuleAction<String> ruleAction(Action<String> action) {
        new NoInputsRuleAction<String>(action)
    }

    def ruleAction = Mock(RuleAction)
    def ruleSource = new Object()

    def "add closure rule that applies to all components"() {
        def input = { ComponentSelection cs ->  }

        when:
        rules.all input

        then:
        1 * adapter.createFromClosure(ComponentSelection, input) >> ruleAction

        and:
        rules.rules.size() == 1

        metadataRuleContainer.addRule(ruleAction);
        return this;
    }

    private ComponentMetadataHandler addClassBasedRule(SpecConfigurableRule ruleAction) {
        metadataRuleContainer.addClassRule(ruleAction);
        return this;
    }

    private <U> SpecRuleAction<? super U> createAllSpecRuleAction(RuleAction<? super U> ruleAction) {

import groovy.lang.Closure;
import org.gradle.api.Action;

public interface RuleActionAdapter {
    <T> RuleAction<? super T> createFromClosure(Class<T> subjectType, Closure<?> closure);

    <T> RuleAction<? super T> createFromAction(Action<? super T> action);

    <T> RuleAction<? super T> createFromRuleSource(Class<T> subjectType, Object ruleSource);

        Spec<ComponentSelection> spec = new ComponentSelectionMatchingSpec(moduleIdentifier);
        return new SpecRuleAction<>(ruleAction, spec);
    }

    private SpecRuleAction<? super ComponentSelection> createAllSpecRulesAction(RuleAction<? super ComponentSelection> ruleAction) {
        return new SpecRuleAction<>(ruleAction, Specs.satisfyAll());
    }

    static class ComponentSelectionMatchingSpec implements Spec<ComponentSelection> {