// Copyright (c) 2026, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import com.google.gson.Gson
import java.net.URI
import java.nio.file.Files.readString
import java.nio.file.Paths
import java.util.UUID
import java.util.concurrent.Callable
import org.gradle.api.tasks.bundling.Jar
import org.gradle.kotlin.dsl.provideDelegate
import org.spdx.sbom.gradle.SpdxSbomTask
import org.spdx.sbom.gradle.extensions.DefaultSpdxSbomTaskExtension

plugins {
  id("org.jetbrains.kotlin.jvm")
  id("r8-conventions")
  id("dependencies-plugin")
  id("org.spdx.sbom")
}

if (project.hasProperty("spdxVersion")) {
  project.version = project.property("spdxVersion")!!
}

// We need all the runtime deps for SPDX generation.
val r8Deps by
  configurations.creating {
    isCanBeConsumed = false
    isCanBeResolved = true
  }

dependencies {
  compileOnly(libs.bundles.compilerDeps)
  r8Deps(libs.bundles.compilerDeps)
}

spdxSbom {
  targets {
    create("r8") {
      // Use of both compileClasspath and runtimeClasspath due to how the
      // dependencies jar is built and dependencies above therefore use
      // compileOnly for actual runtime dependencies.
      configurations.set(listOf("compileClasspath", "runtimeClasspath"))
      scm {
        uri.set("https://r8.googlesource.com/r8/")
        if (project.hasProperty("spdxRevision")) {
          revision.set(project.property("spdxRevision").toString())
        }
      }
      document {
        name.set("R8 Compiler Suite")
        // Generate version 5 UUID from fixed namespace UUID and name generated from revision
        // (git hash) and artifact name.
        if (project.hasProperty("spdxRevision")) {
          namespace.set(
            "https://spdx.google/" +
              uuid5(
                UUID.fromString("df17ea25-709b-4edc-8dc1-d3ca82c74e8e"),
                project.property("spdxRevision").toString() + "-r8",
              )
          )
        }
        creator.set("Organization: Google LLC")
        packageSupplier.set("Organization: Google LLC")
      }
    }
  }
}

val keepRadiusProtoJarScope by configurations.dependencyScope("keepRadiusProtoJarScope")
val keepRadiusProtoJarConfig by
  configurations.resolvable("keepRadiusProtoJarConfig") { extendsFrom(keepRadiusProtoJarScope) }
val keepAnnoDepsJarExceptAsmScope by configurations.dependencyScope("keepAnnoDepsJarExceptAsmScope")
val keepAnnoDepsJarExceptAsmConfig by
  configurations.resolvable("keepAnnoDepsJarExceptAsmConfig") {
    extendsFrom(keepAnnoDepsJarExceptAsmScope)
  }
val keepAnnoToolsJarScope by configurations.dependencyScope("keepAnnoToolsJarScope")
val keepAnnoToolsJarConfig by
  configurations.resolvable("keepAnnoToolsJarConfig") { extendsFrom(keepAnnoToolsJarScope) }

val libanalyzerProtoJarScope by configurations.dependencyScope("libanalyzerProtoJarScope")
val libanalyzerProtoJarConfig by
  configurations.resolvable("libanalyzerProtoJarConfig") { extendsFrom(libanalyzerProtoJarScope) }

val mainJarScope by configurations.dependencyScope("mainJarScope")
val mainJarConfig by configurations.resolvable("mainJarConfig") { extendsFrom(mainJarScope) }
val mainResourcesScope by configurations.dependencyScope("mainResourcesScope")
val mainResourcesConfig by
  configurations.resolvable("mainResourcesConfig") { extendsFrom(mainResourcesScope) }
val swissArmyKnifeScope by configurations.dependencyScope("swissArmyKnifeScope")
val swissArmyKnifeConfig by
  configurations.resolvable("swissArmyKnifeConfig") {
    extendsFrom(swissArmyKnifeScope)
    isTransitive = false
  }

dependencies {
  keepRadiusProtoJarScope(project(":keepradius", "keepradiusProtoJar"))
  keepAnnoDepsJarExceptAsmScope(project(":keepanno", "keepannoDepsJarExceptAsm"))
  keepAnnoToolsJarScope(project(":keepanno", "keepannoToolsJar"))
  libanalyzerProtoJarScope(project(":libanalyzer", "libanalyzer-proto-jar"))
  mainJarScope(project(":main", "mainJar"))
  mainResourcesScope(project(":main", "mainResources"))
  swissArmyKnifeScope(project(":swissarmyknife"))
}

val sharedDepsScope by configurations.dependencyScope("sharedDepsScope")
val sharedDepsConfig by
  configurations.resolvable("sharedDepsConfig") { extendsFrom(sharedDepsScope) }

val sharedTestDepsScope by configurations.dependencyScope("sharedTestDepsScope")
val sharedTestDepsConfig by
  configurations.resolvable("sharedTestDepsConfig") { extendsFrom(sharedTestDepsScope) }

dependencies {
  sharedDepsScope(project(":third_party", "sharedDepsFiles"))
  sharedTestDepsScope(project(":third_party", "sharedTestDepsFiles"))
}

val depsJarFilesScope by configurations.dependencyScope("depsJarFilesScope")

val depsJarFiles by configurations.consumable("depsJarFiles") { extendsFrom(depsJarFilesScope) }

val depsFiles by configurations.consumable("depsFiles") { extendsFrom(depsJarFilesScope) }

fun relocateDepsExceptAsm(pkg: String): List<String> {
  return listOf(
    "--map",
    "android.aapt.**->${pkg}.android.aapt",
    "--map",
    "androidx.annotation.**->${pkg}.androidx.annotation",
    "--map",
    "androidx.collection.**->${pkg}.androidx.collection",
    "--map",
    "androidx.tracing.**->${pkg}.androidx.tracing",
    "--map",
    "com.android.**->${pkg}.com.android",
    "--map",
    "com.android.zipflinger.**->${pkg}.com.android.zipflinger",
    "--map",
    "com.google.common.**->${pkg}.com.google.common",
    "--map",
    "com.google.gson.**->${pkg}.com.google.gson",
    "--map",
    "com.google.thirdparty.**->${pkg}.com.google.thirdparty",
    "--map",
    "com.squareup.wire.**->${pkg}.com.squareup.wire",
    "--map",
    "it.unimi.dsi.fastutil.**->${pkg}.it.unimi.dsi.fastutil",
    "--map",
    "kotlin.**->${pkg}.jetbrains.kotlin",
    "--map",
    "kotlinx.**->${pkg}.jetbrains.kotlinx",
    "--map",
    "okio.**->${pkg}.okio",
    "--map",
    "org.jetbrains.**->${pkg}.org.jetbrains",
    "--map",
    "org.intellij.**->${pkg}.org.intellij",
    "--map",
    "org.checkerframework.**->${pkg}.org.checkerframework",
    "--map",
    "com.google.j2objc.**->${pkg}.com.google.j2objc",
    "--map",
    "com.google.protobuf.**->${pkg}.com.google.protobuf",
    "--map",
    "perfetto.protos.**->${pkg}.perfetto.protos",
    "--map",
    "org.jspecify.annotations.**->${pkg}.org.jspecify.annotations",
    "--map",
    "_COROUTINE.**->${pkg}._COROUTINE",
  )
}

interface InjectedArcOps {
  @get:Inject val arcOps: ArchiveOperations
}

tasks {
  val filteredDepsJar =
    register<Jar>("filteredDepsJar") {
      val injected = project.objects.newInstance<InjectedArcOps>()
      from(
        Callable {
          r8Deps.incoming.files
            .filter {
              val path = it.absolutePath
              path.contains("third_party") &&
                path.contains("dependencies") &&
                !path.contains("errorprone")
            }
            .map { injected.arcOps.zipTree(it) }
        }
      )

      archiveFileName.set("r8-deps-merged.jar")
      destinationDirectory.set(layout.buildDirectory.dir("libs"))
      duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    }

  withType<SpdxSbomTask> {
    taskExtension.set(
      object : DefaultSpdxSbomTaskExtension() {
        override fun mapRepoUri(input: URI?, moduleId: ModuleVersionIdentifier): URI? {

          // Locate the file origin.json with URL for download location.
          fun getOriginJson(): java.nio.file.Path {
            var repositoryDir =
              moduleId.group.replace('.', '/') + "/" + moduleId.name + "/" + moduleId.version
            return Paths.get("third_party", "dependencies", repositoryDir, "origin.json")
          }

          // Simple data model of the content of origin.json generated by the tool to download
          // and create a local repository. E.g.:
          /*
              {
                "artifacts": [
                  {
                    "file": "org/ow2/asm/asm/9.5/asm-9.5.pom",
                    "repo": "https://repo1.maven.org/maven2/",
                    "artifact": "org.ow2.asm:asm:pom:9.5"
                  },
                  {
                    "file": "org/ow2/asm/asm/9.5/asm-9.5.jar",
                    "repo": "https://repo1.maven.org/maven2/",
                    "artifact": "org.ow2.asm:asm:jar:9.5"
                  }
                ]
              }
          */
          data class Artifact(val file: String, val repo: String, val artifact: String)
          data class Artifacts(val artifacts: List<Artifact>)

          // Read origin.json.
          val json = readString(getOriginJson())
          val artifacts = Gson().fromJson(json, Artifacts::class.java)
          return URI.create(artifacts.artifacts.get(0).repo)
        }
      }
    )
  }

  val consolidatedLicense =
    register<ConsolidatedLicenseTask>("consolidatedLicense") {
      r8License = File(getRootDir(), "LICENSE")
      libraryLicenseMap = File(getRootDir(), "LIBRARY-LICENSE")
      libraryLicenses = File(getRootDir(), "library-licensing")
      dependencies =
        configurations.named("runtimeClasspath").map { runtimeClasspath ->
          runtimeClasspath.incoming.resolutionResult.allComponents.mapNotNull {
            val compId = it.id
            if (compId is ModuleComponentIdentifier) {
              "${compId.group}:${compId.module}"
            } else null
          }
        }
      consolidatedOutputFile = File(getRootDir(), "build/generatedLicense/LICENSE")
    }

  val threadingModuleBlockingJar =
    register<Zip>("threadingModuleBlockingJar") {
      val injected = project.objects.newInstance<InjectedArcOps>()
      dependsOn(mainJarConfig)
      from(mainJarConfig.elements.map { it.map { injected.arcOps.zipTree(it) } })
      include("com/android/tools/r8/threading/providers/blocking/**")
      destinationDirectory.set(File(getRootDir(), "build/libs"))
      archiveFileName.set("threading-module-blocking.jar")
    }

  val threadingModuleSingleThreadedJar =
    register<Zip>("threadingModuleSingleThreadedJar") {
      val injected = project.objects.newInstance<InjectedArcOps>()
      dependsOn(mainJarConfig)
      from(mainJarConfig.elements.map { it.map { injected.arcOps.zipTree(it) } })
      include("com/android/tools/r8/threading/providers/singlethreaded/**")
      destinationDirectory.set(File(getRootDir(), "build/libs"))
      archiveFileName.set("threading-module-single-threaded.jar")
    }

  dependencies {
    add(depsJarFilesScope.name, files(filteredDepsJar))
    add(depsJarFilesScope.name, project(":resourceshrinker", "resourceshrinkerDepsJar"))
    add(depsJarFilesScope.name, files(threadingModuleBlockingJar))
    add(depsJarFilesScope.name, files(threadingModuleSingleThreadedJar))
  }

  val filteredDepsJarConfig by configurations.consumable("filteredDepsJarConfig")

  artifacts {
    add(depsFiles.name, consolidatedLicense)
    add(filteredDepsJarConfig.name, filteredDepsJar)
  }

  val depsJarFilesConfig by
    configurations.resolvable("depsJarFilesConfig") { extendsFrom(depsJarFilesScope) }

  // Jar containing all 3p deps, plus R8 threading modules.
  val depsJar =
    register<Zip>("depsJar") {
      dependsOn(depsJarFilesConfig)
      from(Callable { depsJarFilesConfig.files.map(::zipTree) })
      from(consolidatedLicense)
      include("**/*.class")
      include("META-INF/services/kotlin.metadata.internal.extensions.MetadataExtensions")
      include("LICENSE")
      exclude("**/module-info.class")
      exclude("javax/annotation/**")
      exclude("wireless/**")
      exclude("META-INF/versions/**")

      // Disabling compression makes this step go from 4s -> 2s as of Nov 2025,
      // as measured by "gradle --profile".
      entryCompression = ZipEntryCompression.STORED

      duplicatesStrategy = DuplicatesStrategy.EXCLUDE
      archiveFileName.set("deps.jar")
    }

  val protoJar =
    register<Zip>("protoJar") {
      val injected = project.objects.newInstance<InjectedArcOps>()
      dependsOn(keepRadiusProtoJarConfig, libanalyzerProtoJarConfig)
      from(keepRadiusProtoJarConfig.elements.map { it.map { injected.arcOps.zipTree(it) } })
      from(libanalyzerProtoJarConfig.elements.map { it.map { injected.arcOps.zipTree(it) } })
      exclude("META-INF/MANIFEST.MF")
      archiveFileName.set("proto.jar")
      destinationDirectory.set(File(getRootDir(), "build/libs"))
    }

  val r8WithRelocatedDepsManifest =
    register<Jar>("r8WithRelocatedDepsManifest") {
      manifest { attributes["Main-Class"] = "com.android.tools.r8.SwissArmyKnife" }
      archiveFileName.set("r8-manifest.jar")
    }

  val r8WithRelocatedDeps =
    register<SwissArmyKnifeTask>("r8WithRelocatedDeps") {
      outputs.doNotCacheIf("Large standalone artifact (~50MB)") { true }
      swissArmyKnifeClasspath.from(swissArmyKnifeConfig, depsJar)
      compiler = "relocator"
      inputFiles.from(depsJar)
      inputFiles.from(protoJar)
      inputFiles.from(mainResourcesConfig)
      inputFiles.from(r8WithRelocatedDepsManifest)
      inputNoResFiles.from(swissArmyKnifeConfig)
      val pkg = "com.android.tools.r8"
      extraArgs =
        listOf(
          "--map",
          "com.android.tools.r8.**->${pkg}",
          "--map",
          "com.android.tools.r8.keepanno.annotations.**->${pkg}.keepanno.annotations",
          "--map",
          "com.android.tools.r8.keepanno.**->${pkg}.relocated.keepanno",
          "--map",
          "org.objectweb.asm.**->${pkg}.org.objectweb.asm",
        ) + relocateDepsExceptAsm(pkg) + listOf("--map-diagnostics", "warning", "error")
      outputFile = File(getRootDir(), "build/libs/r8.jar")
    }

  register<SwissArmyKnifeTask>("keepAnnoToolsWithRelocatedDeps") {
    outputs.doNotCacheIf("Large standalone artifact (~8MB)") { true }
    swissArmyKnifeClasspath.from(swissArmyKnifeConfig, depsJar)
    compiler = "relocator"
    inputNoResFiles.from(keepAnnoDepsJarExceptAsmConfig)
    inputNoResFiles.from(keepAnnoToolsJarConfig)
    val pkg = "com.android.tools.r8.keepanno"
    extraArgs =
      listOf("--map", "com.android.tools.r8.keepanno.**->${pkg}") +
        relocateDepsExceptAsm(pkg) +
        listOf("--map-diagnostics", "warning", "error")
    outputFile = File(getRootDir(), "build/libs/keepanno-tools.jar")
  }

  register<CreateR8LibraryTask>("processKeepRulesLibWithRelocatedDeps") {
    r8compilerClasspath.from(r8WithRelocatedDeps.flatMap { it.outputFile })
    inputJar = r8WithRelocatedDeps.flatMap { it.outputFile }
    pgConfigs.from(File(rootDir, "src/main/keep_processkeeprules.txt"))
    enableKeepAnnotations = false

    setOutputJarFile(File(rootDir, "build/libs/processkeepruleslib.jar"))
  }
}