// Gradle build config for Godot Engine's Android port.
//
// Do not remove/modify comments ending with BEGIN/END, they are used to inject
// addon-specific configuration.
buildscript {
    apply from: 'config.gradle'

    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
        maven { url "https://plugins.gradle.org/m2/" }
//CHUNK_BUILDSCRIPT_REPOSITORIES_BEGIN
//CHUNK_BUILDSCRIPT_REPOSITORIES_END
    }
    dependencies {
        classpath "com.android.tools.build:gradle:$versions.androidGradlePlugin"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$versions.kotlinVersion"
//CHUNK_BUILDSCRIPT_DEPENDENCIES_BEGIN
//CHUNK_BUILDSCRIPT_DEPENDENCIES_END
    }
}

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
}

apply from: 'config.gradle'

allprojects {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
        maven { url "https://plugins.gradle.org/m2/" }
//CHUNK_ALLPROJECTS_REPOSITORIES_BEGIN
//CHUNK_ALLPROJECTS_REPOSITORIES_END

        // Godot user plugins custom maven repos
        String[] mavenRepos = getGodotPluginsMavenRepos()
        if (mavenRepos != null && mavenRepos.size() > 0) {
            for (String repoUrl : mavenRepos) {
                maven {
                    url repoUrl
                }
            }
        }
    }
}

configurations {
    // Initializes a placeholder for the devImplementation dependency configuration.
    devImplementation {}
}

dependencies {
    implementation "androidx.fragment:fragment:$versions.fragmentVersion"

    if (rootProject.findProject(":lib")) {
        implementation project(":lib")
    } else if (rootProject.findProject(":godot:lib")) {
        implementation project(":godot:lib")
    } else {
        // Custom build mode. In this scenario this project is the only one around and the Godot
        // library is available through the pre-generated godot-lib.*.aar android archive files.
        debugImplementation fileTree(dir: 'libs/debug', include: ['*.jar', '*.aar'])
        devImplementation fileTree(dir: 'libs/dev', include: ['*.jar', '*.aar'])
        releaseImplementation fileTree(dir: 'libs/release', include: ['*.jar', '*.aar'])
    }

    // Godot user plugins remote dependencies
    String[] remoteDeps = getGodotPluginsRemoteBinaries()
    if (remoteDeps != null && remoteDeps.size() > 0) {
        for (String dep : remoteDeps) {
            implementation dep
        }
    }

    // Godot user plugins local dependencies
    String[] pluginsBinaries = getGodotPluginsLocalBinaries()
    if (pluginsBinaries != null && pluginsBinaries.size() > 0) {
        implementation files(pluginsBinaries)
    }

//CHUNK_DEPENDENCIES_BEGIN
//CHUNK_DEPENDENCIES_END
}

android {
    compileSdkVersion versions.compileSdk
    buildToolsVersion versions.buildTools
    ndkVersion versions.ndkVersion

    compileOptions {
        sourceCompatibility versions.javaVersion
        targetCompatibility versions.javaVersion
    }

    kotlinOptions {
        jvmTarget = versions.javaVersion
    }

    assetPacks = [":assetPacks:installTime"]

    namespace = 'com.godot.game'

    defaultConfig {
        // The default ignore pattern for the 'assets' directory includes hidden files and directories which are used by Godot projects.
        aaptOptions {
            ignoreAssetsPattern "!.svn:!.git:!.gitignore:!.ds_store:!*.scc:<dir>_*:!CVS:!thumbs.db:!picasa.ini:!*~"
        }

        ndk {
            String[] export_abi_list = getExportEnabledABIs()
            abiFilters export_abi_list
        }

        manifestPlaceholders = [godotEditorVersion: getGodotEditorVersion()]

        // Feel free to modify the application id to your own.
        applicationId getExportPackageName()
        versionCode getExportVersionCode()
        versionName getExportVersionName()
        minSdkVersion getExportMinSdkVersion()
        targetSdkVersion getExportTargetSdkVersion()

        missingDimensionStrategy 'products', 'template'
//CHUNK_ANDROID_DEFAULTCONFIG_BEGIN
//CHUNK_ANDROID_DEFAULTCONFIG_END
    }

    lintOptions {
        abortOnError false
        disable 'MissingTranslation', 'UnusedResources'
    }

    ndkVersion versions.ndkVersion

    packagingOptions {
        exclude 'META-INF/LICENSE'
        exclude 'META-INF/NOTICE'

        // 'doNotStrip' is enabled for development within Android Studio
        if (shouldNotStrip()) {
            doNotStrip '**/*.so'
        }
    }

    signingConfigs {
        debug {
            if (hasCustomDebugKeystore()) {
                storeFile new File(getDebugKeystoreFile())
                storePassword getDebugKeystorePassword()
                keyAlias getDebugKeyAlias()
                keyPassword getDebugKeystorePassword()
            }
        }

        release {
            File keystoreFile = new File(getReleaseKeystoreFile())
            if (keystoreFile.isFile()) {
                storeFile keystoreFile
                storePassword getReleaseKeystorePassword()
                keyAlias getReleaseKeyAlias()
                keyPassword getReleaseKeystorePassword()
            }
        }
    }

    buildTypes {

        debug {
            // Signing and zip-aligning are skipped for prebuilt builds, but
            // performed for custom builds.
            zipAlignEnabled shouldZipAlign()
            if (shouldSign()) {
                signingConfig signingConfigs.debug
            } else {
                signingConfig null
            }
        }

        dev {
            initWith debug
            // Signing and zip-aligning are skipped for prebuilt builds, but
            // performed for custom builds.
            zipAlignEnabled shouldZipAlign()
            if (shouldSign()) {
                signingConfig signingConfigs.debug
            } else {
                signingConfig null
            }
        }

        release {
            // Signing and zip-aligning are skipped for prebuilt builds, but
            // performed for custom builds.
            zipAlignEnabled shouldZipAlign()
            if (shouldSign()) {
                signingConfig signingConfigs.release
            } else {
                signingConfig null
            }
        }
    }

    sourceSets {
        main {
            manifest.srcFile 'AndroidManifest.xml'
            java.srcDirs = [
                'src'
//DIR_SRC_BEGIN
//DIR_SRC_END
            ]
            res.srcDirs = [
                'res'
//DIR_RES_BEGIN
//DIR_RES_END
            ]
            aidl.srcDirs = [
                'aidl'
//DIR_AIDL_BEGIN
//DIR_AIDL_END
            ]
            assets.srcDirs = [
                'assets'
//DIR_ASSETS_BEGIN
//DIR_ASSETS_END
            ]
        }
        debug.jniLibs.srcDirs = [
            'libs/debug'
//DIR_JNI_DEBUG_BEGIN
//DIR_JNI_DEBUG_END
        ]
        dev.jniLibs.srcDirs = [
            'libs/dev'
//DIR_JNI_DEV_BEGIN
//DIR_JNI_DEV_END
        ]
        release.jniLibs.srcDirs = [
            'libs/release'
//DIR_JNI_RELEASE_BEGIN
//DIR_JNI_RELEASE_END
        ]
    }

    applicationVariants.all { variant ->
        variant.outputs.all { output ->
            output.outputFileName = "android_${variant.name}.apk"
        }
    }
}

task copyAndRenameDebugApk(type: Copy) {
    from "$buildDir/outputs/apk/debug/android_debug.apk"
    into getExportPath()
    rename "android_debug.apk", getExportFilename()
}

task copyAndRenameDevApk(type: Copy) {
    from "$buildDir/outputs/apk/dev/android_dev.apk"
    into getExportPath()
    rename "android_dev.apk", getExportFilename()
}

task copyAndRenameReleaseApk(type: Copy) {
    from "$buildDir/outputs/apk/release/android_release.apk"
    into getExportPath()
    rename "android_release.apk", getExportFilename()
}

task copyAndRenameDebugAab(type: Copy) {
    from "$buildDir/outputs/bundle/debug/build-debug.aab"
    into getExportPath()
    rename "build-debug.aab", getExportFilename()
}

task copyAndRenameDevAab(type: Copy) {
    from "$buildDir/outputs/bundle/dev/build-dev.aab"
    into getExportPath()
    rename "build-dev.aab", getExportFilename()
}

task copyAndRenameReleaseAab(type: Copy) {
    from "$buildDir/outputs/bundle/release/build-release.aab"
    into getExportPath()
    rename "build-release.aab", getExportFilename()
}

/**
 * Used to validate the version of the Java SDK used for the Godot gradle builds.
 */
task validateJavaVersion {
    if (JavaVersion.current() != versions.javaVersion) {
        throw new GradleException("Invalid Java version ${JavaVersion.current()}. Version ${versions.javaVersion} is the required Java version for Godot gradle builds.")
    }
}

/*
When they're scheduled to run, the copy*AARToAppModule tasks generate dependencies for the 'app'
module, so we're ensuring the ':app:preBuild' task is set to run after those tasks.
 */
if (rootProject.tasks.findByPath("copyDebugAARToAppModule") != null) {
    preBuild.mustRunAfter(rootProject.tasks.named("copyDebugAARToAppModule"))
}
if (rootProject.tasks.findByPath("copyDevAARToAppModule") != null) {
    preBuild.mustRunAfter(rootProject.tasks.named("copyDevAARToAppModule"))
}
if (rootProject.tasks.findByPath("copyReleaseAARToAppModule") != null) {
    preBuild.mustRunAfter(rootProject.tasks.named("copyReleaseAARToAppModule"))
}

//CHUNK_GLOBAL_BEGIN
//CHUNK_GLOBAL_END