/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.build.gradle.internal

import com.android.build.api.attributes.BuildTypeAttr.Companion.ATTRIBUTE
import com.android.build.api.attributes.ProductFlavorAttr
import com.android.build.api.component.impl.ComponentPropertiesImpl
import com.android.build.api.component.impl.TestComponentImpl
import com.android.build.api.component.impl.TestComponentPropertiesImpl
import com.android.build.api.variant.impl.VariantImpl
import com.android.build.api.variant.impl.VariantPropertiesImpl
import com.android.build.gradle.internal.dependency.AarResourcesCompilerTransform
import com.android.build.gradle.internal.dependency.AarToClassTransform
import com.android.build.gradle.internal.dependency.AarTransform
import com.android.build.gradle.internal.dependency.AlternateCompatibilityRule
import com.android.build.gradle.internal.dependency.AlternateDisambiguationRule
import com.android.build.gradle.internal.dependency.AndroidXDependencySubstitution.replaceOldSupportLibraries
import com.android.build.gradle.internal.dependency.ClassesDirToClassesTransform
import com.android.build.gradle.internal.dependency.EnumerateClassesTransform
import com.android.build.gradle.internal.dependency.ExtractAarTransform
import com.android.build.gradle.internal.dependency.ExtractProGuardRulesTransform
import com.android.build.gradle.internal.dependency.FilterShrinkerRulesTransform
import com.android.build.gradle.internal.dependency.GenericTransformParameters
import com.android.build.gradle.internal.dependency.IdentityTransform
import com.android.build.gradle.internal.dependency.JetifyTransform
import com.android.build.gradle.internal.dependency.LibraryDependencySourcesTransform
import com.android.build.gradle.internal.dependency.LibrarySymbolTableTransform
import com.android.build.gradle.internal.dependency.MockableJarTransform
import com.android.build.gradle.internal.dependency.ModelArtifactCompatibilityRule.Companion.setUp
import com.android.build.gradle.internal.dependency.PlatformAttrTransform
import com.android.build.gradle.internal.dependency.VersionedCodeShrinker.Companion.of
import com.android.build.gradle.internal.dependency.getDexingArtifactConfigurations
import com.android.build.gradle.internal.dependency.registerDexingOutputSplitTransform
import com.android.build.gradle.internal.dsl.BaseFlavor
import com.android.build.gradle.internal.dsl.BuildType
import com.android.build.gradle.internal.dsl.DefaultConfig
import com.android.build.gradle.internal.dsl.ProductFlavor
import com.android.build.gradle.internal.dsl.SigningConfig
import com.android.build.gradle.internal.publishing.AndroidArtifacts
import com.android.build.gradle.internal.res.getAapt2FromMavenAndVersion
import com.android.build.gradle.internal.res.namespaced.AutoNamespacePreProcessTransform
import com.android.build.gradle.internal.res.namespaced.AutoNamespaceTransform
import com.android.build.gradle.internal.res.namespaced.init
import com.android.build.gradle.internal.scope.GlobalScope
import com.android.build.gradle.internal.services.getBuildService
import com.android.build.gradle.internal.utils.getDesugarLibConfig
import com.android.build.gradle.internal.utils.setDisallowChanges
import com.android.build.gradle.internal.variant.ComponentInfo
import com.android.build.gradle.internal.variant.VariantInputModel
import com.android.build.gradle.options.BooleanOption
import com.android.build.gradle.options.StringOption
import com.android.build.gradle.options.SyncOptions
import com.android.builder.model.CodeShrinker
import com.google.common.base.Strings
import com.google.common.collect.Maps
import org.gradle.api.Action
import org.gradle.api.ActionConfiguration
import org.gradle.api.Project
import org.gradle.api.artifacts.Configuration
import org.gradle.api.artifacts.dsl.DependencyHandler
import org.gradle.api.artifacts.transform.TransformSpec
import org.gradle.api.artifacts.type.ArtifactTypeDefinition
import org.gradle.api.attributes.Attribute
import org.gradle.api.attributes.AttributesSchema
import org.gradle.api.attributes.Usage
import org.gradle.api.internal.artifacts.ArtifactAttributes

/**
 * configures the dependencies for a set of variant inputs.
 */
class DependencyConfigurator(
    private val project: Project,
    private val projectName: String,
    private val globalScope: GlobalScope,
    private val variantInputModel: VariantInputModel<DefaultConfig, BuildType, ProductFlavor, SigningConfig>
) {

    fun configureDependencySubstitutions(): DependencyConfigurator {
        // If Jetifier is enabled, replace old support libraries with AndroidX.
        if (globalScope.projectOptions[BooleanOption.ENABLE_JETIFIER]) {
            replaceOldSupportLibraries(project)
        }
        return this
    }

    fun configureGeneralTransforms(): DependencyConfigurator {
        val dependencies: DependencyHandler = project.dependencies

        // The aars/jars may need to be processed (e.g., jetified to AndroidX) before they can be
        // used
        // Arguments passed to an ArtifactTransform must not be null
        val jetifierSkipIfPossible =
            globalScope.projectOptions[BooleanOption.JETIFIER_SKIP_IF_POSSIBLE]
        val jetifierBlackList = Strings.nullToEmpty(
            globalScope.projectOptions[StringOption.JETIFIER_BLACKLIST]
        )
        val autoNamespaceDependencies =
            globalScope.extension.aaptOptions.namespaced &&
                    globalScope.projectOptions[BooleanOption.CONVERT_NON_NAMESPACED_DEPENDENCIES]
        val jetifiedAarOutputType = if (autoNamespaceDependencies) {
            AndroidArtifacts.ArtifactType.MAYBE_NON_NAMESPACED_PROCESSED_AAR
        } else {
            AndroidArtifacts.ArtifactType.PROCESSED_AAR
        }
        if (globalScope.projectOptions[BooleanOption.ENABLE_JETIFIER]) {
            dependencies.registerTransform(
                JetifyTransform::class.java
            ) { spec: TransformSpec<JetifyTransform.Parameters> ->
                spec.parameters.projectName.set(projectName)
                spec.parameters.skipIfPossible.set(jetifierSkipIfPossible)
                spec.parameters.blackListOption.set(jetifierBlackList)
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.AAR.type
                )
                spec.to.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    jetifiedAarOutputType.type
                )
            }
            dependencies.registerTransform(
                JetifyTransform::class.java
            ) { spec: TransformSpec<JetifyTransform.Parameters> ->
                spec.parameters.projectName.set(projectName)
                spec.parameters.skipIfPossible.set(jetifierSkipIfPossible)
                spec.parameters.blackListOption.set(jetifierBlackList)
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.JAR.type
                )
                spec.to.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.PROCESSED_JAR.type
                )
            }
        } else {
            dependencies.registerTransform(
                IdentityTransform::class.java
            ) { spec: TransformSpec<GenericTransformParameters> ->
                spec.parameters.projectName.set(projectName)
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.AAR.type
                )
                spec.to.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    jetifiedAarOutputType.type
                )
            }
            dependencies.registerTransform(
                IdentityTransform::class.java
            ) { spec: TransformSpec<GenericTransformParameters> ->
                spec.parameters.projectName.set(projectName)
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.JAR.type
                )
                spec.to.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.PROCESSED_JAR.type
                )
            }
        }
        dependencies.registerTransform(
            ExtractAarTransform::class.java
        ) { spec: TransformSpec<GenericTransformParameters> ->
            spec.parameters.projectName.set(projectName)
            spec.from.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.PROCESSED_AAR.type
            )
            spec.to.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.EXPLODED_AAR.type
            )
        }
        dependencies.registerTransform(
            MockableJarTransform::class.java
        ) { spec: TransformSpec<MockableJarTransform.Parameters> ->
            // Query for JAR instead of PROCESSED_JAR as android.jar doesn't need processing
            spec.parameters.projectName.set(projectName)
            spec.parameters.returnDefaultValues.set(true)
            spec.from.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.JAR.type
            )
            spec.from.attribute(
                AndroidArtifacts.MOCKABLE_JAR_RETURN_DEFAULT_VALUES,
                true
            )
            spec.to.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.TYPE_MOCKABLE_JAR
            )
            spec.to.attribute(
                AndroidArtifacts.MOCKABLE_JAR_RETURN_DEFAULT_VALUES,
                true
            )
        }
        dependencies.registerTransform(
            MockableJarTransform::class.java
        ) { spec: TransformSpec<MockableJarTransform.Parameters> ->
            // Query for JAR instead of PROCESSED_JAR as android.jar doesn't need processing
            spec.parameters.projectName.set(projectName)
            spec.parameters.returnDefaultValues.set(false)
            spec.from.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.JAR.type
            )
            spec.from.attribute(
                AndroidArtifacts.MOCKABLE_JAR_RETURN_DEFAULT_VALUES,
                false
            )
            spec.to.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.TYPE_MOCKABLE_JAR
            )
            spec.to.attribute(
                AndroidArtifacts.MOCKABLE_JAR_RETURN_DEFAULT_VALUES,
                false
            )
        }
        // transform to extract attr info from android.jar
        dependencies.registerTransform(
            PlatformAttrTransform::class.java
        ) { spec: TransformSpec<GenericTransformParameters> ->
            spec.parameters.projectName.set(projectName)
            // Query for JAR instead of PROCESSED_JAR as android.jar doesn't need processing
            spec.from.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.JAR.type
            )
            spec.to.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.TYPE_PLATFORM_ATTR
            )
        }
        val sharedLibSupport = globalScope
            .projectOptions[BooleanOption.CONSUME_DEPENDENCIES_AS_SHARED_LIBRARIES]

        for (transformTarget in AarTransform.getTransformTargets()) {
            dependencies.registerTransform(
                AarTransform::class.java
            ) { spec: TransformSpec<AarTransform.Parameters> ->
                spec.parameters.projectName.set(projectName)
                spec.parameters.targetType.set(transformTarget)
                spec.parameters.sharedLibSupport.set(sharedLibSupport)
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.EXPLODED_AAR.type
                )
                spec.to.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    transformTarget.type
                )
            }
        }
        if (globalScope.projectOptions[BooleanOption.PRECOMPILE_DEPENDENCIES_RESOURCES]) {
            dependencies.registerTransform(
                AarResourcesCompilerTransform::class.java
            ) { reg: TransformSpec<AarResourcesCompilerTransform.Parameters> ->
                reg.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.EXPLODED_AAR.type
                )
                reg.to
                    .attribute(
                        ArtifactAttributes.ARTIFACT_FORMAT,
                        AndroidArtifacts.ArtifactType.COMPILED_DEPENDENCIES_RESOURCES.type
                    )
                reg.parameters { params: AarResourcesCompilerTransform.Parameters ->
                    val (first, second) = getAapt2FromMavenAndVersion(
                        globalScope
                    )
                    params.aapt2FromMaven
                        .from(first)
                    params.aapt2Version
                        .set(second)
                    params.errorFormatMode
                        .set(
                            SyncOptions.getErrorFormatMode(
                                globalScope.projectOptions
                            )
                        )
                    params.aapt2DaemonBuildService
                        .setDisallowChanges(getBuildService(project.gradle.sharedServices))
                }
            }
        }
        // API Jar: Produce a single API jar that can also contain the library R class from the AAR
        val apiUsage: Usage = project.objects.named(Usage::class.java, Usage.JAVA_API)

        dependencies.registerTransform(
            AarToClassTransform::class.java
        ) { reg: TransformSpec<AarToClassTransform.Params> ->
            reg.from.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.PROCESSED_AAR.type
            )
            reg.from.attribute(
                Usage.USAGE_ATTRIBUTE,
                apiUsage
            )
            reg.to.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.CLASSES_JAR.type
            )
            reg.to.attribute(
                Usage.USAGE_ATTRIBUTE,
                apiUsage
            )
            reg.parameters { params: AarToClassTransform.Params ->
                params.forCompileUse.set(true)
                params.generateRClassJar
                    .set(
                        globalScope.projectOptions.get(
                            BooleanOption.COMPILE_CLASSPATH_LIBRARY_R_CLASSES
                        )
                    )
            }
        }
        // Produce a single runtime jar from the AAR.
        val runtimeUsage: Usage = project.objects.named(Usage::class.java, Usage.JAVA_RUNTIME)

        dependencies.registerTransform(
            AarToClassTransform::class.java
        ) { reg: TransformSpec<AarToClassTransform.Params> ->
            reg.from.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.PROCESSED_AAR.type
            )
            reg.from.attribute(
                Usage.USAGE_ATTRIBUTE,
                runtimeUsage
            )
            reg.to.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.CLASSES_JAR.type
            )
            reg.to.attribute(
                Usage.USAGE_ATTRIBUTE,
                runtimeUsage
            )
            reg.parameters { params: AarToClassTransform.Params ->
                params.forCompileUse.set(false)

                params.generateRClassJar.set(false)
            }
        }
        if (globalScope.projectOptions[BooleanOption.ENABLE_PROGUARD_RULES_EXTRACTION]) {
            dependencies.registerTransform(
                ExtractProGuardRulesTransform::class.java
            ) { spec: TransformSpec<GenericTransformParameters> ->
                spec.parameters.projectName.set(projectName)
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.PROCESSED_JAR.type
                )
                spec.to
                    .attribute(
                        ArtifactAttributes.ARTIFACT_FORMAT,
                        AndroidArtifacts.ArtifactType.UNFILTERED_PROGUARD_RULES.type
                    )
            }
        }
        dependencies.registerTransform(
            LibrarySymbolTableTransform::class.java
        ) { spec: TransformSpec<GenericTransformParameters> ->
            spec.parameters.projectName.set(projectName)
            spec.from.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.EXPLODED_AAR.type
            )
            spec.to
                .attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.SYMBOL_LIST_WITH_PACKAGE_NAME.type
                )
        }
        if (autoNamespaceDependencies) {
            dependencies.registerTransform(AutoNamespacePreProcessTransform::class.java) { spec ->
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.MAYBE_NON_NAMESPACED_PROCESSED_AAR.type
                )
                spec.to.attribute(
                        ArtifactAttributes.ARTIFACT_FORMAT,
                        AndroidArtifacts.ArtifactType.PREPROCESSED_AAR_FOR_AUTO_NAMESPACE.type
                )
                spec.parameters.init(globalScope)
            }
            dependencies.registerTransform(AutoNamespacePreProcessTransform::class.java) { spec ->
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.JAR.type
                )
                spec.to.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.PREPROCESSED_AAR_FOR_AUTO_NAMESPACE.type
                )
                spec.parameters.init(globalScope)
            }

            dependencies.registerTransform(AutoNamespaceTransform::class.java) { spec ->
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.PREPROCESSED_AAR_FOR_AUTO_NAMESPACE.type
                )
                spec.to.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.PROCESSED_AAR.type
                )
                spec.parameters.init(globalScope)
            }

        }
        // Transform to go from external jars to CLASSES and JAVA_RES artifacts. This returns the
        // same exact file but with different types, since a jar file can contain both.
        for (classesOrResources in arrayOf(
            AndroidArtifacts.ArtifactType.CLASSES_JAR.type,
            AndroidArtifacts.ArtifactType.JAVA_RES.type
        )) {
            dependencies.registerTransform(IdentityTransform::class.java) { spec: TransformSpec<GenericTransformParameters?> ->
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.PROCESSED_JAR.type
                )
                spec.to.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    classesOrResources
                )
            }
        }
        // The Kotlin Kapt plugin should query for PROCESSED_JAR, but it is currently querying for
        // JAR, so we need to have the workaround below to make it get PROCESSED_JAR. See
        // http://issuetracker.google.com/111009645.
        project.configurations.all { configuration: Configuration ->
            if (configuration.name.startsWith("kapt")) {
                configuration
                    .attributes
                    .attribute(
                        ArtifactAttributes.ARTIFACT_FORMAT,
                        AndroidArtifacts.ArtifactType.PROCESSED_JAR.type
                    )
            }
        }

        // When consuming classes from Android libraries, there are 2 transforms:
        //     1. `android-classes-directory` -> `android-classes`
        //     2. `android-classes-jar` -> `android-classes`
        // Currently Gradle always takes transform flow #1, which is ideal for incremental dexing.
        // (We don't know why Gradle does that, but IncrementalDesugaringTest should catch it if
        // this behavior changes.)
        dependencies.registerTransform(
            ClassesDirToClassesTransform::class.java,
            Action { spec: TransformSpec<GenericTransformParameters?> ->
                spec.from
                    .attribute(
                        ArtifactAttributes.ARTIFACT_FORMAT,
                        AndroidArtifacts.ArtifactType.CLASSES_DIR.type
                    )
                spec.to.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.CLASSES.type
                )
            }
        )
        dependencies.registerTransform(
            IdentityTransform::class.java,
            Action { spec: TransformSpec<GenericTransformParameters?> ->
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.CLASSES_JAR.type
                )
                spec.to.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.CLASSES.type
                )
            }
        )
        dependencies.registerTransform(
                LibraryDependencySourcesTransform::class.java,
                Action { spec: TransformSpec<GenericTransformParameters> ->
                    spec.parameters.projectName.set(projectName)
                    spec.from.attribute(
                            ArtifactAttributes.ARTIFACT_FORMAT,
                            AndroidArtifacts.ArtifactType.EXPLODED_AAR.type
                    )
                    spec.to.attribute(
                            ArtifactAttributes.ARTIFACT_FORMAT,
                            AndroidArtifacts.ArtifactType.AAR_CLASS_LIST_AND_RES_SYMBOLS.type
                    )
                }
        )


        // When consuming classes from Java libraries, there are 2 transforms:
        //     1. `java-classes-directory` -> `android-classes`
        //     2. `jar` -> `processed-jar` -> `android-classes-jar` -> `android-classes`
        // Currently Gradle always takes transform flow #2, which is not ideal for incremental
        // dexing.
        // TODO(147137579): Configure Gradle to take transform flow #1.
        dependencies.registerTransform(IdentityTransform::class.java) { spec: TransformSpec<GenericTransformParameters?> ->
            spec.from
                .attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    ArtifactTypeDefinition.JVM_CLASS_DIRECTORY
                )
            spec.to.attribute(
                ArtifactAttributes.ARTIFACT_FORMAT,
                AndroidArtifacts.ArtifactType.CLASSES.type
            )
        }

        val schema = dependencies.attributesSchema
        // custom strategy for build-type and product-flavor.
        setBuildTypeStrategy(schema)
        setupFlavorStrategy(schema)
        setupModelStrategy(schema)

        return this
    }

    private fun setBuildTypeStrategy(schema: AttributesSchema) {
        // this is ugly but because the getter returns a very base class we have no choices.
        val dslBuildTypes = variantInputModel.buildTypes.values.map { it.buildType }

        if (dslBuildTypes.isEmpty()) {
            return
        }

        val alternateMap: MutableMap<String, List<String>> =
            Maps.newHashMap()
        for (buildType in dslBuildTypes) {
            if (!buildType.matchingFallbacks.isEmpty()) {
                alternateMap[buildType.name] = buildType.matchingFallbacks
            }
        }
        if (!alternateMap.isEmpty()) {
            val buildTypeStrategy =
                schema.attribute(
                    ATTRIBUTE
                )
            buildTypeStrategy
                .compatibilityRules
                .add(
                    AlternateCompatibilityRule.BuildTypeRule::class.java
                ) { config: ActionConfiguration ->
                    config.setParams(
                        alternateMap
                    )
                }
            buildTypeStrategy
                .disambiguationRules
                .add(
                    AlternateDisambiguationRule.BuildTypeRule::class.java
                ) { config: ActionConfiguration ->
                    config.setParams(
                        alternateMap
                    )
                }
        }
    }

    private fun setupFlavorStrategy(schema: AttributesSchema) {
        // this is ugly but because the getter returns a very base class we have no choices.
        val flavors = variantInputModel.productFlavors.values.map { it.productFlavor }

        // first loop through all the flavors and collect for each dimension, and each value, its
        // fallbacks
        // map of (dimension > (requested > fallbacks))
        val alternateMap: MutableMap<String, MutableMap<String, List<String>>> =
            Maps.newHashMap()
        for (flavor in flavors) {
            if (flavor.matchingFallbacks.isNotEmpty()) {
                val name = flavor.name
                val dimension = flavor.dimension!!
                val dimensionMap =
                    alternateMap.computeIfAbsent(
                        dimension
                    ) { s: String? -> Maps.newHashMap() }
                dimensionMap[name] = flavor.matchingFallbacks
            }
            handleMissingDimensions(alternateMap, flavor)
        }
        // also handle missing dimensions on the default config.
        handleMissingDimensions(alternateMap, variantInputModel.defaultConfigData.defaultConfig)
        // now that we know we have all the fallbacks for each dimensions, we can create the
        // rule instances.
        for ((key, value) in alternateMap) {
            addFlavorStrategy(schema, key, value)
        }
    }

    private fun setupModelStrategy(attributesSchema: AttributesSchema) {
        setUp(attributesSchema)
    }

    private fun handleMissingDimensions(
        alternateMap: MutableMap<String, MutableMap<String, List<String>>>,
        flavor: BaseFlavor
    ) {
        val missingStrategies = flavor.missingDimensionStrategies
        if (missingStrategies.isNotEmpty()) {
            for ((dimension, value) in missingStrategies) {
                val dimensionMap = alternateMap.computeIfAbsent(dimension) { Maps.newHashMap() }
                dimensionMap[value.requested] = value.fallbacks
            }
        }
    }

    /** Configure artifact transforms that require variant-specific attribute information.  */
    fun <VariantT: VariantImpl<VariantPropertiesT>, VariantPropertiesT: VariantPropertiesImpl> configureVariantTransforms(
        variants: List<ComponentInfo<VariantT, VariantPropertiesT>>,
        testComponents: List<ComponentInfo<TestComponentImpl<out TestComponentPropertiesImpl>, TestComponentPropertiesImpl>>
    ): DependencyConfigurator {
        val allComponents: List<ComponentPropertiesImpl> = (variants + testComponents).map { it.properties }

        val dependencies = project.dependencies
        if (globalScope.projectOptions[BooleanOption.ENABLE_DEXING_ARTIFACT_TRANSFORM]) {
            for (artifactConfiguration in getDexingArtifactConfigurations(
                allComponents
            )) {
                artifactConfiguration.registerTransform(
                    globalScope.project.name,
                    dependencies,
                    project.files(globalScope.bootClasspath),
                    getDesugarLibConfig(globalScope.project),
                    SyncOptions.getErrorFormatMode(globalScope.projectOptions),
                    globalScope.projectOptions.get(BooleanOption.ENABLE_INCREMENTAL_DEXING_TRANSFORM)
                )
            }
        }
        if (globalScope.projectOptions[BooleanOption.ENABLE_PROGUARD_RULES_EXTRACTION]) {
            val shrinkers: Set<CodeShrinker> = allComponents
                .asSequence()
                .map { it.variantScope.codeShrinker }
                .filterNotNull()
                .toSet()
            for (shrinker in shrinkers) {
                dependencies.registerTransform(
                    FilterShrinkerRulesTransform::class.java
                ) { reg: TransformSpec<FilterShrinkerRulesTransform.Parameters> ->
                    reg.from
                        .attribute(
                            ArtifactAttributes.ARTIFACT_FORMAT,
                            AndroidArtifacts.ArtifactType.UNFILTERED_PROGUARD_RULES.type
                        )
                    reg.to
                        .attribute(
                            ArtifactAttributes.ARTIFACT_FORMAT,
                            AndroidArtifacts.ArtifactType.FILTERED_PROGUARD_RULES.type
                        )
                    reg.from.attribute(
                        VariantManager.SHRINKER_ATTR,
                        shrinker.toString()
                    )
                    reg.to.attribute(
                        VariantManager.SHRINKER_ATTR,
                        shrinker.toString()
                    )
                    reg.parameters { params: FilterShrinkerRulesTransform.Parameters ->
                        params.shrinker
                            .set(of(shrinker))
                        params.projectName.set(project.name)
                    }
                }
            }
        }

        if (globalScope.projectOptions[BooleanOption.ENABLE_DUPLICATE_CLASSES_CHECK]) {
            dependencies.registerTransform(
                EnumerateClassesTransform::class.java
            ) { spec: TransformSpec<GenericTransformParameters> ->
                spec.parameters.projectName.set(globalScope.project.name)
                spec.from.attribute(
                    ArtifactAttributes.ARTIFACT_FORMAT,
                    AndroidArtifacts.ArtifactType.CLASSES_JAR.type
                )
                spec.to
                    .attribute(
                        ArtifactAttributes.ARTIFACT_FORMAT,
                        AndroidArtifacts.ArtifactType.ENUMERATED_RUNTIME_CLASSES.type
                    )
            }
        }

        registerDexingOutputSplitTransform(dependencies)

        return this
    }

    companion object {
        @JvmStatic
        fun addFlavorStrategy(
            schema: AttributesSchema,
            dimension: String,
            alternateMap: Map<String, List<String>>
        ) {
            val attr = Attribute.of(dimension, ProductFlavorAttr::class.java)
            val flavorStrategy = schema.attribute(attr)
            flavorStrategy
                .compatibilityRules
                .add(AlternateCompatibilityRule.ProductFlavorRule::class.java) {
                    it.setParams(alternateMap)
                }
            flavorStrategy
                .disambiguationRules
                .add(AlternateDisambiguationRule.ProductFlavorRule::class.java) {
                    it.setParams(alternateMap)
                }
        }
    }
}