import org.junit.runners.model.Statement
import org.slf4j.Logger
import org.slf4j.LoggerFactory

import java.util.concurrent.TimeUnit

class ToolingApi implements TestRule {
    private static final Logger LOGGER = LoggerFactory.getLogger(ToolingApi)

    private GradleDistribution dist
    private TestDirectoryProvider testWorkDirProvider
    private TestFile gradleUserHomeDir
    private TestFile daemonBaseDir

    }

    private int countExecutedCommands() {
        toolingApi.daemons.daemon.log.count("command = ")
    }

    private void createIdleDaemon() {
        withConnection { connection ->
            connection.model(GradleBuild).get()
        }
        toolingApi.daemons.daemon.assertIdle()
    }

    def cleanup() {
        toolingApi.close()
    }

    boolean pathsInvalidated() {

    }

    void assertNoRunningDaemons() {
        waitFor.eventually {
            toolingApi.daemons.daemons*.assertStopped()
        }
    }

    void assertNumberOfRunningDaemons(number) {
        waitFor.eventually {
            assert toolingApi.daemons.daemons.size() == number
            toolingApi.daemons.daemons*.assertBusy()
        }

        def toolingApi = new ToolingApi(distribution, testDirectoryProvider)
        toolingApi.withConnector {
            it.forProjectDirectory(workingDir)
        }

        def systemPropertiesBeforeInvocation = new HashMap<String, Object>(System.getProperties())

        try {
            toolingApi.withConnection {
                action.execute(it)
            }

            this.gradle = packagedDistribution
            this.toolingApi = loadedDistribution
        } else {
            // TAPI {target} -> Gradle current
            this.gradle = loadedDistribution
            this.toolingApi = packagedDistribution
        }
        this.toolingApiVersion = GradleVersion.version(toolingApi.version.version)
        this.gradleVersion = GradleVersion.version(gradle.version.version)

//    We don't want to validate *all* command line options here, just enough to make sure passing through works.

    def "understands project properties for building model"() {
        given:
        toolingApi.verboseLogging = false //sanity check, see GRADLE-2226
        file("build.gradle") << """
        description = project.getProperty('theDescription')
"""

        when:

    @Delegate
    final ToolingApi toolingApi = new ToolingApi(null, temporaryFolder, stdout, stderr)

    // TODO: react to the isolatedProejcts prop coming from build settings

    @Rule
    public RuleChain cleanupRule = RuleChain.outerRule(temporaryFolder).around(temporaryDistributionFolder).around(toolingApi)

    private List<String> expectedDeprecations = []

    @TargetGradleVersion(">=3.0 <6.3")
    def "invalid Gradle distribution does not kill the TAPI client with older Gradle versions"() {
        given:
        toolingApi.requireDaemons()
        toolingApi.requireIsolatedUserHome()
        withConnection { connection ->
            connection.newBuild().forTasks("wrapper").run()
        }

        hasSystemProperty('mySystemProperty', 'defined in the client JVM')
    }

    def "Client JVM system properties do not appear in the build if withSystemProperties() is called"() {
        setup:
        toolingApi.requireDaemons() // no separate daemon JVM -> all client JVM system properties are expected to be visible

        when:
        runTask { withSystemProperties('unrelated' : 'value') }

        then:

    @TargetGradleVersion(">=3.5")
    @Requires(UnitTestPreconditions.Jdk8OrEarlier)
    def "old versions can mutate environment on JDK < 9"() {
        given:
        toolingApi.requireDaemons() //cannot be run in embedded mode

        buildFile << """
            task printEnv() {
                doLast {
                    println "<" + System.getenv() + ">"
                }