// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8;

import static com.android.tools.r8.BaseCompilerCommandUtils.createProgramOutputConsumer;

import com.android.tools.r8.StringConsumer.FileConsumer;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.origin.PathOrigin;
import com.android.tools.r8.profile.art.ArtProfileConsumerUtils;
import com.android.tools.r8.profile.art.ArtProfileProviderUtils;
import com.android.tools.r8.profile.startup.StartupProfileProviderUtils;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.ArchiveResourceProvider;
import com.android.tools.r8.utils.CliParserUtils;
import com.android.tools.r8.utils.FlagFile;
import com.android.tools.r8.utils.MapIdTemplateProvider;
import com.android.tools.r8.utils.SourceFileTemplateProvider;
import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.internal.CliParser;
import com.android.tools.r8.utils.internal.FileUtils;
import com.android.tools.r8.utils.internal.StringUtils;
import java.io.File;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

public class R8CommandParser extends BaseCompilerCommandParser {

  // Due to the family of flags (for assertions and diagnostics) we can't base the one/two args
  // on this setup of flags. Thus, the flag collection just encodes the descriptive content.
  static List<ParseFlagInfo> getFlags() {
    return CliParserUtils.getFlagInfos(createParser());
  }

  private static CliParser<ParserState> createParser() {
    var header =
        StringUtils.joinLines(
            "Usage: r8 [options] [@<argfile>] <input-files>",
            " where <input-files> are any combination class, zip, or jar files",
            " and each <argfile> is a file containing additional arguments (one per line)",
            " and options are:");
    return new CliParser<ParserState>(header)
        .option0(
            "--release",
            "Compile without debugging information (default).",
            state -> {
              if (state.mode == CompilationMode.DEBUG) {
                StringDiagnostic diagnostic =
                    new StringDiagnostic(
                        "Cannot compile in both --debug and --release mode.", state.origin);
                state.builder.error(diagnostic);
              }
              state.mode = CompilationMode.RELEASE;
            })
        .option0(
            "--debug",
            "Compile with debugging information.",
            state -> {
              if (state.mode == CompilationMode.RELEASE) {
                StringDiagnostic diagnostic =
                    new StringDiagnostic(
                        "Cannot compile in both --debug and --release mode.", state.origin);
                state.builder.error(diagnostic);
              }
              state.mode = CompilationMode.DEBUG;
            })
        .option0(
            "--dex",
            "Compile program to DEX file format (default).",
            state -> {
              if (state.outputMode == OutputMode.ClassFile) {
                StringDiagnostic diagnostic =
                    new StringDiagnostic(
                        "Cannot compile in both --dex and --classfile output mode.", state.origin);
                state.builder.error(diagnostic);
              }
              state.outputMode = OutputMode.DexIndexed;
            })
        .option0(
            "--classfile",
            "Compile program to Java classfile format.",
            state -> {
              if (state.outputMode == OutputMode.DexIndexed) {
                state.builder.error(
                    new StringDiagnostic(
                        "Cannot compile in both --dex and --classfile output mode.", state.origin));
              }
              state.outputMode = OutputMode.ClassFile;
            })
        .option1(
            "--output",
            "<file>",
            "Output result in <file>. <file> must be an existing directory or a zip file.",
            (state, arg) -> {
              if (state.outputPath != null) {
                StringDiagnostic diagnostic =
                    new StringDiagnostic(
                        "Cannot output both to '" + state.outputPath + "' and '" + arg + "'",
                        state.origin);
                state.builder.error(diagnostic);
              }
              state.outputPath = Paths.get(arg);
            })
        .option1(
            "--lib",
            "<file|jdk-home>",
            "Add <file|jdk-home> as a library resource.",
            (state, arg) ->
                CompilerCommandParserUtils.addLibraryArgument(
                    state.builder.getAppBuilder(), arg, state.origin, state.builder.getReporter()))
        .option1(
            "--classpath",
            "<file>",
            "Add <file> as a classpath resource.",
            (state, arg) -> state.builder.addClasspathFiles(Paths.get(arg)))
        .option1(
            "--min-api",
            "<number>",
            "Minimum Android API level compatibility (default: "
                + AndroidApiLevel.getDefault().getMajor()
                + ").",
            (state, arg) -> {
              if (state.hasDefinedApiLevel) {
                StringDiagnostic diagnostic =
                    new StringDiagnostic("Cannot set multiple --min-api options", state.origin);
                state.builder.error(diagnostic);
              } else {
                CliParserUtils.parsePositiveInt(
                    arg,
                    state.builder::setMinApiLevel,
                    error ->
                        state.builder.error(
                            new StringDiagnostic(
                                "Invalid argument to --min-api: " + error, state.origin)));
                state.hasDefinedApiLevel = true;
              }
            })
        .option1(
            "--api-database",
            "<file>",
            "Use <file> as the Android API database for API modeling, overriding the default"
                + " database. <file> must be a .ser file generated by ApiDatabaseGenerator.",
            (state, arg) -> {
              if (state.builder.getApiDatabasePath() != null) {
                StringDiagnostic diagnostic =
                    new StringDiagnostic(
                        "Cannot set multiple --api-database options", state.origin);
                state.builder.error(diagnostic);
              } else {
                state.builder.setApiDatabasePath(Paths.get(arg));
              }
            })
        .option0(
            "--pg-compat",
            "Compile with R8 in Proguard compatibility mode.",
            state -> state.builder.setProguardCompatibility(true))
        .option1(
            "--pg-conf",
            "<file>",
            "Proguard configuration <file>.",
            (state, arg) -> state.builder.addProguardConfigurationFiles(Paths.get(arg)))
        .option1(
            "--pg-conf-output",
            "<file>",
            "Output the collective configuration to <file>.",
            (state, arg) ->
                state.builder.setProguardConfigurationConsumer(new FileConsumer(Paths.get(arg))))
        .option1(
            "--pg-map",
            "<file>",
            "Use <file> as a mapping file for distribution and composition with output mapping"
                + " file.",
            (state, arg) -> state.builder.setProguardMapInputFile(Paths.get(arg)))
        .option1(
            "--pg-map-output",
            "<file>",
            "Output the resulting name and line mapping to <file>.",
            (state, arg) -> state.builder.setProguardMapOutputPath(Paths.get(arg)))
        .option1(
            "--partition-map-output",
            "<file>",
            "Output the resulting mapping to <file>.",
            (state, arg) -> state.builder.setPartitionMapOutputPath(Paths.get(arg)))
        .option1(
            "--desugared-lib",
            "<file>",
            "Specify desugared library configuration. <file> is a desugared library configuration"
                + " (json).",
            (state, arg) ->
                state.builder.addDesugaredLibraryConfiguration(
                    StringResource.fromFile(Paths.get(arg))))
        .option0(
            "--no-tree-shaking",
            "Force disable tree shaking of unreachable classes.",
            state -> state.builder.setDisableTreeShaking(true))
        .option0(
            "--no-minification",
            "Force disable minification of names.",
            state -> state.builder.setDisableMinification(true))
        .option0(
            "--no-data-resources",
            "Ignore all data resources.",
            state -> state.includeDataResources = false)
        .option0(
            "--no-desugaring",
            "Force disable desugaring.",
            state -> state.builder.setDisableDesugaring(true))
        .option1(
            "--main-dex-rules",
            "<file>",
            "Proguard keep rules for classes to place in the primary dex file.",
            (state, arg) -> state.builder.addMainDexRulesFiles(Paths.get(arg)))
        .option1(
            "--main-dex-list",
            "<file>",
            "List of classes to place in the primary dex file.",
            (state, arg) -> state.builder.addMainDexListFiles(Paths.get(arg)))
        .option2(
            "--android-resources",
            "<input>",
            "<output>",
            "Add android resource input and output to be used in resource shrinking. Both input and"
                + " output must be specified.",
            (state, arg1, arg2) -> {
              Path inputPath = Paths.get(arg1);
              Path outputPath = Paths.get(arg2);
              state.builder.setAndroidResourceProvider(
                  new ArchiveProtoAndroidResourceProvider(inputPath));
              state.builder.setAndroidResourceConsumer(
                  new ArchiveProtoAndroidResourceConsumer(outputPath, inputPath));
              state.hasAndroidResources = true;
            })
        .option1(
            "--android-resources-usage-log",
            "<file>",
            "Write the resource shrinking usage log to <file>.",
            (state, arg) -> state.androidResourcesUsageLog = Paths.get(arg))
        .option2(
            "--feature",
            "<input>[:|;<res-input>]",
            "<output>[:|;<res-output>]",
            "Add feature <input> file to <output> file. Several occurrences can map to the same"
                + " output. If <res-input> and <res-output> are specified use these as resource"
                + " shrinker input and output. Separator is : on linux/mac, ; on windows. It is"
                + " possible to supply resource only features by using an empty string for <input>"
                + " and <output>, e.g. '--feature :in.ap_ :out.ap_'.",
            (state, arg1, arg2) -> state.featureSplitConfigCollector.addInputOutput(arg1, arg2))
        .option0(
            "--isolated-splits",
            "Specifies that the application is using isolated splits, i.e., if split APKs installed"
                + " for this application are loaded into their own Context objects.",
            (state) -> state.builder.setEnableIsolatedSplits(true))
        .option1(
            "--main-dex-list-output",
            "<file>",
            "Output the full main-dex list in <file>.",
            (state, arg) -> state.builder.setMainDexListOutputPath(Paths.get(arg)))
        .prefix0(
            "--force-enable-assertions",
            "[:[<class name>|<package name>...]]",
            "Forcefully enable javac generated assertion code.",
            (state, suffix) -> parseForceEnableAssertions(state.builder, suffix, state.origin),
            "--force-ea")
        .prefix0(
            "--force-disable-assertions",
            "[:[<class name>|<package name>...]]",
            "Forcefully disable javac generated assertion code. This is the default handling of"
                + " javac assertion code when generating DEX file format.",
            (state, suffix) -> parseForceDisableAssertions(state.builder, suffix, state.origin),
            "--force-da")
        .prefix0(
            "--force-passthrough-assertions",
            "[:[<class name>|<package name>...]]",
            "Don't change javac generated assertion code. This is the default handling of"
                + " javac assertion code when generating class file format.",
            (state, suffix) -> parseForcePassthroughAssertions(state.builder, suffix, state.origin),
            "--force-pa")
        .prefix0(
            "--force-assertions-handler",
            ":<handler method>[:[<class name>|<package name>...]]",
            "Change javac and kotlinc generated assertion code to invoke the method <handler"
                + " method> with each assertion error instead of throwing it. The <handler"
                + " method> is specified as a class name followed by a dot and the method name."
                + " The handler method must take a single argument of type java.lang.Throwable"
                + " and have return type void.",
            (state, suffix) -> parseForceAssertionsHandler(state.builder, suffix, state.origin),
            "--force-ah")
        .option1(
            "--thread-count",
            "<number>",
            "Use <number> of threads for compilation. If not specified the number will be based on"
                + " heuristics taking the number of cores into account.",
            (state, arg) ->
                CliParserUtils.parsePositiveInt(
                    arg,
                    state.builder::setThreadCount,
                    error ->
                        state.builder.error(
                            new StringDiagnostic(
                                "Invalid argument to --thread-count: " + error, state.origin))))
        .prefix2(
            "--map-diagnostics",
            "[:<type>]",
            "<from-level>",
            "<to-level>",
            "Map diagnostics of <type> (default any) reported as <from-level> to <to-level> where"
                + " <from-level> and <to-level> are one of 'info', 'warning', or 'error' and the"
                + " optional <type> is either the simple or fully qualified Java type name of a"
                + " diagnostic. If <type> is unspecified, all diagnostics at <from-level> will be"
                + " mapped. Note that fatal compiler errors cannot be mapped.",
            (state, suffix, fromLevel, toLevel) ->
                CliParserUtils.parseDiagnosticsMapping(
                    suffix,
                    fromLevel,
                    toLevel,
                    m ->
                        state
                            .builder
                            .getReporter()
                            .addDiagnosticsLevelMapping(m.from, m.diagnosticType, m.to),
                    state.builder::error,
                    state.origin))
        .option1(
            "--map-id-template",
            "<template>",
            "Set the map-id to <template>. The <template> can reference the variables: %MAP_HASH,"
                + " compiler generated mapping hash.",
            (state, arg) ->
                state.builder.setMapIdProvider(
                    MapIdTemplateProvider.create(arg, state.builder.getReporter())))
        .option1(
            "--source-file-template",
            "<template>",
            "Set all source-file attributes to <template>. The <template> can reference the"
                + " variables: %MAP_ID, map id (e.g., value of --map-id-template). %MAP_HASH,"
                + " compiler generated mapping hash.",
            (state, arg) ->
                state.builder.setSourceFileProvider(
                    SourceFileTemplateProvider.create(arg, state.builder.getReporter())))
        .option0(
            "--android-platform-build",
            "Compile as a platform build where the runtime/bootclasspath is assumed to be the"
                + " version specified by --min-api.",
            state -> state.builder.setAndroidPlatformBuild(true))
        .option2(
            "--art-profile",
            "<input>",
            "<output>",
            "Rewrite human readable ART profile read from <input> and write to <output>.",
            (state, arg1, arg2) -> {
              Path artProfilePath = Paths.get(arg1);
              Path rewrittenArtProfilePath = Paths.get(arg2);
              state.builder.addArtProfileForRewriting(
                  ArtProfileProviderUtils.createFromHumanReadableArtProfile(artProfilePath),
                  ArtProfileConsumerUtils.create(rewrittenArtProfilePath));
            })
        .option1(
            "--startup-profile",
            "<file>",
            "Startup profile <file> to use for dex layout.",
            (state, arg) -> {
              Path startupProfilePath = Paths.get(arg);
              state.builder.addStartupProfileProviders(
                  StartupProfileProviderUtils.createFromHumanReadableArtProfile(
                      startupProfilePath));
            })
        .option1(
            "--build-metadata-output",
            "<file>",
            "Output build metadata in <file>.",
            (state, arg) -> {
              if (state.buildMetadataOutputPath != null) {
                state.builder.error(
                    new StringDiagnostic(
                        "Cannot output build metadata to both '"
                            + state.buildMetadataOutputPath
                            + "' and '"
                            + arg
                            + "'",
                        state.origin));
              } else {
                state.buildMetadataOutputPath = Paths.get(arg);
              }
            })
        .option1(
            "--configuration-analysis-data-output",
            "<file>",
            "Output configuration analysis data in <file>.",
            (state, arg) -> {
              if (state.configurationAnalysisDataOutputPath != null) {
                state.builder.error(
                    new StringDiagnostic(
                        "Cannot output configuration analysis data to both '"
                            + state.configurationAnalysisDataOutputPath
                            + "' and '"
                            + arg
                            + "'",
                        state.origin));
              } else {
                state.configurationAnalysisDataOutputPath = Paths.get(arg);
                state.hasKeepRadiusOutput = true;
              }
            })
        .option0(
            "--optimize-multidex-for-linearalloc",
            "Optimize class distribution across DEX files for legacy multidex.",
            state -> state.builder.setOptimizeMultidexForLinearAlloc(true))
        .option1(
            "--dumpinputtofile",
            "<file>",
            "Dump all compiler input to <file> for easy reproduction.",
            (state, arg) -> state.builder.dumpInputToFile(Paths.get(arg)))
        .option1(
            "--dumpinputtodirectory",
            "<dir>",
            "Dump all compiler input to <dir> for easy reproduction.",
            (state, arg) -> state.builder.dumpInputToDirectory(Paths.get(arg)))
        .option0(
            "--version", "Print the version of r8.", state -> state.builder.setPrintVersion(true))
        .option0("--help", "Print this message.", state -> state.builder.setPrintHelp(true))
        .positional(
            (state, arg) -> {
              if (arg.startsWith("@")) {
                state.builder.error(
                    new StringDiagnostic(
                        "Recursive @argfiles are not supported: " + arg, state.origin));
              } else {
                state.builder.addProgramFiles(Paths.get(arg));
              }
            });
  }

  static String getUsageMessage() {
    return CliParserUtils.getUsageMessage(createParser());
  }

  private static class ParserState {
    private CompilationMode mode = null;
    private OutputMode outputMode = null;
    private Path outputPath = null;
    private boolean hasKeepRadiusOutput = false;
    private boolean hasDefinedApiLevel = false;
    private boolean includeDataResources = true;
    private boolean hasAndroidResources = false;
    private Path androidResourcesUsageLog = null;
    private Path configurationAnalysisDataOutputPath = null;
    private Path buildMetadataOutputPath = null;
    private final FeatureSplitConfigCollector featureSplitConfigCollector =
        new FeatureSplitConfigCollector();

    private final R8Command.Builder builder;
    private final Origin origin;

    private ParserState(R8Command.Builder builder, Origin origin) {
      this.builder = builder;
      this.origin = origin;
    }
  }

  /**
   * Parse the R8 command-line.
   *
   * <p>Parsing will set the supplied options or their default value if they have any.
   *
   * @param args Command-line arguments array.
   * @param origin Origin description of the command-line arguments.
   * @return R8 command builder with state set up according to parsed command line.
   */
  public static R8Command.Builder parse(String[] args, Origin origin) {
    return new R8CommandParser().parse(args, origin, R8Command.builder());
  }

  /**
   * Parse the R8 command-line.
   *
   * <p>Parsing will set the supplied options or their default value if they have any.
   *
   * @param args Command-line arguments array.
   * @param origin Origin description of the command-line arguments.
   * @param handler Custom defined diagnostics handler.
   * @return R8 command builder with state set up according to parsed command line.
   */
  public static R8Command.Builder parse(String[] args, Origin origin, DiagnosticsHandler handler) {
    return new R8CommandParser().parse(args, origin, R8Command.builder(handler));
  }

  private R8Command.Builder parse(String[] args, Origin origin, R8Command.Builder builder) {
    ParserState state = new ParserState(builder, origin);
    parse(args, origin, builder, state);
    if (state.mode != null) {
      builder.setMode(state.mode);
    }
    OutputMode outputMode = state.outputMode != null ? state.outputMode : OutputMode.DexIndexed;
    if (state.hasKeepRadiusOutput
        && state.outputPath == null
        && outputMode == OutputMode.DexIndexed) {
      builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
    } else {
      Path outputPath = state.outputPath != null ? state.outputPath : Paths.get(".");
      builder.setOutput(outputPath, outputMode, state.includeDataResources);
    }
    builder.setEnableExperimentalMissingLibraryApiModeling(true);
    return builder;
  }

  private void parse(
      String[] args, Origin argsOrigin, R8Command.Builder builder, ParserState state) {
    String[] expandedArgs = FlagFile.expandFlagFiles(args, builder::error);
    createParser()
        .parse(
            expandedArgs,
            state,
            error -> state.builder.error(new StringDiagnostic(error, state.origin)));
    addFeatureSplitConfigs(
        builder, state.featureSplitConfigCollector.getConfigs(), state.includeDataResources);
    if (state.configurationAnalysisDataOutputPath != null) {
      builder.setConfigurationAnalysisDataConsumer(
          new ByteArrayConsumer.FileConsumer(state.configurationAnalysisDataOutputPath));
    }
    if (state.buildMetadataOutputPath != null) {
      final Path finalBuildMetadataOutputPath = state.buildMetadataOutputPath;
      builder.setBuildMetadataConsumer(
          buildMetadata -> {
            try {
              FileUtils.writeTextFile(finalBuildMetadataOutputPath, buildMetadata.toJson());
            } catch (IOException e) {
              throw new UncheckedIOException(e);
            }
          });
    }
    if (state.hasAndroidResources) {
      builder.setResourceShrinkerConfiguration(
          b -> {
            b.enableOptimizedShrinkingWithR8();
            if (state.androidResourcesUsageLog != null) {
              b.setDebugConsumer(new FileConsumer(state.androidResourcesUsageLog));
            }
            return b.build();
          });
    } else if (state.androidResourcesUsageLog != null) {
      builder.error(
          new StringDiagnostic(
              "--android-resources-usage-log requires --android-resources to be set.", argsOrigin));
    }
  }

  private void addFeatureSplitConfigs(
      R8Command.Builder builder,
      Collection<FeatureSplitConfig> featureSplitConfigs,
      boolean includeDataResources) {
    for (FeatureSplitConfig featureSplitConfig : featureSplitConfigs) {
      builder.addFeatureSplit(
          featureSplitGenerator -> {
            featureSplitGenerator.setProgramConsumer(
                featureSplitConfig.outputJar != null
                    ? createProgramOutputConsumer(
                        featureSplitConfig.outputJar, OutputMode.DexIndexed, includeDataResources)
                    : DexIndexedConsumer.emptyConsumer());
            for (Path inputPath : featureSplitConfig.inputJars) {
              featureSplitGenerator.addProgramResourceProvider(
                  ArchiveResourceProvider.fromArchive(inputPath, false));
            }
            if (featureSplitConfig.inputResources != null) {
              featureSplitGenerator.setAndroidResourceProvider(
                  new ArchiveProtoAndroidResourceProvider(
                      featureSplitConfig.inputResources,
                      new PathOrigin(featureSplitConfig.inputResources)));
            }
            if (featureSplitConfig.outputResources != null) {
              featureSplitGenerator.setAndroidResourceConsumer(
                  new ArchiveProtoAndroidResourceConsumer(
                      featureSplitConfig.outputResources, featureSplitConfig.inputResources));
            }
            return featureSplitGenerator.build();
          });
    }
  }

  // Represents a set of paths parsed from a string that may contain a ":" (";" on windows).
  // Supported examples are:
  //   pathA -> first = pathA, second = null
  //   pathA:pathB -> first = pathA, second = pathB
  //   :pathB -> first = null, second = pathB
  //   pathA: -> first = pathA, second = null
  private static class PossibleDoublePath {

    public final Path first;
    public final Path second;

    private PossibleDoublePath(Path first, Path second) {
      this.first = first;
      this.second = second;
    }

    public static PossibleDoublePath parse(String input) {
      Path first = null, second = null;
      List<String> inputSplit = StringUtils.split(input, File.pathSeparatorChar);
      if (inputSplit.isEmpty() || inputSplit.size() > 2) {
        throw new IllegalArgumentException("Feature input/output takes one or two paths.");
      }
      String firstString = inputSplit.get(0);
      if (!firstString.isEmpty()) {
        first = Paths.get(firstString);
      }
      if (inputSplit.size() == 2) {
        // "a:".split() gives just ["a"], so we should never get here if we don't have
        // a second string. ":b".split gives ["", "b"] which is handled for first above.
        assert !inputSplit.get(1).isEmpty();
        second = Paths.get(inputSplit.get(1));
      }
      return new PossibleDoublePath(first, second);
    }
  }

  private static class FeatureSplitConfig {
    private final List<Path> inputJars = new ArrayList<>();
    private Path inputResources;
    private Path outputResources;
    private Path outputJar;
  }

  private static class FeatureSplitConfigCollector {

    private final List<FeatureSplitConfig> resourceOnlySplits = new ArrayList<>();
    private final Map<Path, FeatureSplitConfig> withCodeSplits = new HashMap<>();

    public void addInputOutput(String input, String output) {
      PossibleDoublePath inputPaths = PossibleDoublePath.parse(input);
      PossibleDoublePath outputPaths = PossibleDoublePath.parse(output);
      FeatureSplitConfig featureSplitConfig;
      if (outputPaths.first != null) {
        featureSplitConfig =
            withCodeSplits.computeIfAbsent(outputPaths.first, k -> new FeatureSplitConfig());
        featureSplitConfig.outputJar = outputPaths.first;
        // We support adding resources independently of the input jars, which later --feature
        // can add, so we might have no input jars here, example:
        //  ... --feature :input_feature.ap_ out.jar:out_feature.ap_ --feature in.jar out.jar
        if (inputPaths.first != null) {
          featureSplitConfig.inputJars.add(inputPaths.first);
        }
      } else {
        featureSplitConfig = new FeatureSplitConfig();
        resourceOnlySplits.add(featureSplitConfig);
      }
      if (Objects.isNull(inputPaths.second) != Objects.isNull(outputPaths.second)) {
        throw new IllegalArgumentException(
            "Both input and output for feature resources must be provided");
      }
      featureSplitConfig.inputResources = inputPaths.second;
      featureSplitConfig.outputResources = outputPaths.second;
    }

    public Collection<FeatureSplitConfig> getConfigs() {
      ArrayList<FeatureSplitConfig> featureSplitConfigs = new ArrayList<>(resourceOnlySplits);
      featureSplitConfigs.addAll(withCodeSplits.values());
      return featureSplitConfigs;
    }
  }
}