package org.gradle.execution;

import org.gradle.api.Task;

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

public class TaskSelection {
    private final String projectPath;
    private final String taskName;
    private final TaskSelectionResult taskSelectionResult;

    public TaskSelection(String projectPath, String taskName, TaskSelectionResult tasks) {
        this.projectPath = projectPath;
        this.taskName = taskName;

            List<TaskSelection> taskSelections = commandLineTaskParser.parseTasks(taskParameter);
            for (TaskSelection taskSelection : taskSelections) {
                LOGGER.info("Selected primary task '{}' from project {}", taskSelection.getTaskName(), taskSelection.getProjectPath());
                plan.addEntryTasks(taskSelection.getTasks());
            }
        }
    }

        selector.resolveTaskName(null, null, defaultBuild, 'foo') >> new TaskSelection(':project', 'foo task', asTaskSelectionResults(task, task2))
        selector.resolveTaskName(null, null, defaultBuild, 'bar') >> new TaskSelection(':project', 'bar task', asTaskSelectionResults(task3))
        selector.resolveTaskName(null, null, defaultBuild, 'lastTask') >> new TaskSelection(':project', 'last task', asTaskSelectionResults(task3))

        when:

    }

    public List<TaskSelection> parseTasks(TaskExecutionRequest taskExecutionRequest) {
        List<TaskSelection> out = new ArrayList<>();
        List<String> remainingPaths = new LinkedList<String>(taskExecutionRequest.getArgs());
        while (!remainingPaths.isEmpty()) {
            String path = remainingPaths.remove(0);

        TaskExecutionRequest request2 = Stub(TaskExecutionRequest)
        def task1 = Stub(Task)
        def task2 = Stub(Task)
        def task3 = Stub(Task)
        def selection1 = Stub(TaskSelection)
        def selection2 = Stub(TaskSelection)

        given:
        _ * gradle.startParameter >> startParameters
        _ * startParameters.taskRequests >> [request1, request2]

        def tasks1 = [task1, task2] as Set

        }

        Set<Task> selectedTasks = getSelection(context, project, taskName, includeSubprojects).getTasks();
        return element -> !selectedTasks.contains(element);
    }

    @Override
    public TaskSelection getSelection(SelectionContext context, ProjectState targetProject, String taskName, boolean includeSubprojects) {
        if (!includeSubprojects) {
            configurer.configure(targetProject.getMutableModel());

import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;
import org.gradle.configuration.project.BuiltInCommand;
import org.gradle.execution.ProjectSelectionException;
import org.gradle.execution.TaskSelection;
import org.gradle.execution.TaskSelectionException;
import org.gradle.execution.TaskSelector;
import org.gradle.internal.build.BuildState;
import org.gradle.internal.build.BuildStateRegistry;

     */
    TaskSelection resolveTaskName(@Nullable File rootDir, @Nullable String projectPath, BuildState targetBuild, String taskName);

    BuildSpecificSelector relativeToBuild(BuildState target);

    /**
     * A selector that is contextualized to select tasks relative to some build.
     */
    interface BuildSpecificSelector {
        TaskSelection resolveTaskName(String taskName);
    }

        TaskSelection taskSelection;
        try {
            taskSelection = context.getSelection(testTaskPath);
        } catch (TaskSelectionException e) {
            throw new TestExecutionException(String.format("Requested test task with path '%s' cannot be found.", testTaskPath));
        }

        Set<Task> tasks = taskSelection.getTasks();
        if (tasks.isEmpty()) {

            spec.id("ambiguous-matches", "Ambiguous matches", GradleCoreProblemGroup.taskSelection());
        } else if (!getCandidates().isEmpty()) {
            spec.id("no-matches", "No matches", GradleCoreProblemGroup.taskSelection());
        } else {
            spec.id("selection-failed", "Selection failed", GradleCoreProblemGroup.taskSelection());
        }
    }