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

    }

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

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

    @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 = []

            return cleanProjectDir(specification)
        }
        false
    }

    static boolean cleanProjectDir(Object specification) {
        if (specification.hasProperty("toolingApi")) {
            specification.toolingApi.cleanUpIsolatedDaemonsAndServices()
        }
        if (specification.hasProperty("caughtGradleConnectionException")) {
            specification.caughtGradleConnectionException = null
        }

            invoker = GradleBuildInvoker.AndroidStudio;
        } else if (invocationSpec.isUseToolingApi()) {
            invoker = invocationSpec.isUseDaemon()
                ? GradleBuildInvoker.ToolingApi
                : GradleBuildInvoker.ToolingApi.withColdDaemon();
        } else {
            invoker = invocationSpec.isUseDaemon()
                ? GradleBuildInvoker.Cli
                : GradleBuildInvoker.CliNoDaemon;
        }

    }

    @Issue("gradle/gradle#1641")
    @TargetGradleVersion(">=3.5 <4.0")
    def "generates download events during maven publish"() {
        given:
        toolingApi.requireIsolatedUserHome()
        if (targetDist.version.version == "3.5-rc-1") {
            return
        }
        def module = mavenHttpRepo.module('group', 'publish', '1')

    private RepositoryHttpServer server

    def setup() {
        server = new RepositoryHttpServer(temporaryFolder, targetDist.version.version)
        server.before()
        toolingApi.requireIsolatedUserHome()
    }

    def cleanup() {
        server.after()
    }

    private String expectedDisplayName(String name, String extension, String version) {

        PerformanceTestJvmOptions.normalizeGradleJvmOptions(useDaemon, PerformanceTestJvmOptions.normalizeJvmOptions(this.gradleOpts))
    }

    def <T extends LongRunningOperation> ToolingApiAction<T> toolingApi(String displayName, Function<ProjectConnection, T> initialAction) {
        useToolingApi = true
        def tapiAction = new ToolingApiAction<T>(displayName, initialAction)
        this.buildAction = tapiAction

    }

    @TargetGradleVersion('>=7.3')
    def "generates success event for failing first attempt to get dependency"() {
        toolingApi.requireIsolatedUserHome()

        def projectFModuleMissing = mavenHttpRepo.module('group', 'projectF', '2.0')
        projectFModuleMissing.missing()

                }
            }
        """

        return pluginBuilder
    }

    private <T> T fetchSchemaModel(Class<T> modelType) {
        toolingApi.withConnection() { connection ->
            ModelBuilder<T> modelBuilder = connection.model(modelType)
            collectOutputs(modelBuilder)
            modelBuilder.get()
        }
    }