apply plugin: "com.android.application"

import com.android.build.OutputFile
import org.apache.tools.ant.taskdefs.condition.Os

project.ext.react = [
  enableHermes: true,  // clean and rebuild if changing
]

apply from: "../../node_modules/react-native/react.gradle"

/**
 * Set this to true to create two separate APKs instead of one:
 *   - An APK that only works on ARM devices
 *   - An APK that only works on x86 devices
 * The advantage is the size of the APK is reduced by about 4MB.
 * Upload all the APKs to the Play Store and people will download
 * the correct one based on the CPU architecture of their device.
 */
def enableSeparateBuildPerCPUArchitecture = false

/**
 * Run Proguard to shrink the Java bytecode in release builds.
 */
def enableProguardInReleaseBuilds = true

/**
 * The preferred build flavor of JavaScriptCore.
 *
 * For example, to use the international variant, you can use:
 * `def jscFlavor = 'org.webkit:android-jsc-intl:+'`
 *
 * The international variant includes ICU i18n library and necessary data
 * allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that
 * give correct results when using with locales other than en-US.  Note that
 * this variant is about 6MiB larger per architecture than default.
 */
def jscFlavor = 'org.webkit:android-jsc:+'

/**
 * Whether to enable the Hermes VM.
 *
 * This should be set on project.ext.react and that value will be read here. If it is not set
 * on project.ext.react, JavaScript will not be compiled to Hermes Bytecode
 * and the benefits of using Hermes will therefore be sharply reduced.
 */
def enableHermes = project.ext.react.get("enableHermes", false);

/**
 * Architectures to build native code for.
 */
def reactNativeArchitectures() {
  def value = project.getProperties().get("reactNativeArchitectures")
  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
}

android {
  ndkVersion rootProject.ext.ndkVersion

//  compileSdkVersion rootProject.ext.compileSdkVersion
  compileSdkVersion 32

  defaultConfig {
    applicationId 'your.project'
    minSdkVersion rootProject.ext.minSdkVersion
    targetSdkVersion rootProject.ext.targetSdkVersion

    versionCode 1
    versionName "1.0"
    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()

    if (isNewArchitectureEnabled()) {
      // We configure the CMake build only if you decide to opt-in for the New Architecture.
      externalNativeBuild {
        cmake {
          arguments "-DPROJECT_BUILD_DIR=$buildDir",
            "-DREACT_ANDROID_DIR=$rootDir/../node_modules/react-native/ReactAndroid",
            "-DREACT_ANDROID_BUILD_DIR=$rootDir/../node_modules/react-native/ReactAndroid/build",
            "-DNODE_MODULES_DIR=$rootDir/../node_modules",
            "-DANDROID_STL=c++_shared"
        }
      }
      if (!enableSeparateBuildPerCPUArchitecture) {
        ndk {
          abiFilters(*reactNativeArchitectures())
        }
      }
    }
  }

  if (isNewArchitectureEnabled()) {
    // We configure the NDK build only if you decide to opt-in for the New Architecture.
    externalNativeBuild {
      cmake {
        path "$projectDir/src/main/jni/CMakeLists.txt"
      }
    }
    def reactAndroidProjectDir = project(':ReactAndroid').projectDir
    def packageReactNdkDebugLibs = tasks.register("packageReactNdkDebugLibs", Copy) {
      dependsOn(":ReactAndroid:packageReactNdkDebugLibsForBuck")
      from("$reactAndroidProjectDir/src/main/jni/prebuilt/lib")
      into("$buildDir/react-ndk/exported")
    }
    def packageReactNdkReleaseLibs = tasks.register("packageReactNdkReleaseLibs", Copy) {
      dependsOn(":ReactAndroid:packageReactNdkReleaseLibsForBuck")
      from("$reactAndroidProjectDir/src/main/jni/prebuilt/lib")
      into("$buildDir/react-ndk/exported")
    }
    afterEvaluate {
      // If you wish to add a custom TurboModule or component locally,
      // you should uncomment this line.
      // preBuild.dependsOn("generateCodegenArtifactsFromSchema")
      preDebugBuild.dependsOn(packageReactNdkDebugLibs)
      preReleaseBuild.dependsOn(packageReactNdkReleaseLibs)

      // Due to a bug inside AGP, we have to explicitly set a dependency
      // between configureCMakeDebug* tasks and the preBuild tasks.
      // This can be removed once this is solved: https://issuetracker.google.com/issues/207403732
      configureCMakeRelWithDebInfo.dependsOn(preReleaseBuild)
      configureCMakeDebug.dependsOn(preDebugBuild)
      reactNativeArchitectures().each { architecture ->
        tasks.findByName("configureCMakeDebug[${architecture}]")?.configure {
          dependsOn("preDebugBuild")
        }
        tasks.findByName("configureCMakeRelWithDebInfo[${architecture}]")?.configure {
          dependsOn("preReleaseBuild")
        }
      }
    }
  }

  splits {
    abi {
      reset()
      enable enableSeparateBuildPerCPUArchitecture
      universalApk false  // If true, also generate a universal APK
      include(*reactNativeArchitectures())
    }
  }
  signingConfigs {
    release {
      storeFile file('new.jks')
      storePassword '123456'
      keyAlias 'key0'
      keyPassword '123456'

      v1SigningEnabled true
      v2SigningEnabled true
    }
    debug {
      storeFile file('new.jks')
      storePassword '123456'
      keyAlias 'key0'
      keyPassword '123456'

      v1SigningEnabled true
      v2SigningEnabled true
    }
  }

  buildTypes {
    debug {
      signingConfig signingConfigs.debug
    }
    release {
      // Caution! In production, you need to generate your own keystore file.
      // see https://reactnative.dev/docs/signed-apk-android.
      signingConfig signingConfigs.debug
      minifyEnabled enableProguardInReleaseBuilds
      proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
    }
  }

  // applicationVariants are e.g. debug, release
  applicationVariants.all { variant ->
    variant.outputs.each { output ->
      // For each separate APK per architecture, set a unique version code as described here:
      // https://developer.android.com/studio/build/configure-apk-splits.html
      // Example: versionCode 1 will generate 1001 for armeabi-v7a, 1002 for x86, etc.
      def versionCodes = ["armeabi-v7a": 1, "x86": 2, "arm64-v8a": 3, "x86_64": 4]
      def abi = output.getFilter(OutputFile.ABI)
      if (abi != null) {  // null for the universal-debug, universal-release variants
        output.versionCodeOverride =
          defaultConfig.versionCode * 1000 + versionCodes.get(abi)
      }

    }
  }
}

dependencies {
  implementation fileTree(dir: "libs", include: ["*.jar"])

  //noinspection GradleDynamicVersion
  implementation "com.facebook.react:react-native:+"  // From node_modules

  implementation "androidx.swiperefreshlayout:swiperefreshlayout:1.0.0"
  implementation 'androidx.appcompat:appcompat:1.5.1'
  implementation 'com.google.android.material:material:1.4.0'
  implementation 'androidx.constraintlayout:constraintlayout:2.0.4'

  debugImplementation("com.facebook.flipper:flipper:${FLIPPER_VERSION}") {
    exclude group: 'com.facebook.fbjni'
  }

  debugImplementation("com.facebook.flipper:flipper-network-plugin:${FLIPPER_VERSION}") {
    exclude group: 'com.facebook.flipper'
    exclude group: 'com.squareup.okhttp3', module: 'okhttp'
  }

  debugImplementation("com.facebook.flipper:flipper-fresco-plugin:${FLIPPER_VERSION}") {
    exclude group: 'com.facebook.flipper'
  }

  if (enableHermes) {
    //noinspection GradleDynamicVersion
    implementation("com.facebook.react:hermes-engine:+") { // From node_modules
      exclude group: 'com.facebook.fbjni'
    }
  } else {
    implementation jscFlavor
  }
}

if (isNewArchitectureEnabled()) {
  // If new architecture is enabled, we let you build RN from source
  // Otherwise we fallback to a prebuilt .aar bundled in the NPM package.
  // This will be applied to all the imported transtitive dependency.
  configurations.all {
    resolutionStrategy.dependencySubstitution {
      substitute(module("com.facebook.react:react-native"))
        .using(project(":ReactAndroid"))
        .because("On New Architecture we're building React Native from source")
      substitute(module("com.facebook.react:hermes-engine"))
        .using(project(":ReactAndroid:hermes-engine"))
        .because("On New Architecture we're building Hermes from source")
    }
  }
}

// Run this once to be able to run the application with BUCK
// puts all compile dependencies into folder libs for BUCK to use
task copyDownloadableDepsToLibs(type: Copy) {
  from configurations.implementation
  into 'libs'
}

apply from: file("../../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesAppBuildGradle(project)

def isNewArchitectureEnabled() {
  // To opt-in for the New Architecture, you can either:
  // - Set `newArchEnabled` to true inside the `gradle.properties` file
  // - Invoke gradle with `-newArchEnabled=true`
  // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
  return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
}