Untitled

package com.martitech.convention.plugin

import com.android.build.api.dsl.ApplicationBuildType
import com.android.build.gradle.internal.dsl.BaseAppModuleExtension
import com.martitech.config.AppConfig
import com.martitech.config.BuildType
import org.gradle.api.NamedDomainObjectContainer
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.kotlin.dsl.configure
import org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension
import java.util.Properties

class AndroidApplicationConventionPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            with(pluginManager) {
                apply("com.android.application")
                apply("org.jetbrains.kotlin.android")
            }

            extensions.configure<BaseAppModuleExtension> {
                compileSdk = AppConfig.COMPILE_SDK
                defaultConfig.apply {
                    applicationId = AppConfig.APPLICATION_ID
                    minSdk = AppConfig.MIN_SDK
                    targetSdk = AppConfig.TARGET_SDK
                    versionCode = AppConfig.VERSION_CODE
                    versionName = AppConfig.VERSION_NAME
                    multiDexEnabled = true
                    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
                }

                compileOptions {
                    sourceCompatibility = AppConfig.JAVA_VERSION
                    targetCompatibility = AppConfig.JAVA_VERSION
                }

                buildFeatures {
                    viewBinding = true
                    buildConfig = true
                }

                buildTypes {
                    configureBuildTypes(this, project)
                }
            }

            extensions.configure<KotlinAndroidProjectExtension> {
                jvmToolchain(AppConfig.JAVA_VERSION.toString().substringAfter("VERSION_").toInt())
            }
        }
    }

    private fun configureBuildTypes(
        buildTypes: NamedDomainObjectContainer<ApplicationBuildType>,
        project: Project
    ) {
        BuildType.values().forEach { buildType ->
            val buildTypeName = buildType.name.lowercase()
            buildTypes.maybeCreate(buildTypeName).apply {
                configureBuildType(buildType, project)
            }
        }
    }

    private fun ApplicationBuildType.configureBuildType(
        buildType: BuildType,
        project: Project
    ) {
        isDebuggable = buildType.isDebuggable
        isMinifyEnabled = buildType.isMinifyEnabled
        isShrinkResources = buildType.isShrinkResources
        proguardFiles(
            project.layout.buildDirectory.file("proguard-android-optimize.txt").get().asFile,
            "proguard-rules.pro"
        )
        manifestPlaceholders["appName"] = buildType.appName
        versionNameSuffix = buildType.versionNameIdSuffix
        applicationIdSuffix = buildType.applicationIdSuffix

        val amplitudeApiKey = project.getPropertyOrDefault("AMPLITUDE_API_KEY_${buildType.name.uppercase()}", "")
        val newrelicApiKey = project.getPropertyOrDefault("NEWRELIC_API_KEY_${buildType.name.uppercase()}", "")
        val baseUrl = project.getPropertyOrDefault("BASE_URL_${buildType.name.uppercase()}", "")
        val metaCdn = project.getPropertyOrDefault("META_CDN_${buildType.name.uppercase()}", "")
        val apiVersion = project.getPropertyOrDefault("API_VERSION_${buildType.name.uppercase()}", "v1")

        buildConfigField("String", "AMPLITUDE_API_KEY", "\"$amplitudeApiKey\"")
        buildConfigField("String", "NEWRELIC_API_KEY", "\"$newrelicApiKey\"")
        buildConfigField("String", "BASE_URL", "\"$baseUrl\"")
        buildConfigField("String", "META_CDN", "\"$metaCdn\"")
        buildConfigField("String", "API_VERSION", "\"$apiVersion\"")
    }

    private fun Project.getPropertyOrDefault(propertyName: String, defaultValue: String): String {
        val propFile = rootProject.file("local.properties")
        if (propFile.exists()) {
            val props = Properties()
            propFile.inputStream().use { props.load(it) }
            val value = props.getProperty(propertyName)
            if (!value.isNullOrEmpty()) return value
        }
        val envValue = System.getenv(propertyName)
        if (!envValue.isNullOrEmpty()) return envValue
        val gradleValue = project.findProperty(propertyName) as? String
        if (!gradleValue.isNullOrEmpty()) return gradleValue
        return defaultValue
    }
}