// Top-level build file where you can add configuration options common to all sub-projects/modules.

import io.gitlab.arturbosch.detekt.Detekt
import io.gitlab.arturbosch.detekt.DetektCreateBaselineTask

import static org.gradle.api.tasks.testing.TestResult.ResultType

buildscript {
    repositories {
        gradle.configureMavenRepositories(delegate)
    }

    dependencies {
        classpath libs.android.gradle.plugin
    }
}

plugins {
    alias(libs.plugins.dependency.analysis)
    alias(libs.plugins.detekt)
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.kotlin.compose) apply false
    alias(libs.plugins.ksp)
}

allprojects {
    ext {
        gleanVersion = libs.versions.glean.get()
    }

    if (gradle.mozconfig.substs.DOWNLOAD_ALL_GRADLE_DEPENDENCIES) {
        // Work around https://github.com/google/ksp/issues/1964 by explicitly
        // declaring dependencies that are dynamically added during Gradle task
        // execution.
        pluginManager.withPlugin('com.google.devtools.ksp') {
            project.configurations {
                kspDependencies
            }

            project.dependencies {
                kspDependencies libs.ksp.symbol.processing.aa
                kspDependencies libs.ksp.symbol.processing.aa.embeddable
                kspDependencies libs.ksp.symbol.processing.api
                kspDependencies libs.ksp.symbol.processing.common.deps
            }
        }
    }
}

subprojects {
    apply plugin: 'jacoco'

    // Prevent some dependencies used by Fenix/Focus from being used in AC.
    project.configurations.all {
        exclude group: 'com.adjust.sdk', module: 'adjust-android'
        exclude group: 'io.mockk', module: 'mockk'
    }

    project.configurations.configureEach {
        // Dependencies can't depend on a different major version of Glean than A-C itself.
        resolutionStrategy.eachDependency { details ->
            if (details.requested.group == 'org.mozilla.telemetry'
                    && details.requested.name.contains('glean') ) {
                def requested = details.requested.version.tokenize(".")
                def defined = project.ext.gleanVersion.tokenize(".")
                // Check the major version
                if (requested[0] != defined[0]) {
                    throw new AssertionError("Cannot resolve to a single Glean version. Requested: ${details.requested.version}, A-C uses: ${project.ext.gleanVersion}")
                } else {
                    // Enforce that all (transitive) dependencies are using the defined Glean version
                    details.useVersion project.ext.gleanVersion
                }
            }
        }

        resolutionStrategy.capabilitiesResolution.withCapability("org.mozilla.telemetry:glean-native") {
            def toBeSelected = candidates.find { it.id instanceof ModuleComponentIdentifier && it.id.module.contains('geckoview') }
            if (toBeSelected != null) {
                select(toBeSelected)
            }
            because 'use GeckoView Glean instead of standalone Glean'
        }
    }

    if (gradle.hasProperty('localProperties.dependencySubstitutions.geckoviewTopsrcdir')) {
        if (gradle.hasProperty('localProperties.dependencySubstitutions.geckoviewTopobjdir')) {
            ext.topobjdir = gradle."localProperties.dependencySubstitutions.geckoviewTopobjdir"
        }
        ext.topsrcdir = gradle."localProperties.dependencySubstitutions.geckoviewTopsrcdir"
        apply from: "${topsrcdir}/substitute-local-geckoview.gradle"
    }

    afterEvaluate {
        if (it.hasProperty('android')) {
            // Format test output
            tasks.matching {it instanceof Test}.configureEach() {
                systemProperty "robolectric.logging", "stdout"
                systemProperty "logging.test-mode", "true"
                systemProperty "javax.net.ssl.trustStoreType", "JKS"

                testLogging.events = []

                beforeSuite { descriptor ->
                    if (descriptor.getClassName() != null) {
                        println("\nSUITE: " + descriptor.getClassName())
                    }
                }

                beforeTest { descriptor ->
                    println("  TEST: " + descriptor.getName())
                }

                onOutput { descriptor, event ->
                    it.logger.lifecycle("    " + event.message.trim())
                }

                afterTest { descriptor, result ->
                    switch (result.getResultType()) {
                        case ResultType.SUCCESS:
                            println("  SUCCESS")
                            break

                        case ResultType.FAILURE:
                            def testId = descriptor.getClassName() + "." + descriptor.getName()
                            println("  TEST-UNEXPECTED-FAIL | " + testId + " | " + result.getException())
                            break

                        case ResultType.SKIPPED:
                            println("  SKIPPED")
                            break
                    }
                    it.logger.lifecycle("")
                }
            }

            dependencies {
                lintChecks project(':components:tooling-lint')
            }

            android {
                // We can't have one baseline file at the root of android-components because
                // this is not a project module and we would have to coordinate every module to
                // merge baselines.
                lint {
                    baseline = file("${projectDir}/lint-baseline.xml")
                }

                testOptions {
                    testCoverage {
                        jacocoVersion = libs.versions.jacoco.get()
                    }
                    unitTests {
                        includeAndroidResources = true
                    }
                }

                packaging {
                    resources {
                        excludes += ['META-INF/LICENSE.md', 'META-INF/LICENSE-notice.md']
                    }
                }

                androidResources {
                    ignoreAssetsPattern = "manifest.template.json"
                }
            }

            if (project.name != "support-test") {
                android.buildTypes.all { buildType ->
                    tasks.withType(Test).configureEach() {
                        jacoco {
                            includeNoLocationClasses = true
                            excludes = ['jdk.internal.*']
                        }

                        finalizedBy { "jacoco${buildType.name.capitalize()}TestReport" }
                    }

                    tasks.register("jacoco${buildType.name.capitalize()}TestReport", JacocoReport) {
                        reports {
                            xml.required = true
                            html.required = true
                        }

                        def fileFilter = ['**/R.class', '**/R$*.class', '**/BuildConfig.*', '**/Manifest*.*',
                                          '**/*Test*.*', 'android/**/*.*', '**/*$[0-9].*']
                        def kotlinDebugTree = fileTree(dir: "$project.layout.buildDirectory/tmp/kotlin-classes/${buildType.name}", excludes: fileFilter)
                        def javaDebugTree = fileTree(dir: "$project.layout.buildDirectory/intermediates/classes/${buildType.name}", excludes: fileFilter)
                        def mainSrc = "$project.projectDir/src/main/java"

                        sourceDirectories.setFrom(files([mainSrc]))
                        classDirectories.setFrom(files([kotlinDebugTree, javaDebugTree]))
                        getExecutionData().setFrom(fileTree(project.layout.buildDirectory).include([
                                "jacoco/test${buildType.name.capitalize()}UnitTest.exec"
                        ]))
                    }
                }

                android {
                    buildTypes {
                        debug {
                            // Enable test coverage when fetching dependencies: it's an easy way to
                            // ensure we fetch the Jacoco agent dependency `org.jacoco.agent`, which
                            // resolves to `org.jacoco.agent-$VERSION-runtime.jar`.
                            testCoverageEnabled = project.hasProperty("coverage") || gradle.mozconfig.substs.DOWNLOAD_ALL_GRADLE_DEPENDENCIES
                        }
                    }
                }
            }
        }
    }

    tasks.withType(AbstractTestTask).configureEach {
        failOnNoDiscoveredTests = false
    }
}

if (findProject(":geckoview") == null) {
    // Avoid adding this task if it already exists in a different root project.
    tasks.register("clean", Delete) {
        delete rootProject.layout.buildDirectory
    }
}

detekt {
    input = files("$projectDir/components", "$projectDir/buildSrc", "$projectDir/samples")
    config = files("$projectDir/config/detekt.yml")
    baseline = file("$projectDir/config/detekt-baseline.xml")

    reports {
        html {
            enabled = true
            destination = file("$projectDir/build/reports/detekt.html")
        }
        xml {
            enabled = false
        }
        txt {
            enabled = false
        }
    }
}

tasks.named("detekt").configure {
    reports {
        custom {
            reportId = "suppression-count"
            outputLocation.set(file("$projectDir/build/reports/suppressions.txt"))
        }
    }
}

tasks.withType(Detekt).configureEach() {
    // Custom detekt rules should be built before.
    // See https://detekt.dev/docs/introduction/extensions#pitfalls
    dependsOn(":components:tooling-detekt:assemble")

    autoCorrect = true

    exclude "**/build.gradle.kts"
    exclude "**/build/**"
    exclude "**/docs/**"
    exclude "**/resources/**"
    exclude "**/src/androidTest/**"
    exclude "**/src/iosTest/**"
    exclude "**/src/main/assets/extensions/**"
    exclude "**/src/test/**"
    exclude "**/test/src/**"
    exclude "**/tmp/**"
    exclude "**/tooling/fetch-tests/**"
}

// Apply same path exclusions as for the main task
tasks.withType(DetektCreateBaselineTask).configureEach() {
    dependsOn(":components:browser-icons:updateBuiltInExtensionVersion")
    dependsOn(":components:feature-accounts:updateBuiltInExtensionVersion")
    dependsOn(":components:feature-readerview:updateBuiltInExtensionVersion")
    dependsOn(":components:feature-search:updateAdsExtensionVersion")
    dependsOn(":components:feature-search:updateCookiesExtensionVersion")
    dependsOn(":components:samples-browser:updateBorderifyExtensionVersion")
    dependsOn(":components:samples-browser:updateTestExtensionVersion")
    dependsOn(":components:samples-compose-browser:updateBorderifyExtensionVersion")
    dependsOn(":components:samples-compose-browser:updateTestExtensionVersion")
    dependsOn(":components:tooling-detekt:assemble")

    exclude "**/build.gradle.kts"
    exclude "**/build/**"
    exclude "**/docs/**"
    exclude "**/resources/**"
    exclude "**/src/androidTest/**"
    exclude "**/src/iosTest/**"
    exclude "**/src/main/assets/extensions/**"
    exclude "**/src/test/**"
    exclude "**/test/src/**"
    exclude "**/tmp/**"
    exclude "**/tooling/fetch-tests/**"
}

configurations {
    ktlint

    detektDependencies
}

dependencies {
    ktlint(libs.ktlint) {
        attributes {
            attribute(Bundling.BUNDLING_ATTRIBUTE, getObjects().named(Bundling, Bundling.EXTERNAL))
        }
    }
    detektPlugins project(":components:tooling-detekt")
    detekt libs.detekt.cli

    detektDependencies libs.detekt.cli
}

tasks.register("ktlint", JavaExec) {
    group = "verification"
    description = "Check Kotlin code style."
    classpath = configurations.ktlint
    mainClass.set("com.pinterest.ktlint.Main")
    args "components/**/*.kt"
    args "samples/**/*.kt"
    args "!**/build/**/*.kt"
    args "buildSrc/**/*.kt"
    args "--reporter=json,output=build/reports/ktlint/ktlint.json"
    args "--reporter=plain"
}

tasks.register("ktlintFormat", JavaExec) {
    group = "formatting"
    description = "Fix Kotlin code style deviations."
    classpath = configurations.ktlint
    mainClass.set("com.pinterest.ktlint.Main")
    args "-F"
    args "components/**/*.kt"
    args "samples/**/*.kt"
    args "!**/build/**/*.kt"
    args "buildSrc/**/*.kt"
    args "--reporter=json,output=build/reports/ktlint/ktlintFormat.json"
    args "--reporter=plain"
    jvmArgs("--add-opens", "java.base/java.lang=ALL-UNNAMED")
}

tasks.register("lint") {
    group = "verification"
    description = "Runs lint on all android-components subprojects."

    // We use `dependsOn` over string task names to ensure this is all lazy
    // until the `lint` task is actually selected. This aggregates over all
    // components listed in the buildconfig instead of relying on what is
    // currently configured by Gradle and avoiding configuration-on-demand
    // issues. Each component is required to implement a `lint` task though it
    // can be empty.
    dependsOn {
        def allComponents = rootProject.ext.buildConfig.projects
        allComponents.collect { ":${it.key}:lint" }
    }
}

tasks.register("listRepositories") {
    def reposData = project.provider {
        project.repositories.collect { repo ->
            [name: repo.name, url: repo.url.toString()]
        }
    }
    doLast {
        println "Repositories:"
        reposData.get().each { println "Name: " + it.name + "; url: " + it.url }
    }
}