import org.gradle.util.GradleVersion

// note that there is no mechanism to share code between the initscript{} block and the main script, so some logic is duplicated

// conditionally apply the GE / Build Scan plugin to the classpath so it can be applied to the build further down in this script
initscript {
    def isTopLevelBuild = !gradle.parent
    if (!isTopLevelBuild) {
        return
    }

    def getInputParam = { String name ->
        def envVarName = name.toUpperCase().replace('.', '_').replace('-', '_')
        return System.getProperty(name) ?: System.getenv(envVarName)
    }

    // finish early if injection is disabled
    def gradleInjectionEnabled = getInputParam("develocity.injection-enabled")
    if (gradleInjectionEnabled != "true") {
        return
    }

    def pluginRepositoryUrl = getInputParam('gradle.plugin-repository.url')
    def gePluginVersion = getInputParam('develocity.plugin.version')
    def ccudPluginVersion = getInputParam('develocity.ccud-plugin.version')

    def atLeastGradle5 = GradleVersion.current() >= GradleVersion.version('5.0')
    def atLeastGradle4 = GradleVersion.current() >= GradleVersion.version('4.0')

    if (gePluginVersion || ccudPluginVersion && atLeastGradle4) {
        pluginRepositoryUrl = pluginRepositoryUrl ?: 'https://plugins.gradle.org/m2'
        logger.quiet("Develocity plugins resolution: $pluginRepositoryUrl")

        repositories {
            maven { url pluginRepositoryUrl }
        }
    }

    dependencies {
        if (gePluginVersion) {
            classpath atLeastGradle5 ?
                "com.gradle:gradle-enterprise-gradle-plugin:$gePluginVersion" :
                "com.gradle:build-scan-plugin:1.16"
        }

        if (ccudPluginVersion && atLeastGradle4) {
            classpath "com.gradle:common-custom-user-data-gradle-plugin:$ccudPluginVersion"
        }
    }
}

def BUILD_SCAN_PLUGIN_ID = 'com.gradle.build-scan'
def BUILD_SCAN_PLUGIN_CLASS = 'com.gradle.scan.plugin.BuildScanPlugin'

def DEVELOCITY_PLUGIN_ID = 'com.gradle.enterprise'
def DEVELOCITY_PLUGIN_CLASS = 'com.gradle.enterprise.gradleplugin.GradleEnterprisePlugin'
def DEVELOCITY_EXTENSION_CLASS = 'com.gradle.enterprise.gradleplugin.GradleEnterpriseExtension'
def CI_AUTO_INJECTION_CUSTOM_VALUE_NAME = 'CI auto injection'
def CI_AUTO_INJECTION_CUSTOM_VALUE_VALUE = 'gradle-build-action'
def CCUD_PLUGIN_ID = 'com.gradle.common-custom-user-data-gradle-plugin'
def CCUD_PLUGIN_CLASS = 'com.gradle.CommonCustomUserDataGradlePlugin'

def isTopLevelBuild = !gradle.parent
if (!isTopLevelBuild) {
    return
}

def getInputParam = { String name ->
    def envVarName = name.toUpperCase().replace('.', '_').replace('-', '_')
    return System.getProperty(name) ?: System.getenv(envVarName)
}

// finish early if injection is disabled
def gradleInjectionEnabled = getInputParam("develocity.injection-enabled")
if (gradleInjectionEnabled != "true") {
    return
}

def geUrl = getInputParam('develocity.url')
def geAllowUntrustedServer = Boolean.parseBoolean(getInputParam('develocity.allow-untrusted-server'))
def geEnforceUrl = Boolean.parseBoolean(getInputParam('develocity.enforce-url'))
def buildScanUploadInBackground = Boolean.parseBoolean(getInputParam('develocity.build-scan.upload-in-background'))
def gePluginVersion = getInputParam('develocity.plugin.version')
def ccudPluginVersion = getInputParam('develocity.ccud-plugin.version')
def buildScanTermsOfServiceUrl = getInputParam('build-scan.terms-of-service.url')
def buildScanTermsOfServiceAgree = getInputParam('build-scan.terms-of-service.agree')

def atLeastGradle4 = GradleVersion.current() >= GradleVersion.version('4.0')

// finish early if configuration parameters passed in via system properties are not valid/supported
if (ccudPluginVersion && isNotAtLeast(ccudPluginVersion, '1.7')) {
    logger.warn("Common Custom User Data Gradle plugin must be at least 1.7. Configured version is $ccudPluginVersion.")
    return
}

// register buildScanPublished listener and optionally apply the GE / Build Scan plugin
if (GradleVersion.current() < GradleVersion.version('6.0')) {
    rootProject {
        buildscript.configurations.getByName("classpath").incoming.afterResolve { ResolvableDependencies incoming ->
            def resolutionResult = incoming.resolutionResult

            if (gePluginVersion) {
                def scanPluginComponent = resolutionResult.allComponents.find {
                    it.moduleVersion.with { group == "com.gradle" && (name == "build-scan-plugin" || name == "gradle-enterprise-gradle-plugin") }
                }
                if (!scanPluginComponent) {
                    logger.quiet("Applying $BUILD_SCAN_PLUGIN_CLASS via init script")
                    applyPluginExternally(pluginManager, BUILD_SCAN_PLUGIN_CLASS)
                    if (geUrl) {
                        logger.quiet("Connection to Develocity: $geUrl, allowUntrustedServer: $geAllowUntrustedServer")
                        buildScan.server = geUrl
                        buildScan.allowUntrustedServer = geAllowUntrustedServer
                    }
                    buildScan.publishAlways()
                    if (buildScan.metaClass.respondsTo(buildScan, 'setUploadInBackground', Boolean)) buildScan.uploadInBackground = buildScanUploadInBackground  // uploadInBackground not available for build-scan-plugin 1.16
                    buildScan.value CI_AUTO_INJECTION_CUSTOM_VALUE_NAME, CI_AUTO_INJECTION_CUSTOM_VALUE_VALUE
                }

                if (geUrl && geEnforceUrl) {
                    pluginManager.withPlugin(BUILD_SCAN_PLUGIN_ID) {
                        afterEvaluate {
                            logger.quiet("Enforcing Develocity: $geUrl, allowUntrustedServer: $geAllowUntrustedServer")
                            buildScan.server = geUrl
                            buildScan.allowUntrustedServer = geAllowUntrustedServer
                        }
                    }
                }

                if (buildScanTermsOfServiceUrl && buildScanTermsOfServiceAgree) {
                    buildScan.termsOfServiceUrl = buildScanTermsOfServiceUrl
                    buildScan.termsOfServiceAgree = buildScanTermsOfServiceAgree
                }
            }

            if (ccudPluginVersion && atLeastGradle4) {
                def ccudPluginComponent = resolutionResult.allComponents.find {
                    it.moduleVersion.with { group == "com.gradle" && name == "common-custom-user-data-gradle-plugin" }
                }
                if (!ccudPluginComponent) {
                    logger.quiet("Applying $CCUD_PLUGIN_CLASS via init script")
                    pluginManager.apply(initscript.classLoader.loadClass(CCUD_PLUGIN_CLASS))
                }
            }
        }
    }
} else {
    gradle.settingsEvaluated { settings ->
        if (gePluginVersion) {
            if (!settings.pluginManager.hasPlugin(DEVELOCITY_PLUGIN_ID)) {
                logger.quiet("Applying $DEVELOCITY_PLUGIN_CLASS via init script")
                applyPluginExternally(settings.pluginManager, DEVELOCITY_PLUGIN_CLASS)
                eachDevelocityExtension(settings, DEVELOCITY_EXTENSION_CLASS) { ext ->
                    if (geUrl) {
                        logger.quiet("Connection to Develocity: $geUrl, allowUntrustedServer: $geAllowUntrustedServer")
                        ext.server = geUrl
                        ext.allowUntrustedServer = geAllowUntrustedServer
                    }
                    ext.buildScan.publishAlways()
                    ext.buildScan.uploadInBackground = buildScanUploadInBackground
                    ext.buildScan.value CI_AUTO_INJECTION_CUSTOM_VALUE_NAME, CI_AUTO_INJECTION_CUSTOM_VALUE_VALUE
                }
            }

            if (geUrl && geEnforceUrl) {
                eachDevelocityExtension(settings, DEVELOCITY_EXTENSION_CLASS) { ext ->
                    logger.quiet("Enforcing Develocity: $geUrl, allowUntrustedServer: $geAllowUntrustedServer")
                    ext.server = geUrl
                    ext.allowUntrustedServer = geAllowUntrustedServer
                }
            }

            if (buildScanTermsOfServiceUrl && buildScanTermsOfServiceAgree) {
                eachDevelocityExtension(settings, DEVELOCITY_EXTENSION_CLASS) { ext ->
                    ext.buildScan.termsOfServiceUrl = buildScanTermsOfServiceUrl
                    ext.buildScan.termsOfServiceAgree = buildScanTermsOfServiceAgree
                }
            }
        }

        if (ccudPluginVersion) {
            if (!settings.pluginManager.hasPlugin(CCUD_PLUGIN_ID)) {
                logger.quiet("Applying $CCUD_PLUGIN_CLASS via init script")
                settings.pluginManager.apply(initscript.classLoader.loadClass(CCUD_PLUGIN_CLASS))
            }
        }
    }
}

void applyPluginExternally(def pluginManager, String pluginClassName) {
    def externallyApplied = 'develocity.externally-applied'
    def oldValue = System.getProperty(externallyApplied)
    System.setProperty(externallyApplied, 'true')
    try {
        pluginManager.apply(initscript.classLoader.loadClass(pluginClassName))
    } finally {
        if (oldValue == null) {
            System.clearProperty(externallyApplied)
        } else {
            System.setProperty(externallyApplied, oldValue)
        }
    }
}

static def eachDevelocityExtension(def settings, def publicType, def action) {
    settings.extensions.extensionsSchema.elements.findAll { it.publicType.concreteClass.name == publicType }
        .collect { settings[it.name] }.each(action)
}

static boolean isNotAtLeast(String versionUnderTest, String referenceVersion) {
    GradleVersion.version(versionUnderTest) < GradleVersion.version(referenceVersion)
}