/*
 * Copyright (C) 2014 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 static com.android.build.gradle.internal.dependency.DexingOutputSplitTransformKt.registerDexingOutputSplitTransform;
import static com.android.build.gradle.internal.dependency.DexingTransformKt.getDexingArtifactConfigurations;
import static com.android.build.gradle.internal.dependency.L8DexDesugarLibTransformKt.getDesugarLibConfigurations;
import static com.android.build.gradle.internal.publishing.AndroidArtifacts.ArtifactType.FILTERED_PROGUARD_RULES;
import static com.android.build.gradle.internal.publishing.AndroidArtifacts.ArtifactType.UNFILTERED_PROGUARD_RULES;
import static com.android.build.gradle.internal.utils.DesugarLibUtils.getDesugarLibConfig;
import static com.android.builder.core.VariantTypeImpl.ANDROID_TEST;
import static com.android.builder.core.VariantTypeImpl.UNIT_TEST;
import static org.gradle.api.internal.artifacts.ArtifactAttributes.ARTIFACT_FORMAT;

import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.build.api.attributes.ProductFlavorAttr;
import com.android.build.api.component.ComponentIdentity;
import com.android.build.api.component.TestComponentProperties;
import com.android.build.api.component.impl.AndroidTestImpl;
import com.android.build.api.component.impl.AndroidTestPropertiesImpl;
import com.android.build.api.component.impl.ComponentImpl;
import com.android.build.api.component.impl.ComponentPropertiesImpl;
import com.android.build.api.component.impl.UnitTestImpl;
import com.android.build.api.component.impl.UnitTestPropertiesImpl;
import com.android.build.api.variant.impl.VariantImpl;
import com.android.build.api.variant.impl.VariantPropertiesImpl;
import com.android.build.gradle.BaseExtension;
import com.android.build.gradle.TestedAndroidConfig;
import com.android.build.gradle.internal.api.DefaultAndroidSourceSet;
import com.android.build.gradle.internal.api.ReadOnlyObjectProvider;
import com.android.build.gradle.internal.api.VariantFilter;
import com.android.build.gradle.internal.api.artifact.BuildArtifactSpec;
import com.android.build.gradle.internal.api.dsl.DslScope;
import com.android.build.gradle.internal.core.VariantBuilder;
import com.android.build.gradle.internal.core.VariantDslInfo;
import com.android.build.gradle.internal.core.VariantDslInfoImpl;
import com.android.build.gradle.internal.core.VariantSources;
import com.android.build.gradle.internal.crash.ExternalApiUsageException;
import com.android.build.gradle.internal.dependency.AndroidXDependencySubstitution;
import com.android.build.gradle.internal.dependency.DesugarLibConfiguration;
import com.android.build.gradle.internal.dependency.DexingArtifactConfiguration;
import com.android.build.gradle.internal.dependency.FilterShrinkerRulesTransform;
import com.android.build.gradle.internal.dependency.SourceSetManager;
import com.android.build.gradle.internal.dependency.VariantDependencies;
import com.android.build.gradle.internal.dependency.VariantDependenciesBuilder;
import com.android.build.gradle.internal.dependency.VersionedCodeShrinker;
import com.android.build.gradle.internal.dsl.ActionableVariantObjectOperationsExecutor;
import com.android.build.gradle.internal.dsl.BaseAppModuleExtension;
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.pipeline.TransformManager;
import com.android.build.gradle.internal.profile.AnalyticsUtil;
import com.android.build.gradle.internal.publishing.PublishingSpecs;
import com.android.build.gradle.internal.scope.BuildArtifactsHolder;
import com.android.build.gradle.internal.scope.GlobalScope;
import com.android.build.gradle.internal.scope.InternalArtifactType;
import com.android.build.gradle.internal.scope.MutableTaskContainer;
import com.android.build.gradle.internal.scope.SingleArtifactType;
import com.android.build.gradle.internal.scope.VariantBuildArtifactsHolder;
import com.android.build.gradle.internal.scope.VariantScope;
import com.android.build.gradle.internal.scope.VariantScopeImpl;
import com.android.build.gradle.internal.variant.BaseVariantData;
import com.android.build.gradle.internal.variant.DimensionCombination;
import com.android.build.gradle.internal.variant.DimensionCombinator;
import com.android.build.gradle.internal.variant.TestVariantData;
import com.android.build.gradle.internal.variant.TestedVariantData;
import com.android.build.gradle.internal.variant.VariantFactory;
import com.android.build.gradle.internal.variant.VariantInputModel;
import com.android.build.gradle.internal.variant.VariantPathHelper;
import com.android.build.gradle.options.BooleanOption;
import com.android.build.gradle.options.ProjectOptions;
import com.android.build.gradle.options.SigningOptions;
import com.android.build.gradle.options.SyncOptions;
import com.android.builder.core.DefaultManifestParser;
import com.android.builder.core.ManifestAttributeSupplier;
import com.android.builder.core.VariantType;
import com.android.builder.errors.IssueReporter;
import com.android.builder.model.CodeShrinker;
import com.android.builder.profile.ProcessProfileWriter;
import com.android.builder.profile.Recorder;
import com.android.utils.Pair;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.wireless.android.sdk.stats.ApiVersion;
import com.google.wireless.android.sdk.stats.GradleBuildVariant;
import java.io.File;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import org.gradle.api.Action;
import org.gradle.api.Project;
import org.gradle.api.artifacts.dsl.DependencyHandler;
import org.gradle.api.attributes.Attribute;
import org.gradle.api.file.ConfigurableFileCollection;
import org.gradle.api.file.FileCollection;
import org.gradle.api.file.FileSystemLocation;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.Provider;

/** Class to create, manage variants. */
public class VariantManager {

    private static final String MULTIDEX_VERSION = "1.0.2";

    protected static final String COM_ANDROID_SUPPORT_MULTIDEX =
            "com.android.support:multidex:" + MULTIDEX_VERSION;
    protected static final String COM_ANDROID_SUPPORT_MULTIDEX_INSTRUMENTATION =
            "com.android.support:multidex-instrumentation:" + MULTIDEX_VERSION;

    protected static final String ANDROIDX_MULTIDEX_MULTIDEX =
            AndroidXDependencySubstitution.getAndroidXMappings()
                    .get("com.android.support:multidex");
    protected static final String ANDROIDX_MULTIDEX_MULTIDEX_INSTRUMENTATION =
            AndroidXDependencySubstitution.getAndroidXMappings()
                    .get("com.android.support:multidex-instrumentation");

    @NonNull private final Project project;
    @NonNull private final ProjectOptions projectOptions;
    @NonNull private final BaseExtension extension;
    @NonNull private final VariantFactory variantFactory;
    @NonNull private final VariantInputModel variantInputModel;
    @NonNull private final TaskManager taskManager;
    @NonNull private final SourceSetManager sourceSetManager;
    @NonNull private final Recorder recorder;
    @NonNull private final VariantFilter variantFilter;
    @NonNull private final List<ComponentPropertiesImpl> components;
    @NonNull private final Map<File, ManifestAttributeSupplier> manifestParserMap;
    @NonNull protected final GlobalScope globalScope;
    @Nullable private final SigningConfig signingOverride;
    // We cannot use gradle's state of executed as that returns true while inside afterEvalute.
    // Wew want this to only be true after all tasks have been create.
    private boolean hasCreatedTasks = false;
    public static final Attribute<String> SHRINKER_ATTR =
            Attribute.of("codeShrinker", String.class);

    public VariantManager(
            @NonNull GlobalScope globalScope,
            @NonNull Project project,
            @NonNull ProjectOptions projectOptions,
            @NonNull BaseExtension extension,
            @NonNull VariantFactory variantFactory,
            @NonNull VariantInputModel variantInputModel,
            @NonNull TaskManager taskManager,
            @NonNull SourceSetManager sourceSetManager,
            @NonNull Recorder recorder) {
        this.globalScope = globalScope;
        this.extension = extension;
        this.project = project;
        this.projectOptions = projectOptions;
        this.variantFactory = variantFactory;
        this.variantInputModel = variantInputModel;
        this.taskManager = taskManager;
        this.sourceSetManager = sourceSetManager;
        this.recorder = recorder;
        this.signingOverride = createSigningOverride();
        this.variantFilter = new VariantFilter(new ReadOnlyObjectProvider());
        this.components = Lists.newArrayList();
        this.manifestParserMap = Maps.newHashMap();
    }

    /** Registers a new variant. */
    private void addComponent(@NonNull ComponentPropertiesImpl component) {
        components.add(component);
    }

    /** Returns a list of all created {@link VariantScope}s. */
    @NonNull
    public List<ComponentPropertiesImpl> getComponents() {
        return components;
    }

    /** Creates the variants and their tasks. */
    public List<ComponentPropertiesImpl> createVariantsAndTasks() {
        variantFactory.validateModel(variantInputModel);
        variantFactory.preVariantWork(project);

        if (components.isEmpty()) {
            computeVariants();
        }

        // Create top level test tasks.
        taskManager.createTopLevelTestTasks(!variantInputModel.getProductFlavors().isEmpty());

        // Create tasks for all variants (main and tests)
        for (ComponentPropertiesImpl component : components) {
            createTasksForVariant(component);
        }

        taskManager.createReportTasks(components);

        return components;
    }

    /** Create tasks for the specified variant. */
    private void createTasksForVariant(@NonNull ComponentPropertiesImpl componentProperties) {
        final VariantType variantType = componentProperties.getVariantType();

        taskManager.createAssembleTask(componentProperties);
        if (variantType.isBaseModule()) {
            taskManager.createBundleTask(componentProperties);
        }

        if (variantType.isTestComponent()) {
            TestComponentProperties testComponent = (TestComponentProperties) componentProperties;
            VariantPropertiesImpl testedVariant =
                    (VariantPropertiesImpl) testComponent.getTestedVariant();

            VariantDslInfo variantDslInfo = componentProperties.getVariantDslInfo();
            VariantDependencies variantDependencies = componentProperties.getVariantDependencies();

            if (testedVariant.getVariantDslInfo().getRenderscriptSupportModeEnabled()) {
                project.getDependencies()
                        .add(
                                variantDependencies.getCompileClasspath().getName(),
                                project.files(
                                        globalScope
                                                .getSdkComponents()
                                                .getRenderScriptSupportJarProvider()));
            }

            if (variantType.isApk()) { // ANDROID_TEST
                if (variantDslInfo.isLegacyMultiDexMode()) {
                    String multiDexInstrumentationDep =
                            globalScope.getProjectOptions().get(BooleanOption.USE_ANDROID_X)
                                    ? ANDROIDX_MULTIDEX_MULTIDEX_INSTRUMENTATION
                                    : COM_ANDROID_SUPPORT_MULTIDEX_INSTRUMENTATION;
                    project.getDependencies()
                            .add(
                                    variantDependencies.getCompileClasspath().getName(),
                                    multiDexInstrumentationDep);
                    project.getDependencies()
                            .add(
                                    variantDependencies.getRuntimeClasspath().getName(),
                                    multiDexInstrumentationDep);
                }

                taskManager.createAndroidTestVariantTasks(
                        (AndroidTestPropertiesImpl) componentProperties,
                        getVariantPropertiesList());
            } else { // UNIT_TEST
                taskManager.createUnitTestVariantTasks(
                        (UnitTestPropertiesImpl) componentProperties);
            }

        } else {
            taskManager.createTasksForVariantScope(
                    (VariantPropertiesImpl) componentProperties, getVariantPropertiesList());
        }
    }

    private List<VariantPropertiesImpl> getVariantPropertiesList() {
        return components
                .stream()
                .filter(component -> component instanceof VariantPropertiesImpl)
                .map(component -> (VariantPropertiesImpl) component)
                .collect(Collectors.toList());
    }

    /** Publish intermediate artifacts in the BuildArtifactsHolder based on PublishingSpecs. */
    public void publishBuildArtifacts(@NonNull ComponentPropertiesImpl componentProperties) {
        BuildArtifactsHolder buildArtifactsHolder = componentProperties.getArtifacts();
        for (PublishingSpecs.OutputSpec outputSpec :
                componentProperties.getVariantScope().getPublishingSpec().getOutputs()) {
            SingleArtifactType<? extends FileSystemLocation> buildArtifactType =
                    outputSpec.getOutputType();

            // Gradle only support publishing single file.  Therefore, unless Gradle starts
            // supporting publishing multiple files, PublishingSpecs should not contain any
            // OutputSpec with an appendable ArtifactType.
            if (BuildArtifactSpec.Companion.has(buildArtifactType)
                    && BuildArtifactSpec.Companion.get(buildArtifactType).getAppendable()) {
                throw new RuntimeException(
                        String.format(
                                "Appendable ArtifactType '%1s' cannot be published.",
                                buildArtifactType.name()));
            }

            if (buildArtifactsHolder.hasFinalProduct(buildArtifactType)) {
                Provider<? extends FileSystemLocation> artifact =
                        buildArtifactsHolder.getFinalProduct(buildArtifactType);

                componentProperties
                        .getVariantScope()
                        .publishIntermediateArtifact(
                                artifact,
                                outputSpec.getArtifactType(),
                                outputSpec.getPublishedConfigTypes());
            } else {
                if (buildArtifactType == InternalArtifactType.ALL_CLASSES.INSTANCE) {
                    Provider<FileCollection> allClasses =
                            buildArtifactsHolder.getFinalProductAsFileCollection(
                                    InternalArtifactType.ALL_CLASSES.INSTANCE);
                    Provider<File> file = allClasses.map(FileCollection::getSingleFile);

                    componentProperties
                            .getVariantScope()
                            .publishIntermediateArtifact(
                                    file,
                                    outputSpec.getArtifactType(),
                                    outputSpec.getPublishedConfigTypes());
                }
            }
        }
    }

    @NonNull
    private Map<Attribute<ProductFlavorAttr>, ProductFlavorAttr> getFlavorSelection(
            @NonNull VariantDslInfo variantDslInfo) {
        ObjectFactory factory = project.getObjects();

        return variantDslInfo
                .getMissingDimensionStrategies()
                .entrySet()
                .stream()
                .collect(
                        Collectors.toMap(
                                entry -> Attribute.of(entry.getKey(), ProductFlavorAttr.class),
                                entry ->
                                        factory.named(
                                                ProductFlavorAttr.class,
                                                entry.getValue().getRequested())));

    }

    /** Configure artifact transforms that require variant-specific attribute information. */
    private void configureVariantArtifactTransforms() {
        DependencyHandler dependencies = project.getDependencies();

        if (globalScope.getProjectOptions().get(BooleanOption.ENABLE_DEXING_ARTIFACT_TRANSFORM)) {
            for (DexingArtifactConfiguration artifactConfiguration :
                    getDexingArtifactConfigurations(components)) {
                artifactConfiguration.registerTransform(
                        globalScope.getProject().getName(),
                        dependencies,
                        globalScope.getBootClasspath(),
                        getDesugarLibConfig(globalScope.getProject()),
                        SyncOptions.getErrorFormatMode(globalScope.getProjectOptions()),
                        projectOptions.get(BooleanOption.ENABLE_INCREMENTAL_DEXING_V2));
            }
        }

        if (globalScope.getProjectOptions().get(BooleanOption.ENABLE_PROGUARD_RULES_EXTRACTION)) {
            Set<CodeShrinker> shrinkers =
                    components
                            .stream()
                            .map(component -> component.getVariantScope().getCodeShrinker())
                            .filter(Objects::nonNull)
                            .collect(Collectors.toSet());
            for (CodeShrinker shrinker : shrinkers) {
                dependencies.registerTransform(
                        FilterShrinkerRulesTransform.class,
                        reg -> {
                            reg.getFrom()
                                    .attribute(
                                            ARTIFACT_FORMAT, UNFILTERED_PROGUARD_RULES.getType());
                            reg.getTo()
                                    .attribute(ARTIFACT_FORMAT, FILTERED_PROGUARD_RULES.getType());

                            reg.getFrom().attribute(SHRINKER_ATTR, shrinker.toString());
                            reg.getTo().attribute(SHRINKER_ATTR, shrinker.toString());

                            reg.parameters(
                                    params -> {
                                        params.getShrinker()
                                                .set(VersionedCodeShrinker.of(shrinker));
                                        params.getProjectName().set(project.getName());
                                    });
                        });
            }
        }

        for (DesugarLibConfiguration configuration : getDesugarLibConfigurations(components)) {
            configuration.registerTransform(dependencies);
        }

        registerDexingOutputSplitTransform(dependencies);
    }

    /**
     * Returns a modified name.
     *
     * <p>This name is used to request a missing dimension. It is the same name as the flavor that
     * sets up the request, which means it's not going to be matched, and instead it'll go to a
     * custom fallbacks provided by the flavor.
     *
     * <p>We are just modifying the name to avoid collision in case the same name exists in
     * different dimensions
     */
    public static String getModifiedName(@NonNull String name) {
        return "____" + name;
    }

    /** Create all variants. */
    @VisibleForTesting
    public void computeVariants() {
        List<String> flavorDimensionList = extension.getFlavorDimensionList();

        DimensionCombinator computer =
                new DimensionCombinator(
                        variantInputModel,
                        globalScope.getDslScope().getIssueReporter(),
                        variantFactory.getVariantType(),
                        flavorDimensionList);

        List<DimensionCombination> variants = computer.computeVariants();

        // get some info related to testing
        BuildTypeData testBuildTypeData = getTestBuildTypeData();

        // loop on all the new variant objects to create the legacy ones.
        for (DimensionCombination variant : variants) {
            createVariantsFromCombination(variant, testBuildTypeData);
        }

        configureVariantArtifactTransforms();
    }

    @Nullable
    private BuildTypeData getTestBuildTypeData() {
        BuildTypeData testBuildTypeData = null;
        if (extension instanceof TestedAndroidConfig) {
            TestedAndroidConfig testedExtension = (TestedAndroidConfig) extension;

            testBuildTypeData =
                    variantInputModel.getBuildTypes().get(testedExtension.getTestBuildType());
            if (testBuildTypeData == null) {
                throw new RuntimeException(
                        String.format(
                                "Test Build Type '%1$s' does not" + " exist.",
                                testedExtension.getTestBuildType()));
            }
        }
        return testBuildTypeData;
    }

    @Nullable
    private Pair<VariantImpl<VariantPropertiesImpl>, VariantPropertiesImpl> createVariant(
            @NonNull DimensionCombination dimensionCombination,
            @NonNull BuildTypeData buildTypeData,
            @NonNull List<ProductFlavorData<ProductFlavor>> productFlavorDataList,
            @NonNull VariantType variantType) {
        // entry point for a given buildType/Flavors/VariantType combo.
        // Need to run the new variant API to selectively ignore variants.
        // in order to do this, we need access to the VariantDslInfo, to create a
        DslScope dslScope = globalScope.getDslScope();

        final ProductFlavorData<DefaultConfig> defaultConfig = variantInputModel.getDefaultConfig();
        DefaultAndroidSourceSet defaultConfigSourceProvider = defaultConfig.getSourceSet();

        VariantBuilder variantBuilder =
                VariantBuilder.getBuilder(
                        dimensionCombination,
                        variantType,
                        defaultConfig.getProductFlavor(),
                        defaultConfigSourceProvider,
                        buildTypeData.getBuildType(),
                        buildTypeData.getSourceSet(),
                        signingOverride,
                        getParser(
                                defaultConfigSourceProvider.getManifestFile(),
                                variantType.getRequiresManifest()),
                        globalScope.getProjectOptions(),
                        dslScope.getIssueReporter(),
                        this::canParseManifest);

        // We must first add the flavors to the variant config, in order to get the proper
        // variant-specific and multi-flavor name as we add/create the variant providers later.
        for (ProductFlavorData<ProductFlavor> productFlavorData : productFlavorDataList) {
            variantBuilder.addProductFlavor(
                    productFlavorData.getProductFlavor(), productFlavorData.getSourceSet());
        }

        VariantDslInfoImpl variantDslInfo = variantBuilder.createVariantDslInfo();
        ComponentIdentity componentIdentity = variantDslInfo.getComponentIdentity();

        // create the Variant object so that we can run the action which may interrupt the creation
        // (in case of enabled = false)
        VariantImpl<VariantPropertiesImpl> variant =
                variantFactory.createVariantObject(componentIdentity, variantDslInfo);

        // HACK, we need access to the new type rather than the old. This will go away in the
        // future
        ActionableVariantObjectOperationsExecutor commonExtension =
                (ActionableVariantObjectOperationsExecutor) extension;
        //noinspection unchecked
        commonExtension.executeVariantOperations(variant);

        if (!variant.getEnabled()) {
            return null;
        }

        // now that we have the result of the filter, we can continue configuring the variant

        createCompoundSourceSets(productFlavorDataList, variantBuilder, sourceSetManager);

        VariantSources variantSources = variantBuilder.createVariantSources();

        // Only record release artifacts
        if (!buildTypeData.getBuildType().isDebuggable()
                && variantType.isApk()
                && !variantDslInfo.getVariantType().isForTesting()) {
            ProcessProfileWriter.get().recordApplicationId(variantDslInfo::getApplicationId);
        }

        // Add the container of dependencies.
        // The order of the libraries is important, in descending order:
        // variant-specific, build type, multi-flavor, flavor1, flavor2, ..., defaultConfig.
        // variant-specific if the full combo of flavors+build type. Does not exist if no flavors.
        // multi-flavor is the combination of all flavor dimensions. Does not exist if <2 dimension.
        final List<DefaultAndroidSourceSet> variantSourceSets =
                Lists.newArrayListWithExpectedSize(productFlavorDataList.size() + 4);

        // 1. add the variant-specific if applicable.
        if (!productFlavorDataList.isEmpty()) {
            variantSourceSets.add(
                    (DefaultAndroidSourceSet) variantSources.getVariantSourceProvider());
        }

        // 2. the build type.
        variantSourceSets.add(buildTypeData.getSourceSet());

        // 3. the multi-flavor combination
        if (productFlavorDataList.size() > 1) {
            variantSourceSets.add(
                    (DefaultAndroidSourceSet) variantSources.getMultiFlavorSourceProvider());
        }

        // 4. the flavors.
        for (ProductFlavorData<ProductFlavor> productFlavor : productFlavorDataList) {
            variantSourceSets.add(productFlavor.getSourceSet());
        }

        // 5. The defaultConfig
        variantSourceSets.add(variantInputModel.getDefaultConfig().getSourceSet());

        // Create VariantDependencies
        VariantDependenciesBuilder builder =
                VariantDependenciesBuilder.builder(
                                project,
                                projectOptions,
                                globalScope.getDslScope().getIssueReporter(),
                                variantDslInfo)
                        .setFlavorSelection(getFlavorSelection(variantDslInfo))
                        .addSourceSets(variantSourceSets);

        if (extension instanceof BaseAppModuleExtension) {
            builder.setFeatureList(((BaseAppModuleExtension) extension).getDynamicFeatures());
        }

        final VariantDependencies variantDependencies = builder.build(globalScope);

        // Done. Create the (too) many variant objects

        VariantPathHelper pathHelper = new VariantPathHelper(project, variantDslInfo, dslScope);
        VariantBuildArtifactsHolder artifacts =
                new VariantBuildArtifactsHolder(
                        project, componentIdentity.getName(), globalScope.getBuildDir());
        MutableTaskContainer taskContainer = new MutableTaskContainer();

        // create the obsolete VariantScope
        VariantScopeImpl variantScope =
                new VariantScopeImpl(
                        componentIdentity,
                        variantDslInfo,
                        variantSources,
                        variantDependencies,
                        pathHelper,
                        artifacts,
                        globalScope,
                        new TransformManager(project, dslScope.getIssueReporter(), recorder),
                        null /* testedVariantProperties*/);

        // and the obsolete variant data
        BaseVariantData variantData =
                variantFactory.createVariantData(
                        componentIdentity,
                        variantDslInfo,
                        variantDependencies,
                        variantSources,
                        pathHelper,
                        artifacts,
                        globalScope,
                        taskManager,
                        taskContainer);

        // then the new VariantProperties which will contain the 2 old objects.
        VariantPropertiesImpl variantProperties =
                variantFactory.createVariantPropertiesObject(
                        componentIdentity,
                        variantDslInfo,
                        variantDependencies,
                        variantSources,
                        pathHelper,
                        artifacts,
                        variantScope,
                        variantData);

        if (variantDslInfo.isLegacyMultiDexMode()) {
            String multiDexDependency =
                    globalScope.getProjectOptions().get(BooleanOption.USE_ANDROID_X)
                            ? ANDROIDX_MULTIDEX_MULTIDEX
                            : COM_ANDROID_SUPPORT_MULTIDEX;
            project.getDependencies()
                    .add(variantDependencies.getCompileClasspath().getName(), multiDexDependency);
            project.getDependencies()
                    .add(variantDependencies.getRuntimeClasspath().getName(), multiDexDependency);
        }

        if (variantDslInfo.getRenderscriptSupportModeEnabled()) {
            final ConfigurableFileCollection fileCollection =
                    project.files(
                            globalScope.getSdkComponents().getRenderScriptSupportJarProvider());
            project.getDependencies()
                    .add(variantDependencies.getCompileClasspath().getName(), fileCollection);
            if (variantType.isApk() && !variantType.isForTesting()) {
                project.getDependencies()
                        .add(variantDependencies.getRuntimeClasspath().getName(), fileCollection);
            }
        }

        // Run the VariantProperties actions
        //noinspection unchecked
        commonExtension.executeVariantPropertiesOperations(variantProperties);

        // also execute the delayed actions registered on the Variant object itself
        //noinspection unchecked
        variant.executePropertiesActions(variantProperties);

        return Pair.of(variant, variantProperties);
    }

    private static void createCompoundSourceSets(
            @NonNull List<ProductFlavorData<ProductFlavor>> productFlavorList,
            @NonNull VariantBuilder variantBuilder,
            @NonNull SourceSetManager sourceSetManager) {
        final VariantType variantType = variantBuilder.getVariantType();

        if (!productFlavorList.isEmpty() /* && !variantConfig.getType().isSingleBuildType()*/) {
            DefaultAndroidSourceSet variantSourceSet =
                    (DefaultAndroidSourceSet)
                            sourceSetManager.setUpSourceSet(
                                    VariantBuilder.computeSourceSetName(
                                            variantBuilder.getName(), variantType),
                                    variantType.isTestComponent());
            variantBuilder.setVariantSourceProvider(variantSourceSet);
        }

        if (productFlavorList.size() > 1) {
            DefaultAndroidSourceSet multiFlavorSourceSet =
                    (DefaultAndroidSourceSet)
                            sourceSetManager.setUpSourceSet(
                                    VariantBuilder.computeSourceSetName(
                                            variantBuilder.getFlavorName(), variantType),
                                    variantType.isTestComponent());
            variantBuilder.setMultiFlavorSourceProvider(multiFlavorSourceSet);
        }
    }

    /** Create a TestVariantData for the specified testedVariantData. */
    @Nullable
    public ComponentPropertiesImpl createTestComponents(
            @NonNull DimensionCombination dimensionCombination,
            @NonNull BuildTypeData buildTypeData,
            @NonNull List<ProductFlavorData<ProductFlavor>> productFlavorDataList,
            @NonNull VariantImpl<VariantPropertiesImpl> testedVariant,
            @NonNull VariantPropertiesImpl testedVariantProperties,
            @NonNull VariantType variantType) {

        // handle test variant
        // need a suppress warning because ProductFlavor.getTestSourceSet(type) is annotated
        // to return @Nullable and the constructor is @NonNull on this parameter,
        // but it's never the case on defaultConfigData
        // The constructor does a runtime check on the instances so we should be safe.
        final DefaultAndroidSourceSet testSourceSet =
                variantInputModel.getDefaultConfig().getTestSourceSet(variantType);
        DslScope dslScope = globalScope.getDslScope();
        @SuppressWarnings("ConstantConditions")
        VariantBuilder variantBuilder =
                VariantBuilder.getBuilder(
                        dimensionCombination,
                        variantType,
                        variantInputModel.getDefaultConfig().getProductFlavor(),
                        testSourceSet,
                        buildTypeData.getBuildType(),
                        buildTypeData.getTestSourceSet(variantType),
                        signingOverride,
                        testSourceSet != null
                                ? getParser(
                                        testSourceSet.getManifestFile(),
                                        variantType.getRequiresManifest())
                                : null,
                        globalScope.getProjectOptions(),
                        dslScope.getIssueReporter(),
                        this::canParseManifest);

        variantBuilder.setTestedVariant(
                (VariantDslInfoImpl) testedVariantProperties.getVariantDslInfo());

        List<ProductFlavor> productFlavorList =
                testedVariantProperties.getVariantDslInfo().getProductFlavorList();

        // We must first add the flavors to the variant builder, in order to get the proper
        // variant-specific and multi-flavor name as we add/create the variant providers later.
        final Map<String, ProductFlavorData<ProductFlavor>> productFlavors =
                variantInputModel.getProductFlavors();
        for (ProductFlavor productFlavor : productFlavorList) {
            ProductFlavorData<ProductFlavor> data = productFlavors.get(productFlavor.getName());

            //noinspection ConstantConditions
            variantBuilder.addProductFlavor(
                    data.getProductFlavor(), data.getTestSourceSet(variantType));
        }

        VariantDslInfoImpl variantDslInfo = variantBuilder.createVariantDslInfo();

        // this is ANDROID_TEST
        ComponentImpl component;
        if (variantType.isApk()) {
            AndroidTestImpl androidTestVariant =
                    variantFactory.createAndroidTestObject(
                            variantDslInfo.getComponentIdentity(), variantDslInfo);

            testedVariant.executeAndroidTestActions(androidTestVariant);

            component = androidTestVariant;
        } else {
            // this is UNIT_TEST
            UnitTestImpl unitTestVariant =
                    variantFactory.createUnitTestObject(
                            variantDslInfo.getComponentIdentity(), variantDslInfo);

            testedVariant.executeUnitTestActions(unitTestVariant);

            component = unitTestVariant;
        }

        if (!component.getEnabled()) {
            return null;
        }

        // now that we have the result of the filter, we can continue configuring the variant
        createCompoundSourceSets(productFlavorDataList, variantBuilder, sourceSetManager);

        VariantSources variantSources = variantBuilder.createVariantSources();

        // Add the container of dependencies, the order of the libraries is important.
        // In descending order: build type (only for unit test), flavors, defaultConfig.

        // Add the container of dependencies.
        // The order of the libraries is important, in descending order:
        // variant-specific, build type (, multi-flavor, flavor1, flavor2, ..., defaultConfig.
        // variant-specific if the full combo of flavors+build type. Does not exist if no flavors.
        // multi-flavor is the combination of all flavor dimensions. Does not exist if <2 dimension.
        List<ProductFlavor> testProductFlavors = variantDslInfo.getProductFlavorList();
        List<DefaultAndroidSourceSet> testVariantSourceSets =
                Lists.newArrayListWithExpectedSize(4 + testProductFlavors.size());

        // 1. add the variant-specific if applicable.
        if (!testProductFlavors.isEmpty()) {
            testVariantSourceSets.add(
                    (DefaultAndroidSourceSet) variantSources.getVariantSourceProvider());
        }

        // 2. the build type.
        DefaultAndroidSourceSet buildTypeConfigurationProvider =
                buildTypeData.getTestSourceSet(variantType);
        if (buildTypeConfigurationProvider != null) {
            testVariantSourceSets.add(buildTypeConfigurationProvider);
        }

        // 3. the multi-flavor combination
        if (testProductFlavors.size() > 1) {
            testVariantSourceSets.add(
                    (DefaultAndroidSourceSet) variantSources.getMultiFlavorSourceProvider());
        }

        // 4. the flavors.
        for (ProductFlavor productFlavor : testProductFlavors) {
            testVariantSourceSets.add(
                    variantInputModel
                            .getProductFlavors()
                            .get(productFlavor.getName())
                            .getTestSourceSet(variantType));
        }

        // now add the default config
        testVariantSourceSets.add(
                variantInputModel.getDefaultConfig().getTestSourceSet(variantType));

        // If the variant being tested is a library variant, VariantDependencies must be
        // computed after the tasks for the tested variant is created.  Therefore, the
        // VariantDependencies is computed here instead of when the VariantData was created.
        VariantDependenciesBuilder builder =
                VariantDependenciesBuilder.builder(
                                project,
                                projectOptions,
                                globalScope.getDslScope().getIssueReporter(),
                                variantDslInfo)
                        .addSourceSets(testVariantSourceSets)
                        .setFlavorSelection(getFlavorSelection(variantDslInfo))
                        .setTestedVariant(testedVariantProperties);

        final VariantDependencies variantDependencies = builder.build(globalScope);

        VariantPathHelper pathHelper = new VariantPathHelper(project, variantDslInfo, dslScope);
        ComponentIdentity componentIdentity = variantDslInfo.getComponentIdentity();
        VariantBuildArtifactsHolder artifacts =
                new VariantBuildArtifactsHolder(
                        project, componentIdentity.getName(), globalScope.getBuildDir());
        MutableTaskContainer taskContainer = new MutableTaskContainer();

        VariantScopeImpl variantScope =
                new VariantScopeImpl(
                        componentIdentity,
                        variantDslInfo,
                        variantSources,
                        variantDependencies,
                        pathHelper,
                        artifacts,
                        globalScope,
                        new TransformManager(project, dslScope.getIssueReporter(), recorder),
                        testedVariantProperties);

        // create the internal storage for this variant.
        TestVariantData testVariantData =
                new TestVariantData(
                        componentIdentity,
                        variantDslInfo,
                        variantDependencies,
                        variantSources,
                        pathHelper,
                        artifacts,
                        (TestedVariantData) testedVariantProperties.getVariantData(),
                        globalScope,
                        taskManager,
                        taskContainer);

        // this is ANDROID_TEST
        ComponentPropertiesImpl componentProperties;
        if (variantType.isApk()) {
            AndroidTestPropertiesImpl androidTestProperties =
                    variantFactory.createAndroidTestProperties(
                            componentIdentity,
                            variantDslInfo,
                            variantDependencies,
                            variantSources,
                            pathHelper,
                            artifacts,
                            variantScope,
                            testVariantData,
                            testedVariantProperties);

            component.executePropertiesActions(androidTestProperties);

            componentProperties = androidTestProperties;
        } else {
            // this is UNIT_TEST
            UnitTestPropertiesImpl unitTestProperties =
                    variantFactory.createUnitTestProperties(
                            componentIdentity,
                            variantDslInfo,
                            variantDependencies,
                            variantSources,
                            pathHelper,
                            artifacts,
                            variantScope,
                            testVariantData,
                            testedVariantProperties);

            // also execute the delayed actions registered on the Variant object itself
            component.executePropertiesActions(unitTestProperties);

            componentProperties = unitTestProperties;
        }

        // register
        testedVariantProperties
                .getTestComponents()
                .put(variantDslInfo.getVariantType(), componentProperties);

        return componentProperties;
    }

    /**
     * Creates Variant objects for a specific {@link ComponentIdentity}
     *
     * <p>This will create both the prod and the androidTest/unitTest variants.
     */
    private void createVariantsFromCombination(
            @NonNull DimensionCombination dimensionCombination,
            @Nullable BuildTypeData testBuildTypeData) {
        VariantType variantType = variantFactory.getVariantType();

        // first run the old variantFilter API
        // This acts on buildtype/flavor only, and applies in one pass to prod/tests.
        Action<com.android.build.api.variant.VariantFilter> variantFilterAction =
                extension.getVariantFilter();

        DefaultConfig defaultConfig = variantInputModel.getDefaultConfig().getProductFlavor();

        BuildTypeData buildTypeData =
                variantInputModel.getBuildTypes().get(dimensionCombination.getBuildType());
        BuildType buildType = buildTypeData.getBuildType();

        // get the list of ProductFlavorData from the list of flavor name
        List<ProductFlavorData<ProductFlavor>> productFlavorDataList =
                dimensionCombination
                        .getProductFlavors()
                        .stream()
                        .map(it -> variantInputModel.getProductFlavors().get(it.getSecond()))
                        .collect(Collectors.toList());

        List<ProductFlavor> productFlavorList =
                productFlavorDataList
                        .stream()
                        .map(ProductFlavorData::getProductFlavor)
                        .collect(Collectors.toList());

        boolean ignore = false;

        if (variantFilterAction != null) {
            variantFilter.reset(
                    dimensionCombination, defaultConfig, buildType, variantType, productFlavorList);

            try {
                // variantFilterAction != null always true here.
                variantFilterAction.execute(variantFilter);
            } catch (Throwable t) {
                throw new ExternalApiUsageException(t);
            }
            ignore = variantFilter.getIgnore();
        }

        if (!ignore) {
            // create the prod variant
            Pair<VariantImpl<VariantPropertiesImpl>, VariantPropertiesImpl> variantInfo =
                    createVariant(
                            dimensionCombination,
                            buildTypeData,
                            productFlavorDataList,
                            variantType);
            if (variantInfo != null) {
                addComponent(variantInfo.getSecond());

                VariantPropertiesImpl variantProperties = variantInfo.getSecond();

                VariantDslInfo variantDslInfo = variantProperties.getVariantDslInfo();
                VariantScope variantScope = variantProperties.getVariantScope();

                int minSdkVersion = variantDslInfo.getMinSdkVersion().getApiLevel();
                int targetSdkVersion = variantDslInfo.getTargetSdkVersion().getApiLevel();
                if (minSdkVersion > 0 && targetSdkVersion > 0 && minSdkVersion > targetSdkVersion) {
                    globalScope
                            .getDslScope()
                            .getIssueReporter()
                            .reportWarning(
                                    IssueReporter.Type.GENERIC,
                                    String.format(
                                            Locale.US,
                                            "minSdkVersion (%d) is greater than targetSdkVersion"
                                                    + " (%d) for variant \"%s\". Please change the"
                                                    + " values such that minSdkVersion is less than or"
                                                    + " equal to targetSdkVersion.",
                                            minSdkVersion,
                                            targetSdkVersion,
                                            variantProperties.getName()));
                }

                GradleBuildVariant.Builder profileBuilder =
                        ProcessProfileWriter.getOrCreateVariant(
                                        project.getPath(), variantProperties.getName())
                                .setIsDebug(buildType.isDebuggable())
                                .setMinSdkVersion(
                                        AnalyticsUtil.toProto(variantDslInfo.getMinSdkVersion()))
                                .setMinifyEnabled(variantScope.getCodeShrinker() != null)
                                .setUseMultidex(variantDslInfo.isMultiDexEnabled())
                                .setUseLegacyMultidex(variantDslInfo.isLegacyMultiDexMode())
                                .setVariantType(
                                        variantProperties
                                                .getVariantType()
                                                .getAnalyticsVariantType())
                                .setDexBuilder(AnalyticsUtil.toProto(variantScope.getDexer()))
                                .setDexMerger(AnalyticsUtil.toProto(variantScope.getDexMerger()))
                                .setCoreLibraryDesugaringEnabled(
                                        variantScope.isCoreLibraryDesugaringEnabled())
                                .setTestExecution(
                                        AnalyticsUtil.toProto(
                                                globalScope
                                                        .getExtension()
                                                        .getTestOptions()
                                                        .getExecutionEnum()));

                if (variantScope.getCodeShrinker() != null) {
                    profileBuilder.setCodeShrinker(
                            AnalyticsUtil.toProto(variantScope.getCodeShrinker()));
                }

                if (variantDslInfo.getTargetSdkVersion().getApiLevel() > 0) {
                    profileBuilder.setTargetSdkVersion(
                            AnalyticsUtil.toProto(variantDslInfo.getTargetSdkVersion()));
                }
                if (variantDslInfo.getMaxSdkVersion() != null) {
                    profileBuilder.setMaxSdkVersion(
                            ApiVersion.newBuilder().setApiLevel(variantDslInfo.getMaxSdkVersion()));
                }

                VariantScope.Java8LangSupport supportType = variantScope.getJava8LangSupportType();
                if (supportType != VariantScope.Java8LangSupport.INVALID
                        && supportType != VariantScope.Java8LangSupport.UNUSED) {
                    profileBuilder.setJava8LangSupport(AnalyticsUtil.toProto(supportType));
                }

                if (variantFactory.hasTestScope()) {
                    if (buildTypeData == testBuildTypeData) {
                        ComponentPropertiesImpl androidTestVariantProperties =
                                createTestComponents(
                                        dimensionCombination,
                                        buildTypeData,
                                        productFlavorDataList,
                                        variantInfo.getFirst(),
                                        variantProperties,
                                        ANDROID_TEST);
                        if (androidTestVariantProperties != null) {
                            addComponent(androidTestVariantProperties);
                        }
                    }

                    ComponentPropertiesImpl unitTestVariantProperties =
                            createTestComponents(
                                    dimensionCombination,
                                    buildTypeData,
                                    productFlavorDataList,
                                    variantInfo.getFirst(),
                                    variantProperties,
                                    UNIT_TEST);
                    if (unitTestVariantProperties != null) {
                        addComponent(unitTestVariantProperties);
                    }
                }
            }
        }
    }

    private SigningConfig createSigningOverride() {
        SigningOptions signingOptions = SigningOptions.readSigningOptions(projectOptions);
        if (signingOptions != null) {
            com.android.build.gradle.internal.dsl.SigningConfig signingConfigDsl =
                    new com.android.build.gradle.internal.dsl.SigningConfig("externalOverride");

            signingConfigDsl.setStoreFile(new File(signingOptions.getStoreFile()));
            signingConfigDsl.setStorePassword(signingOptions.getStorePassword());
            signingConfigDsl.setKeyAlias(signingOptions.getKeyAlias());
            signingConfigDsl.setKeyPassword(signingOptions.getKeyPassword());

            if (signingOptions.getStoreType() != null) {
                signingConfigDsl.setStoreType(signingOptions.getStoreType());
            }

            if (signingOptions.getV1Enabled() != null) {
                signingConfigDsl.setV1SigningEnabled(signingOptions.getV1Enabled());
            }

            if (signingOptions.getV2Enabled() != null) {
                signingConfigDsl.setV2SigningEnabled(signingOptions.getV2Enabled());
            }

            return signingConfigDsl;
        }
        return null;
    }

    @NonNull
    private ManifestAttributeSupplier getParser(
            @NonNull File file, boolean isManifestFileRequired) {
        return manifestParserMap.computeIfAbsent(
                file,
                f ->
                        new DefaultManifestParser(
                                f,
                                this::canParseManifest,
                                isManifestFileRequired,
                                globalScope.getDslScope().getIssueReporter()));
    }

    private boolean canParseManifest() {
        return hasCreatedTasks || !projectOptions.get(BooleanOption.DISABLE_EARLY_MANIFEST_PARSING);
    }

    public void setHasCreatedTasks(boolean hasCreatedTasks) {
        this.hasCreatedTasks = hasCreatedTasks;
    }
}