/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

buildscript {
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${rootProject.hasProperty("kotlinVersion") ? rootProject.ext.kotlinVersion : KOTLIN_VERSION}"
    }
}

plugins {
    id("com.android.library")
    id("com.facebook.react")
    id("maven-publish")
    id("de.undercouch.download")
}

import com.facebook.react.tasks.internal.*

import java.nio.file.Paths

import de.undercouch.gradle.tasks.download.Download
import org.apache.tools.ant.taskdefs.condition.Os
import org.apache.tools.ant.filters.ReplaceTokens

def AAR_OUTPUT_URL = "file://${projectDir}/../android"
// We download various C++ open-source dependencies into downloads.
// We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
// After that we build native code from src/main/jni with module path pointing at third-party-ndk.

def customDownloadsDir = System.getenv("REACT_NATIVE_DOWNLOADS_DIR")
def downloadsDir = customDownloadsDir ? new File(customDownloadsDir) : new File("$buildDir/downloads")
def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
def reactNativeRootDir = projectDir.parent

// You need to have following folders in this directory:
//   - boost_1_76_0
//   - double-conversion-1.1.6
//   - folly-deprecate-dynamic-initializer
//   - glog-0.3.5
def dependenciesPath = System.getenv("REACT_NATIVE_DEPENDENCIES")

// The Boost library is a very large download (>100MB).
// If Boost is already present on your system, define the REACT_NATIVE_BOOST_PATH env variable
// and the build will use that.
def boostPath = dependenciesPath ?: System.getenv("REACT_NATIVE_BOOST_PATH")

// Setup build type for NDK, supported values: {debug, release}
def nativeBuildType = System.getenv("NATIVE_BUILD_TYPE") ?: "release"

// We put the publishing version from gradle.properties inside ext. so other
// subprojects can access it as well.
ext.publishing_version = VERSION_NAME

task createNativeDepsDirectories {
    downloadsDir.mkdirs()
    thirdPartyNdkDir.mkdirs()
}

task downloadBoost(dependsOn: createNativeDepsDirectories, type: Download) {
    src("https://boostorg.jfrog.io/artifactory/main/release/${BOOST_VERSION.replace("_", ".")}/source/boost_${BOOST_VERSION}.tar.gz")
    onlyIfNewer(true)
    overwrite(false)
    dest(new File(downloadsDir, "boost_${BOOST_VERSION}.tar.gz"))
}

final def prepareBoost = tasks.register("prepareBoost", PrepareBoostTask) {
    it.dependsOn(boostPath ? [] : [downloadBoost])
    it.boostPath.setFrom(boostPath ?: tarTree(resources.gzip(downloadBoost.dest)))
    it.boostVersion.set(BOOST_VERSION)
    it.outputDir.set(new File(thirdPartyNdkDir, "boost"))
}

task downloadDoubleConversion(dependsOn: createNativeDepsDirectories, type: Download) {
    src("https://github.com/google/double-conversion/archive/v${DOUBLE_CONVERSION_VERSION}.tar.gz")
    onlyIfNewer(true)
    overwrite(false)
    dest(new File(downloadsDir, "double-conversion-${DOUBLE_CONVERSION_VERSION}.tar.gz"))
}

task prepareDoubleConversion(dependsOn: dependenciesPath ? [] : [downloadDoubleConversion], type: Copy) {
    from(dependenciesPath ?: tarTree(downloadDoubleConversion.dest))
    from("src/main/jni/third-party/double-conversion/")
    include("double-conversion-${DOUBLE_CONVERSION_VERSION}/src/**/*", "CMakeLists.txt")
    filesMatching("*/src/**/*", { fname -> fname.path = "double-conversion/${fname.name}" })
    includeEmptyDirs = false
    into("$thirdPartyNdkDir/double-conversion")
}

task downloadFolly(dependsOn: createNativeDepsDirectories, type: Download) {
    src("https://github.com/facebook/folly/archive/v${FOLLY_VERSION}.tar.gz")
    onlyIfNewer(true)
    overwrite(false)
    dest(new File(downloadsDir, "folly-${FOLLY_VERSION}.tar.gz"))
}

task prepareFolly(dependsOn: dependenciesPath ? [] : [downloadFolly], type: Copy) {
    from(dependenciesPath ?: tarTree(downloadFolly.dest))
    from("src/main/jni/third-party/folly/")
    include("folly-${FOLLY_VERSION}/folly/**/*", "CMakeLists.txt")
    eachFile { fname -> fname.path = (fname.path - "folly-${FOLLY_VERSION}/") }
    includeEmptyDirs = false
    into("$thirdPartyNdkDir/folly")
}

task downloadFmt(dependsOn: createNativeDepsDirectories, type: Download) {
    src("https://github.com/fmtlib/fmt/archive/${FMT_VERSION}.tar.gz")
    onlyIfNewer(true)
    overwrite(false)
    dest(new File(downloadsDir, "fmt-${FMT_VERSION}.tar.gz"))
}

task prepareFmt(dependsOn: dependenciesPath ? [] : [downloadFmt], type: Copy) {
    from(dependenciesPath ?: tarTree(downloadFmt.dest))
    from("src/main/jni/third-party/fmt/")
    include("fmt-${FMT_VERSION}/src/**/*", "fmt-${FMT_VERSION}/include/**/*", "CMakeLists.txt")
    eachFile { fname -> fname.path = (fname.path - "fmt-${FMT_VERSION}/") }
    includeEmptyDirs = false
    into("$thirdPartyNdkDir/fmt")
}

task downloadLibevent(dependsOn: createNativeDepsDirectories, type: Download) {
    src("https://github.com/libevent/libevent/releases/download/release-${LIBEVENT_VERSION}-stable/libevent-${LIBEVENT_VERSION}-stable.tar.gz")
    onlyIfNewer(true)
    overwrite(false)
    dest(new File(downloadsDir, "libevent-${LIBEVENT_VERSION}.tar.gz"))
}


final def prepareLibevent = tasks.register("prepareLibevent", PrepareLibeventTask) {
    it.dependsOn(dependenciesPath ? [] : [downloadLibevent])
    it.libeventPath.setFrom(dependenciesPath ?: tarTree(downloadLibevent.dest))
    it.libeventVersion.set(LIBEVENT_VERSION)
    it.outputDir.set(new File(thirdPartyNdkDir, "libevent"))
}

task downloadGlog(dependsOn: createNativeDepsDirectories, type: Download) {
    src("https://github.com/google/glog/archive/v${GLOG_VERSION}.tar.gz")
    onlyIfNewer(true)
    overwrite(false)
    dest(new File(downloadsDir, "glog-${GLOG_VERSION}.tar.gz"))
}

// Prepare glog sources to be compiled, this task will perform steps that normally should've been
// executed by automake. This way we can avoid dependencies on make/automake
final def prepareGlog = tasks.register("prepareGlog", PrepareGlogTask) {
    it.dependsOn(dependenciesPath ? [] : [downloadGlog])
    it.glogPath.setFrom(dependenciesPath ?: tarTree(downloadGlog.dest))
    it.glogVersion.set(GLOG_VERSION)
    it.outputDir.set(new File(thirdPartyNdkDir, "glog"))
}

// Create Android native library module based on jsc from npm
tasks.register('prepareJSC', PrepareJSCTask) {
    it.jscPackagePath.set(findNodeModulePath(projectDir, "jsc-android"))
    it.outputDir = project.layout.buildDirectory.dir("third-party-ndk/jsc")
}

task downloadNdkBuildDependencies {
    if (!boostPath) {
        dependsOn(downloadBoost)
    }
    dependsOn(downloadDoubleConversion)
    dependsOn(downloadFolly)
    dependsOn(downloadGlog)
    dependsOn(downloadFmt)
    dependsOn(downloadLibevent)
}

/**
 * Finds the path of the installed npm package with the given name using Node's
 * module resolution algorithm, which searches "node_modules" directories up to
 * the file system root. This handles various cases, including:
 *
 *   - Working in the open-source RN repo:
 *       Gradle: /path/to/react-native/ReactAndroid
 *       Node module: /path/to/react-native/node_modules/[package]
 *
 *   - Installing RN as a dependency of an app and searching for hoisted
 *     dependencies:
 *       Gradle: /path/to/app/node_modules/react-native/ReactAndroid
 *       Node module: /path/to/app/node_modules/[package]
 *
 *   - Working in a larger repo (e.g., Facebook) that contains RN:
 *       Gradle: /path/to/repo/path/to/react-native/ReactAndroid
 *       Node module: /path/to/repo/node_modules/[package]
 *
 * The search begins at the given base directory (a File object). The returned
 * path is a string.
 */
def findNodeModulePath(baseDir, packageName) {
    def basePath = baseDir.toPath().normalize()
    // Node's module resolution algorithm searches up to the root directory,
    // after which the base path will be null
    while (basePath) {
        def candidatePath = Paths.get(basePath.toString(), "node_modules", packageName)
        if (candidatePath.toFile().exists()) {
            return candidatePath.toString()
        }
        basePath = basePath.getParent()
    }
    return null
}


def reactNativeDevServerPort() {
    def value = project.getProperties().get("reactNativeDevServerPort")
    return value != null ? value : "8081"
}

def reactNativeInspectorProxyPort() {
    def value = project.getProperties().get("reactNativeInspectorProxyPort")
    return value != null ? value : reactNativeDevServerPort()
}

def reactNativeArchitectures() {
    def value = project.getProperties().get("reactNativeArchitectures")
    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
}

tasks.register("packageReactNdkLibsForBuck") {
    dependsOn("packageReactNdkDebugLibsForBuck")
}

tasks.register("packageReactNdkDebugLibsForBuck", Copy) {
    dependsOn("mergeDebugNativeLibs")
    // Shared libraries (.so) are copied from the merged_native_libs folder instead
    from("$buildDir/intermediates/merged_native_libs/debug/out/lib/")
    exclude("**/libjsc.so")
    exclude("**/libhermes.so")
    into("src/main/jni/prebuilt/lib")
}

tasks.register("packageReactNdkReleaseLibsForBuck", Copy) {
    dependsOn("mergeReleaseNativeLibs")
    // Shared libraries (.so) are copied from the merged_native_libs folder instead
    from("$buildDir/intermediates/merged_native_libs/release/out/lib/")
    exclude("**/libjsc.so")
    exclude("**/libhermes.so")
    into("src/main/jni/prebuilt/lib")
}

final def extractNativeDependencies = tasks.register('extractNativeDependencies', ExtractJniAndHeadersTask) {
    it.extractHeadersConfiguration.setFrom(configurations.extractHeaders)
    it.extractJniConfiguration.setFrom(configurations.extractJNI)
    it.baseOutputDir = project.file("src/main/jni/first-party/")
}

task installArchives {
    dependsOn("publishAllPublicationsToNpmRepository")
}

android {
    buildToolsVersion = "31.0.0"
    compileSdkVersion 31

    // Used to override the NDK path/version on internal CI or by allowing
    // users to customize the NDK path/version from their root project (e.g. for M1 support)
    if (rootProject.hasProperty("ndkPath")) {
        ndkPath rootProject.ext.ndkPath
    }
    if (rootProject.hasProperty("ndkVersion")) {
        ndkVersion rootProject.ext.ndkVersion
    }

    defaultConfig {
        minSdkVersion(21)
        targetSdkVersion(31)
        versionCode(1)
        versionName("1.0")

        consumerProguardFiles("proguard-rules.pro")

        buildConfigField("boolean", "IS_INTERNAL_BUILD", "false")
        buildConfigField("int", "EXOPACKAGE_FLAGS", "0")
        buildConfigField("int", "HERMES_BYTECODE_VERSION", "0")

        resValue "integer", "react_native_dev_server_port", reactNativeDevServerPort()
        resValue "integer", "react_native_inspector_proxy_port", reactNativeInspectorProxyPort()

        testApplicationId("com.facebook.react.tests.gradle")
        testInstrumentationRunner("androidx.test.runner.AndroidJUnitRunner")

        externalNativeBuild {
            cmake {
                arguments "-DREACT_COMMON_DIR=${reactNativeRootDir}/ReactCommon",
                        "-DREACT_ANDROID_DIR=$projectDir",
                        "-DREACT_BUILD_DIR=$buildDir",
                        "-DANDROID_STL=c++_shared",
                        "-DANDROID_TOOLCHAIN=clang",
                        "-DANDROID_PLATFORM=android-21"

                targets "reactnativejni",
                    "jscexecutor",
                    "jsijniprofiler",
                    "reactnativeblob",
                    "reactperfloggerjni",
                    "react_newarchdefaults",
                    "turbomodulejsijni",
                    "fabricjni"
            }
        }
        ndk {
            abiFilters (*reactNativeArchitectures())
        }
    }

    buildTypes {
        debug {
            externalNativeBuild {
                cmake {
                    targets "hermes-executor-debug"
                }
            }
        }

        release {
            externalNativeBuild {
                cmake {
                    targets "hermes-executor-release"
                }
            }
        }
    }

    externalNativeBuild {
        cmake {
            path "src/main/jni/CMakeLists.txt"
        }
    }

    preBuild.dependsOn(prepareJSC, prepareBoost, prepareDoubleConversion, prepareFmt, prepareFolly, prepareGlog, prepareLibevent, extractNativeDependencies)
    preBuild.dependsOn("generateCodegenArtifactsFromSchema")

    sourceSets.main {
        res.srcDirs = ["src/main/res/devsupport", "src/main/res/shell", "src/main/res/views/modal", "src/main/res/views/uimanager"]
        java {
            srcDirs = ["src/main/java", "src/main/libraries/soloader/java", "src/main/jni/first-party/fb/jni/java"]
            exclude("com/facebook/react/processing")
            exclude("com/facebook/react/module/processing")
        }
    }

    lintOptions {
        abortOnError(false)
    }

    packagingOptions {
        exclude("META-INF/NOTICE")
        exclude("META-INF/LICENSE")
        // We intentionally don't want to bundle any JS Runtime inside the Android AAR
        // we produce. The reason behind this is that we want to allow users to pick the
        // JS engine by specifying a dependency on either `hermes-engine` or `android-jsc`
        // that will include the necessary .so files to load.
        exclude("**/libhermes.so")
        exclude("**/libjsc.so")
    }

    configurations {
        extractHeaders
        extractJNI
    }

    buildFeatures {
        prefab true
    }

    publishing {
        multipleVariants {
            withSourcesJar()
            allVariants()
        }
    }
}

dependencies {
    api("androidx.appcompat:appcompat-resources:${ANDROIDX_APPCOMPAT_VERSION}")
    api("androidx.appcompat:appcompat:${ANDROIDX_APPCOMPAT_VERSION}")
    api("androidx.autofill:autofill:${ANDROIDX_AUTOFILL_VERSION}")
    api("androidx.swiperefreshlayout:swiperefreshlayout:${SWIPEREFRESH_LAYOUT_VERSION}")
    api("androidx.tracing:tracing:${ANDROIDX_TRACING_VERSION}")

    api("com.facebook.fbjni:fbjni-java-only:${FBJNI_VERSION}")
    api("com.facebook.fresco:fresco:${FRESCO_VERSION}")
    api("com.facebook.fresco:imagepipeline-okhttp3:${FRESCO_VERSION}")
    api("com.facebook.fresco:ui-common:${FRESCO_VERSION}")
    api("com.facebook.infer.annotation:infer-annotation:${INFER_ANNOTATIONS_VERSION}")
    api("com.facebook.soloader:soloader:${SO_LOADER_VERSION}")
    api("com.facebook.yoga:proguard-annotations:${PROGUARD_ANNOTATIONS_VERSION}")

    api("com.google.code.findbugs:jsr305:${JSR305_VERSION}")
    api("com.squareup.okhttp3:okhttp-urlconnection:${OKHTTP_VERSION}")
    api("com.squareup.okhttp3:okhttp:${OKHTTP_VERSION}")
    api("com.squareup.okio:okio:${OKIO_VERSION}")
    api("javax.inject:javax.inject:${JAVAX_INJECT_VERSION}")

    extractHeaders("com.facebook.fbjni:fbjni:${FBJNI_VERSION}:headers")
    extractJNI("com.facebook.fbjni:fbjni:${FBJNI_VERSION}")

    // It's up to the consumer to decide if hermes should be included or not.
    // Therefore hermes-engine is a compileOnly dependency.
    compileOnly(project(":ReactAndroid:hermes-engine"))

    testImplementation("junit:junit:${JUNIT_VERSION}")
    testImplementation("org.assertj:assertj-core:${ASSERTJ_VERSION}")
    testImplementation("org.mockito:mockito-core:${MOCKITO_CORE_VERSION}")
    testImplementation("org.powermock:powermock-api-mockito2:${POWERMOCK_VERSION}")
    testImplementation("org.powermock:powermock-classloading-xstream:${POWERMOCK_VERSION}")
    testImplementation("org.powermock:powermock-module-junit4-rule:${POWERMOCK_VERSION}")
    testImplementation("org.robolectric:robolectric:${ROBOLECTRIC_VERSION}")

    androidTestImplementation(fileTree(dir: "src/main/third-party/java/buck-android-support/", include: ["*.jar"]))
    androidTestImplementation("androidx.test:runner:${ANDROIDX_TEST_VERSION}")
    androidTestImplementation("androidx.test:rules:${ANDROIDX_TEST_VERSION}")
    androidTestImplementation("org.mockito:mockito-core:${MOCKITO_CORE_VERSION}")
}

react {
    // TODO: The library name is chosen for parity with Fabric components & iOS
    // This should be changed to a more generic name, e.g. `ReactCoreSpec`.
    libraryName = "rncore"
    root = file("..")
    jsRootDir = file("../Libraries")
    reactNativeDir = file("$projectDir/..")
    useJavaGenerator = System.getenv("USE_CODEGEN_JAVAPOET")?.toBoolean() ?: false
    // We search for the codegen in either one of the `node_modules` folder or in the
    // root packages folder (that's for when we build from source without calling `yarn install`).
    codegenDir = file(findNodeModulePath(projectDir, "react-native-codegen") ?: "../packages/react-native-codegen/")
}

afterEvaluate {
    // Needed as some of the native sources needs to be downloaded
    // before configureNdkBuildDebug could be executed.
    reactNativeArchitectures().each { architecture ->
        tasks.findByName("configureCMakeDebug[${architecture}]")?.configure { dependsOn(preBuild) }
        tasks.findByName("configureCMakeRelWithDebInfo[${architecture}]")?.configure { dependsOn(preBuild) }
    }
    configureCMakeDebug.dependsOn(preBuild)
    configureCMakeRelWithDebInfo.dependsOn(preBuild)

    publishing {
        publications {
            release(MavenPublication) {
                // We do a multi variant release
                from components.default

                // You can then customize attributes of the publication as shown below.
                artifactId = POM_ARTIFACT_ID
                groupId = GROUP
                version = VERSION_NAME

                pom {
                    name = POM_NAME
                    description = "A framework for building native apps with React"
                    url = "https://github.com/facebook/react-native"

                    developers {
                        developer {
                            id = "facebook"
                            name = "Facebook"
                        }
                    }

                    licenses {
                        license {
                            name = "MIT License"
                            url = "https://github.com/facebook/react-native/blob/HEAD/LICENSE"
                            distribution = "repo"
                        }
                    }

                    scm {
                        url = "https://github.com/facebook/react-native.git"
                        connection = "scm:git:https://github.com/facebook/react-native.git"
                        developerConnection = "scm:git:git@github.com:facebook/react-native.git"
                    }
                }
            }
        }

        repositories {
            maven {
                name = "npm"
                url = AAR_OUTPUT_URL
            }
        }
    }
}

apply plugin: "org.jetbrains.kotlin.android"