import org.gradle.api.services.BuildServiceParameters
import org.tomlj.Toml
import org.tomlj.TomlParseResult
import org.tomlj.TomlTable

buildscript {
    repositories {
        gradle.mozconfig.substs.GRADLE_MAVEN_REPOSITORIES.each { repository ->
            maven {
                url = repository
                if (gradle.mozconfig.substs.ALLOW_INSECURE_GRADLE_REPOSITORIES) {
                    allowInsecureProtocol = true
                }
            }
        }
    }

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

        // Used in mobile/android/fenix/app/build.gradle
        classpath libs.androidx.benchmark.gradle
        classpath libs.androidx.navigation.safeargs
        classpath libs.osslicenses.plugin
        classpath libs.mozilla.glean.gradle.plugin
    }
}

plugins {
    id 'ApkSizePlugin'
    id "mozac.ConfigPlugin"
    id 'org.mozilla.conventions.mach-tasks'
    alias(libs.plugins.android.library) apply false
    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)
    alias(libs.plugins.spotless)
}

def tryInt = { string ->
    if (string == null) {
        return string
    }
    if (string.isInteger()) {
        return string as Integer
    }
    return string
}

abstract class VerifyGleanVersionTask extends DefaultTask {
    @InputFile
    final RegularFileProperty source = project.objects.fileProperty().convention(project.layout.projectDirectory.file("Cargo.lock"))

    @Input
    String expectedVersion = project.ext.gleanVersion

    @OutputFile
    final RegularFileProperty outputFile = project.objects.fileProperty()

    @TaskAction
    void verifyGleanVersion() {
        def foundVersion = getRustVersionFor(source.get().asFile, "glean")
        if (expectedVersion != foundVersion) {
          throw new GradleException("Mismatched Glean version, expected: '${expectedVersion}'," +
              " found '${foundVersion}'")
        } else {
            logger.lifecycle("verifyGleanVersion> expected version matches found version '${foundVersion}'")
        }

        outputFile.get().asFile.text = "glean-${foundVersion}"
    }

    // Parses the Cargo.lock and returns the version for the given package name.
    static String getRustVersionFor(file, packageName) {
        String version = null;
        TomlParseResult result = Toml.parse(file.getText());
        for (object in result.getArray("package").toList()) {
            def table = (TomlTable) object
            if (table.getString("name") == packageName) {
                if (version != null) {
                    throw new GradleException("Multiple versions for '${packageName}' found." +
                                                     " Ensure '${packageName}' is only included once.")
                }
                version = table.getString("version")
            }
        }
        return version
    }
}

tasks.register("verifyGleanVersion", VerifyGleanVersionTask) {
    outputFile.convention(layout.buildDirectory.file("glean/verifyGleanVersion.marker"))
}

allprojects {
    // Expose the per-object-directory configuration to all projects.
    ext {
        mozconfig = gradle.mozconfig
        topsrcdir = gradle.mozconfig.topsrcdir
        topobjdir = gradle.mozconfig.topobjdir

        gleanVersion = libs.versions.glean.get() // Verification done in verifyGleanVersion task

        artifactSuffix = getArtifactSuffix()
        versionName = getVersionName()
        versionCode = computeVersionCode()
        versionNumber = getVersionNumber()
        buildId = getBuildId()

        buildToolsVersion = mozconfig.substs.ANDROID_BUILD_TOOLS_VERSION
        compileSdkMajorVersion = tryInt(mozconfig.substs.ANDROID_COMPILE_SDK_MAJOR)
        compileSdkMinorVersion = tryInt(mozconfig.substs.ANDROID_COMPILE_SDK_MINOR)
        minSdkVersion = tryInt(mozconfig.substs.MOZ_ANDROID_MIN_SDK_VERSION)
        targetSdkVersion = tryInt(mozconfig.substs.ANDROID_TARGET_SDK)
        manifestPlaceholders = [
            ANDROID_TARGET_SDK: mozconfig.substs.ANDROID_TARGET_SDK,
            MOZ_ANDROID_MIN_SDK_VERSION: mozconfig.substs.MOZ_ANDROID_MIN_SDK_VERSION,
        ]
    }

    afterEvaluate {
        if (it.hasProperty('android')) {
            android {
                buildToolsVersion gradle.mozconfig.substs.ANDROID_BUILD_TOOLS_VERSION
                testOptions {
                    unitTests.includeAndroidResources = true
                }
            }
        }
    }

    // Use the semanticdb-javac and semanticdb-kotlinc plugins to generate semanticdb files for Searchfox
    if (mozconfig.substs.ENABLE_MOZSEARCH_PLUGIN || mozconfig.substs.DOWNLOAD_ALL_GRADLE_DEPENDENCIES) {
        def targetRoot = new File(topobjdir, "mozsearch_java_index")

        afterEvaluate {
            def addDependencyToConfigurationIfExists = { configurationName, dependency ->
                def configuration = configurations.findByName(configurationName)
                if (configuration != null) {
                    dependencies.add(configurationName, dependency)
                }
            }

            addDependencyToConfigurationIfExists("compileOnly", libs.semanticdb.java)
            addDependencyToConfigurationIfExists("testCompileOnly", libs.semanticdb.java)
            addDependencyToConfigurationIfExists("androidTestCompileOnly", libs.semanticdb.java)
            addDependencyToConfigurationIfExists("kotlinCompilerPluginClasspath", libs.semanticdb.kotlin)
        }

        tasks.withType(JavaCompile) {
            options.compilerArgs += [
                "-Xplugin:semanticdb -sourceroot:${topsrcdir} -targetroot:${targetRoot}",
            ]
        }

        tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile) {
            compilerOptions.freeCompilerArgs.addAll([
                "-P", "plugin:semanticdb-kotlinc:sourceroot=${topsrcdir}".toString(),
                "-P", "plugin:semanticdb-kotlinc:targetroot=${targetRoot}".toString(),
            ])
        }
    }
}

// Non-official versions are like "61.0a1" or "61.0b1", where "a1" and "b1"
// are the milestone.
// This simply strips that off, leaving "61.0" in this example.
def getAppVersionWithoutMilestone() {
    return project.ext.mozconfig.substs.MOZ_APP_VERSION.replaceFirst(/[ab][0-9]/, "")
}

// This converts MOZ_APP_VERSION into an integer
// version code.
//
// We take something like 58.1.2a1 and come out with 5800102
// This gives us 3 digits for the major number, and 2 digits
// each for the minor and build number. Beta and Release
//
// This must be synchronized with _compute_gecko_version(...) in /taskcluster/gecko_taskgraph/transforms/task.py
def computeVersionCode() {
    String appVersion = getAppVersionWithoutMilestone()

    // Split on the dot delimiter, e.g. 58.1.1a1 -> ["58, "1", "1a1"]
    String[] parts = appVersion.split('\\.')

    assert parts.size() == 2 || parts.size() == 3

    // Major
    int code = Integer.parseInt(parts[0]) * 100000

    // Minor
    code += Integer.parseInt(parts[1]) * 100

    // Build
    if (parts.size() == 3) {
        code += Integer.parseInt(parts[2])
    }

    return code;
}

def getVersionName() {
    return "${mozconfig.substs.MOZ_APP_VERSION}-${mozconfig.substs.MOZ_UPDATE_CHANNEL}"
}

// Mimic Python: open(os.path.join(buildconfig.topobjdir, 'buildid.h')).readline().split()[2]
def getBuildId() {
    def buildidFile = file("${topobjdir}/buildid.h")
    if (!buildidFile.exists()) {
        throw new GradleException(
            "A required build file is missing from the object directory:\n" +
                "  - ${buildidFile}\n\n" +
                "This file is produced by a full build, not by Gradle.\n" +
                "Run `./mach build` from the source directory first, then retry your Gradle build."
        )
    }
    return buildidFile.getText('utf-8').split()[2]
}

def getVersionNumber() {
    def appVersion = getAppVersionWithoutMilestone()
    def parts = appVersion.split('\\.')
    def version = parts[0] + "." + parts[1] + "." + getBuildId()
    def substs = project.ext.mozconfig.substs
    if (!substs.MOZILLA_OFFICIAL && !substs.MOZ_ANDROID_FAT_AAR_ARCHITECTURES) {
        // Use -SNAPSHOT versions locally to enable the local GeckoView substitution flow.
        version += "-SNAPSHOT"
    }
    return version
}

def getArtifactSuffix() {
    def substs = project.ext.mozconfig.substs

    def suffix = ""
    // Release artifacts don't specify the channel, for the sake of simplicity.
    if (substs.MOZ_UPDATE_CHANNEL != 'release') {
        suffix += "-${mozconfig.substs.MOZ_UPDATE_CHANNEL}"
    }

    return suffix
}

afterEvaluate {
    subprojects { project ->
        tasks.withType(JavaCompile) {
            // Add compiler args for all code except third-party code.
            options.compilerArgs += [
                // Turn on all warnings, except...
                "-Xlint:all",
                // Deprecation, because we do use deprecated API for compatibility.
                "-Xlint:-deprecation",
                // Serial, because we don't use Java serialization.
                "-Xlint:-serial",
                // Classfile, because javac has a bug with MethodParameters attributes
                // with Java 7. https://bugs.openjdk.java.net/browse/JDK-8190452
                "-Xlint:-classfile"]

            // In GeckoView java projects only, turn all remaining warnings
            // into errors unless marked by @SuppressWarnings.
            def projectName = project.getName()
            if (projectName.startsWith('geckoview')
                || projectName == 'annotations'
                || projectName == 'messaging_example'
                || projectName == 'port_messaging_example'
                || projectName == 'test_runner'
            ) {
                options.compilerArgs += [
                        "-Werror"
                ]
            }
        }

        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: ${libs.mozilla.glean}")
                        } 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'
            }
        }
    }
}


subprojects { project ->
    // Perform spotless lint in GeckoView projects only.
    // Sync with spotless_projects in mobile/android/geckoview/gradle.configure.
    def projectName = project.getName()
    if (projectName.startsWith('geckoview')
            || projectName == 'annotations'
            || projectName == 'messaging_example'
            || projectName == 'port_messaging_example'
            || projectName == 'test_runner'
    ) {
        apply plugin: "com.diffplug.spotless"

        spotless {
            lineEndings = com.diffplug.spotless.LineEnding.UNIX
            java {
                target project.fileTree(project.projectDir) {
                    include '**/*.java'
                    exclude '**/thirdparty/**'
                }
                googleJavaFormat(libs.versions.google.java.format.get())
            }
            kotlin {
                target project.fileTree(project.projectDir) {
                    include '**/*.kt'
                    exclude '**/thirdparty/**'
                }
                ktlint("${libs.versions.ktlint.get()}").setEditorConfigPath("${topsrcdir}/mobile/android/geckoview/.editorconfig")
            }
        }

        // Work around https://github.com/diffplug/spotless/issues/1958 by
        // explicitly depending on Spotless plugin dependencies.
        project.configurations {
            googleJavaFormat
        }

        project.dependencies {
            googleJavaFormat libs.google.java.format
        }
    }

    afterEvaluate {
        if (it.hasProperty('android')) {
            kotlin {
                jvmToolchain(config.jvmTargetCompatibility)
            }
        }

        if (it.hasProperty('android')
                && (project.projectDir.absolutePath.contains("android-components")
                || projectName == "fenix"
                || projectName == "focus-android")
        ) {
            dependencies {
                lintChecks project.project(':components:tooling-lint')
            }

            android {
                // Copied from subbproject's build.gradle
                lint {
                    baseline = file("${project.projectDir}/lint-baseline.xml")
                }
            }
        }
    }

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

// These are convenience helpers to run lints over all the subprojects
def mobileProjects = [":fenix", ":focus-android", ":android-components"]
tasks.register("lint") {
    group = "verification"
    description = "Runs lint on all mobile projects."
    mobileProjects.each { dependsOn "${it}:lint" }
}
tasks.named("ktlint").configure {
    group = "verification"
    description = "Runs ktlint on all mobile projects."
    mobileProjects.each { dependsOn "${it}:ktlint" }
}
tasks.named("ktlintFormat").configure {
    group = "formatting"
    description = "Runs ktlintFormat on all mobile projects."
    mobileProjects.each { dependsOn "${it}:ktlintFormat" }
}
tasks.named("detekt").configure {
    // NOTE: We are replacing the default 'detekt' task.
    description = "Runs detekt on all mobile projects."
    mobileProjects.each { dependsOn "${it}:detekt" }
}

tasks.register("lint-a-c") {
    group = "verification"
    description = "(Deprecated) alias for :android-components:lint"
    dependsOn ":android-components:lint"
}