/*
 * Copyright (C) 2012 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.jack;

import com.google.common.base.Joiner;

import com.android.jack.backend.dex.DexFileWriter;
import com.android.jack.backend.dex.MultiDexLegacy;
import com.android.jack.backend.dex.compatibility.AndroidCompatibilityChecker;
import com.android.jack.backend.dex.rop.CodeItemBuilder;
import com.android.jack.config.id.Arzon;
import com.android.jack.config.id.Carnac;
import com.android.jack.config.id.JavaVersionPropertyId;
import com.android.jack.incremental.InputFilter;
import com.android.jack.ir.ast.JMethod;
import com.android.jack.library.DumpInLibrary;
import com.android.jack.library.InputLibrary;
import com.android.jack.library.LibraryPathPropertyId;
import com.android.jack.library.PrebuiltCompatibility;
import com.android.jack.meta.MetaImporter;
import com.android.jack.plugin.JackPluginJarCodec;
import com.android.jack.plugin.NotJackPluginException;
import com.android.jack.plugin.PluginManager;
import com.android.jack.plugin.PluginNotFoundException;
import com.android.jack.reporting.Reportable;
import com.android.jack.reporting.Reportable.ProblemLevel;
import com.android.jack.reporting.Reporter;
import com.android.jack.reporting.Reporter.Severity;
import com.android.jack.resource.ResourceImporter;
import com.android.jack.shrob.obfuscation.MappingPrinter;
import com.android.jack.shrob.obfuscation.NameProviderFactory;
import com.android.jack.shrob.obfuscation.Renamer;
import com.android.jack.shrob.obfuscation.SourceFileRenamer;
import com.android.jack.shrob.obfuscation.annotation.AnnotationRemover;
import com.android.jack.shrob.obfuscation.annotation.ParameterAnnotationRemover;
import com.android.jack.shrob.seed.SeedPrinter;
import com.android.jack.shrob.spec.Flags;
import com.android.jack.transformations.lambda.LambdaGroupingScope;
import com.android.jack.transformations.renamepackage.PackageRenamer;
import com.android.jack.util.AndroidApiLevel;
import com.android.jack.util.AndroidApiLevelCodec;
import com.android.jack.util.ClassNameCodec;
import com.android.jack.util.args4j.JackEnumOptionHandler;
import com.android.jack.util.filter.Filter;
import com.android.sched.reflections.ReflectionFactory;
import com.android.sched.util.RunnableHooks;
import com.android.sched.util.SubReleaseKind;
import com.android.sched.util.codec.CaseInsensitiveDirectFSCodec;
import com.android.sched.util.codec.CodecContext;
import com.android.sched.util.codec.DirectDirOutputVFSCodec;
import com.android.sched.util.codec.DirectoryCodec;
import com.android.sched.util.codec.EnumName;
import com.android.sched.util.codec.InputFileOrDirectoryCodec;
import com.android.sched.util.codec.ListCodec;
import com.android.sched.util.codec.PairCodec;
import com.android.sched.util.codec.PairCodec.Pair;
import com.android.sched.util.codec.PairListToMapCodecConverter;
import com.android.sched.util.codec.ParsingException;
import com.android.sched.util.codec.ReaderFileOrDirectoryCodec;
import com.android.sched.util.codec.StringValueCodec;
import com.android.sched.util.codec.VariableName;
import com.android.sched.util.codec.ZipFSCodec;
import com.android.sched.util.codec.ZipOutputVFSCodec;
import com.android.sched.util.config.Config;
import com.android.sched.util.config.ConfigurationException;
import com.android.sched.util.config.GatherConfigBuilder;
import com.android.sched.util.config.HasKeyId;
import com.android.sched.util.config.PropertyIdException;
import com.android.sched.util.config.category.Private;
import com.android.sched.util.config.id.BooleanPropertyId;
import com.android.sched.util.config.id.EnumPropertyId;
import com.android.sched.util.config.id.ImplementationPropertyId;
import com.android.sched.util.config.id.ListPropertyId;
import com.android.sched.util.config.id.MessageDigestPropertyId;
import com.android.sched.util.config.id.ObjectId;
import com.android.sched.util.config.id.PropertyId;
import com.android.sched.util.config.id.ReflectFactoryPropertyId;
import com.android.sched.util.file.CannotChangePermissionException;
import com.android.sched.util.file.CannotCreateFileException;
import com.android.sched.util.file.Directory;
import com.android.sched.util.file.FileAlreadyExistsException;
import com.android.sched.util.file.FileOrDirectory;
import com.android.sched.util.file.FileOrDirectory.ChangePermission;
import com.android.sched.util.file.FileOrDirectory.Existence;
import com.android.sched.util.file.FileOrDirectory.Permission;
import com.android.sched.util.file.FileUtils;
import com.android.sched.util.file.Files;
import com.android.sched.util.file.InputJarFile;
import com.android.sched.util.file.NoSuchFileException;
import com.android.sched.util.file.NotDirectoryException;
import com.android.sched.util.file.OutputZipFile.Compression;
import com.android.sched.util.file.WriterFile;
import com.android.sched.util.file.WrongPermissionException;
import com.android.sched.util.location.FileLocation;
import com.android.sched.util.location.NoLocation;
import com.android.sched.util.location.StringLocation;
import com.android.sched.util.log.LoggerFactory;
import com.android.sched.util.log.TracerFactory;
import com.android.sched.util.log.tracer.StatsTracerFtl;
import com.android.sched.vfs.Container;
import com.android.sched.vfs.OutputVFSPropertyId;
import com.android.sched.vfs.VFSPropertyId;

import org.kohsuke.args4j.Argument;
import org.kohsuke.args4j.Option;
import org.kohsuke.args4j.spi.ExplicitBooleanOptionHandler;
import org.kohsuke.args4j.spi.MapOptionHandler;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;

/**
 * Jack command line options Bean
 */
@HasKeyId
public class Options {

  @Nonnull
  private static final Logger logger = LoggerFactory.getLogger();

  private static class DeprecatedVerbosity implements Reportable {
    @Nonnull
    private final VerbosityLevel verbosity;

    private DeprecatedVerbosity(@Nonnull VerbosityLevel verbosity) {
      this.verbosity = verbosity;
    }

    @Override
    @Nonnull
    public String getMessage() {
      return "Verbosity level '" + verbosity.name().toLowerCase() + "' is deprecated";
    }

    @Override
    @Nonnull
    public ProblemLevel getDefaultProblemLevel() {
      return ProblemLevel.WARNING;
    }

  }

  /**
   * Assertion policies
   */
  @VariableName("policy")
  public enum AssertionPolicy {
    @EnumName(name = "always", description = "always check assert statements")
    ALWAYS,
    @EnumName(name = "never", description = "remove assert statements")
    NEVER,
    @EnumName(name = "runtime", description = "check according to runtime configuration")
    RUNTIME;
  }

  @Nonnull
  public static final EnumPropertyId<AssertionPolicy> ASSERTION_POLICY =
      EnumPropertyId.create(
              "jack.assert.policy",
              "Assert statement policy",
              AssertionPolicy.class)
          .addDefaultValue(AssertionPolicy.RUNTIME)
          .ignoreCase()
          .addCategory(DumpInLibrary.class)
          .addCategory(PrebuiltCompatibility.class)
          .addCategory(Carnac.class);

  @Nonnull
  public static final BooleanPropertyId INCREMENTAL_MODE = BooleanPropertyId
      .create("jack.incremental", "Enable incremental mode")
      .addDefaultValue(Boolean.FALSE).addCategory(DumpInLibrary.class);

  @Nonnull
  public static final ReflectFactoryPropertyId<InputFilter> INPUT_FILTER = ReflectFactoryPropertyId
      .create("jack.input.filter", "Inputs filter", InputFilter.class)
      .addDefaultValue("no-filter").addArgType(Options.class);

  @Nonnull
  public static final JavaVersionPropertyId JAVA_SOURCE_VERSION =
      JavaVersionPropertyId.create("jack.java.source.version", "Java source version")
          .addDefaultValue("1.7").addCategory(Arzon.class).addCategory(DumpInLibrary.class);

  @Nonnull
  public static final BooleanPropertyId LAMBDA_TO_ANONYMOUS_CONVERTER = BooleanPropertyId
      .create("jack.lambda.anonymous", "Enable lambda support with an anonymous class")
      .addDefaultValue(Boolean.TRUE)
      .addCategory(DumpInLibrary.class)
      .addCategory(PrebuiltCompatibility.class);

  @Nonnull
  public static final EnumPropertyId<LambdaGroupingScope> LAMBDA_GROUPING_SCOPE = EnumPropertyId
      .create(
          "jack.lambda.grouping-scope", "Defines the scope for lambda grouping",
          LambdaGroupingScope.class)
      .ignoreCase()
      .addDefaultValue(LambdaGroupingScope.NONE)
      .requiredIf(LAMBDA_TO_ANONYMOUS_CONVERTER.getValue().isTrue())
      .addCategory(DumpInLibrary.class)
      .addCategory(PrebuiltCompatibility.class)
      .addCategory(Private.class);

  @Nonnull
  public static final MessageDigestPropertyId LAMBDA_NAME_DIGEST_ALGO = MessageDigestPropertyId
      .create("jack.lambda.name.digest.algo", "Digest algorithm use for lambda class name")
      .requiredIf(LAMBDA_TO_ANONYMOUS_CONVERTER.getValue().isTrue()).addDefaultValue("SHA");

  @Nonnull
  public static final BooleanPropertyId LAMBDA_MERGE_INTERFACES = BooleanPropertyId
      .create("jack.lambda.merge-interfaces",
          "Allows merging functional interfaces")
      .addDefaultValue(Boolean.FALSE)
      .requiredIf(Options.LAMBDA_TO_ANONYMOUS_CONVERTER.getValue().isTrue())
      .addCategory(DumpInLibrary.class)
      .addCategory(PrebuiltCompatibility.class)
      .addCategory(Private.class);

  @Nonnull
  public static final BooleanPropertyId LAMBDA_SIMPLIFY_STATELESS = BooleanPropertyId
      .create("jack.lambda.simplify-stateless",
          "Simplifies stateless lambda to use single-instance implementation")
      .addDefaultValue(Boolean.FALSE)
      .requiredIf(Options.LAMBDA_TO_ANONYMOUS_CONVERTER.getValue().isTrue())
      .addCategory(DumpInLibrary.class)
      .addCategory(PrebuiltCompatibility.class)
      .addCategory(Private.class);

  @Nonnull
  public static final BooleanPropertyId GENERATE_JACK_LIBRARY = BooleanPropertyId.create(
      "jack.library", "Generate jack library").addDefaultValue(Boolean.FALSE);

  @Nonnull
  public static final BooleanPropertyId GENERATE_DEX_FILE =
      BooleanPropertyId.create("jack.dex", "Generate dex file").addDefaultValue(Boolean.FALSE)
          .addCategory(DumpInLibrary.class);

  /**
   * property used to specify the kind of switch enum optimization that is enabled. See(@link
   * SwitchEnumOptStrategy)
   */
  @Nonnull
  public static final EnumPropertyId<SwitchEnumOptStrategy> OPTIMIZED_ENUM_SWITCH =
      EnumPropertyId.create(
              "jack.optimization.enum.switch", "Optimize enum switch", SwitchEnumOptStrategy.class)
          .addDefaultValue(SwitchEnumOptStrategy.NEVER)
          .ignoreCase()
          .addCategory(DumpInLibrary.class)
          .addCategory(PrebuiltCompatibility.class);

  @Nonnull
  public static final BooleanPropertyId GENERATE_DEX_IN_LIBRARY = BooleanPropertyId
      .create("jack.library.dex", "Generate dex files in library").addDefaultValue(Boolean.TRUE)
      .requiredIf(GENERATE_JACK_LIBRARY.getValue().isTrue());

  @Nonnull
  public static final BooleanPropertyId USE_PREBUILT_FROM_LIBRARY =
      BooleanPropertyId.create("jack.library.prebuilt.use", "Use prebuilt files from library")
          .addDefaultValue(Boolean.TRUE)
          .requiredIf(
              GENERATE_DEX_FILE.getValue().isTrue().or(GENERATE_JACK_LIBRARY.getValue().isTrue()))
      .addCategory(DumpInLibrary.class);

  @Nonnull
  public static final BooleanPropertyId GENERATE_JAYCE_IN_LIBRARY = BooleanPropertyId
      .create("jack.library.jayce", "Generate Jayce files in library")
      .addDefaultValue(Boolean.FALSE).addCategory(Private.class)
      .requiredIf(GENERATE_JACK_LIBRARY.getValue().isTrue());

  @Nonnull
  public static final BooleanPropertyId GENERATE_DEPENDENCIES_IN_LIBRARY = BooleanPropertyId
      .create("jack.library.dependencies", "Generate Dependency files in library")
      .addDefaultValue(Boolean.FALSE).addCategory(Private.class)
      .requiredIf(GENERATE_JACK_LIBRARY.getValue().isTrue());

  @Nonnull
  public static final
      BooleanPropertyId GENERATE_LIBRARY_FROM_INCREMENTAL_FOLDER = BooleanPropertyId.create(
          "jack.library.from-incremental-folder",
          "Generate a jack library from the incremental folder").addDefaultValue(Boolean.FALSE)
          .addCategory(Private.class);

  @Nonnull
  public static final EnumPropertyId<Container> DEX_OUTPUT_CONTAINER_TYPE =
      EnumPropertyId.create("jack.dex.output.container", "Output container type", Container.class)
          .ignoreCase().requiredIf(GENERATE_DEX_FILE.getValue().isTrue());

  @Nonnull
  public static final EnumPropertyId<Container> LIBRARY_OUTPUT_CONTAINER_TYPE = EnumPropertyId
      .create("jack.library.output.container", "Library output container type", Container.class)
      .ignoreCase().requiredIf(GENERATE_JACK_LIBRARY.getValue().isTrue());

  @Nonnull
  public static final VFSPropertyId LIBRARY_OUTPUT_ZIP = VFSPropertyId
      .create("jack.library.output.zip", "Output zip archive for library",
          new ZipFSCodec(Existence.MAY_EXIST, Compression.UNCOMPRESSED).setInfoString("output-lib"))
      .requiredIf(GENERATE_JACK_LIBRARY.getValue().isTrue()
          .and(LIBRARY_OUTPUT_CONTAINER_TYPE.is(Container.ZIP))
          .or(GENERATE_LIBRARY_FROM_INCREMENTAL_FOLDER.getValue().isTrue()));

  @Nonnull
  public static final VFSPropertyId LIBRARY_OUTPUT_DIR =
      VFSPropertyId.create(
              "jack.library.output.dir",
              "Output folder for library",
              new CaseInsensitiveDirectFSCodec(Existence.MUST_EXIST).setInfoString("output-lib"))
          .withoutAutoAction()
          .requiredIf(
              GENERATE_JACK_LIBRARY
                  .getValue()
                  .isTrue()
                  .and(LIBRARY_OUTPUT_CONTAINER_TYPE.is(Container.DIR)));

  @Nonnull
  public static final OutputVFSPropertyId DEX_OUTPUT_DIR = OutputVFSPropertyId.create(
      "jack.dex.output.dir", "Output folder for dex",
      new DirectDirOutputVFSCodec(Existence.MUST_EXIST).setInfoString("output-dex"))
      .withoutAutoAction().requiredIf(
      DEX_OUTPUT_CONTAINER_TYPE.is(Container.DIR));

  @Nonnull
  public static final OutputVFSPropertyId DEX_OUTPUT_ZIP = OutputVFSPropertyId.create(
      "jack.dex.output.zip", "Output zip archive for dex",
      new ZipOutputVFSCodec(Existence.MAY_EXIST).setInfoString("output-dex")).requiredIf(
      DEX_OUTPUT_CONTAINER_TYPE.is(Container.ZIP));

  @Nonnull
  public static final LibraryPathPropertyId IMPORTED_LIBRARIES =
      new LibraryPathPropertyId("jack.library.import", "Libraries to import", "imported-lib")
          .withoutAutoAction()
          .addDefaultValue(Collections.<InputLibrary>emptyList());

  @Nonnull
  public static final LibraryPathPropertyId CLASSPATH =
      new LibraryPathPropertyId("jack.classpath", "Classpath", "classpath-lib")
          .withoutAutoAction()
          .addDefaultValue(Collections.<InputLibrary>emptyList());

  @Nonnull
  public static final BooleanPropertyId ENABLE_COMPILED_FILES_STATISTICS = BooleanPropertyId.create(
      "jack.statistic.source", "Enable compiled files statistics").addDefaultValue(
      Boolean.FALSE);

  @Nonnull
  public static final BooleanPropertyId ANNOTATION_PROCESSOR_ENABLED =
      BooleanPropertyId.create(
        "jack.annotation-processor", "Enable annotation processors")
        .addDefaultValue(true).addCategory(DumpInLibrary.class);

  @Option(name = "--version", usage = "display version")
  private boolean version;

  @Option(name = "--help", usage = "display help")
  private boolean help;

  @Option(name = "--help-properties", usage = "display properties list")
  private boolean helpProperties;

  @Option(name = "-D", metaVar = "<property>=<value>",
      usage = "set value for the given property (repeatable)",
      handler = MapOptionHandler.class)
  @Nonnull
  private final Map<String, String> properties = new HashMap<String, String>();

  @Option(name = "-A", metaVar = "<option>=<value>",
      usage = "set option for annotation processors (repeatable)",
      handler = MapOptionHandler.class)
  @CheckForNull
  private Map<String, String> annotationProcessorOption;

  @Nonnull
  public static final PropertyId<Map<String, String>> ANNOTATION_PROCESSOR_OPTIONS = PropertyId
      .create(
          "jack.annotation-processor.options",
          "Options for annotation processors",
          new PairListToMapCodecConverter<String, String>(new ListCodec<Pair<String, String>>(
              new PairCodec<String, String>(new StringValueCodec(
                  "an annotation processor option name", "option"), new StringValueCodec(
                  "an annotation processor option value", "value"))).setMin(0))).addDefaultValue(
          Collections.<String, String>emptyMap());

  private final File propertiesFile = null;

  /**
   * Jack verbosity level.
   * Note: The implementation of {@link ProblemLevel} assumes that the ordinal values of
   * {@link VerbosityLevel} are ordered from the highest severity to the lowest.
   */
  @VariableName("level")
  public enum VerbosityLevel {
    @EnumName(name = "error")
    ERROR("error"),
    @EnumName(name = "warning")
    WARNING("warning"),
    @EnumName(name = "info")
    INFO("info"),
    @EnumName(name = "debug", hide = true)
    @Deprecated DEBUG("debug"),
    @EnumName(name = "trace", hide = true)
    @Deprecated TRACE("trace");

    @Nonnull
    private final String id;

    VerbosityLevel(@Nonnull String id) {
      this.id = id;
    }

    public String getId() {
      return id;
    }
  }

  /**
   * Types of switch enum optimization strategies.
   * 1. feedback (set on by default)
   * 2. always
   * 3. never
   */
  @VariableName("strategy")
  public enum SwitchEnumOptStrategy {
    // feedback-based optimization: this strategy will be enabled/disabled based on the
    // compile time information collected, e.g., if it is detected that an enum is only
    // used in one/few switch statements, it is useless to optimize it. Potentially enable
    // this strategy will cost more compilation time, but save more dex code
    @EnumName(name = "feedback")
    FEEDBACK(),
    // different from feedback-based optimization, always strategy doesn't collect compile-
    // time information to guide switch enum optimization. It will always enable switch enum
    // optimization no matter the enum is rarely/frequently used. Ideally this strategy will
    // compile code quicker than feedback-based strategy does, but the generated dex may be
    // larger than feedback strategy
    @EnumName(name = "always")
    ALWAYS(),
    // this actually is not real strategy, but we still need it because switch enum
    // optimization is disabled when incremental compilation is triggered
    @EnumName(name = "never")
    NEVER();
  }

  @Nonnull
  public static final EnumPropertyId<VerbosityLevel> VERBOSITY_LEVEL = EnumPropertyId.create(
      "jack.verbose.level", "Verbosity level", VerbosityLevel.class)
      .addDefaultValue(VerbosityLevel.WARNING);

  @Option(name = "--verbose", usage = "set verbosity (default: warning)",
      handler = JackEnumOptionHandler.class)
  private VerbosityLevel verbose = VerbosityLevel.WARNING;

  /**
   * Folder used for incremental data.
   */
  @Option(name = "--incremental-folder", usage = "directory used for incremental data",
      metaVar = "<DIRECTORY>")
  private File incrementalFolder = null;

  @Option(name = "--output-dex", usage = "output dex files and resources to the directory",
      metaVar = "<DIRECTORY>")
  private File out = null;

  /**
   * Output to this zip file.
   */
  @Option(name = "--output-dex-zip", metaVar = "<FILE>")
  private File outZip = null;

  /**
   * Output jack library to this folder.
   */
  private File libraryOutDir = null;

  @Option(name = "--output-jack", usage = "output jack library file", metaVar = "<FILE>")
  private File libraryOutZip = null;

  @Option(name = "--config-jarjar", usage = "use jarjar rules files (default: none)",
      metaVar = "<FILE>")
  private List<File> jarjarRulesFiles = new ArrayList<File>(0);

  @Option(name = "--import", usage = "import the given file into the output (repeatable)",
      metaVar = "<FILE>")
  protected List<File> importedLibraries = new ArrayList<File>();

  @Option(name = "--import-resource",
      usage = "import the given directory into the output as resource files (repeatable)",
      metaVar = "<DIRECTORY>")
  private List<File> resImport = new ArrayList<File>();

  @Option(name = "--import-meta",
      usage = "import the given directory into the output as meta-files (repeatable)",
      metaVar = "<DIRECTORY>")
  private List<File> metaImport = new ArrayList<File>();

  @Option(name = "--config-proguard",
      usage = "use a proguard flags file (default: none) (repeatable)",
      metaVar = "<FILE>")
  protected List<File> proguardFlagsFiles = null;

  /**
   * Enable/disable compiler sanity checks.
   */
  @Option(name = "--sanity-checks",
      handler = ExplicitBooleanOptionHandler.class, metaVar = "[on | off]")
  private boolean sanityChecks =
      Jack.getVersion().getSubReleaseKind() == SubReleaseKind.ENGINEERING;
  @Nonnull
  public static final BooleanPropertyId SANITY_CHECKS =
      BooleanPropertyId.create("jack.sanity-checks", "Compiler sanity checks")
          .addCategory(DumpInLibrary.class)
          .addDefaultValue(Jack.getVersion().getSubReleaseKind() == SubReleaseKind.ENGINEERING);

  /**
   * Enable tracer and output into this dir (.html).
   */
  @Option(name = "--tracer-dir",
      metaVar = "<DIRECTORY>")
  private File tracerDir;

  /*
   * Annotation processor
   */

  @Option(name = "--processorpath", usage = "annotation processor classpath", metaVar = "<PATH>")
  @CheckForNull
  private String processorPath;

  @Option(name = "--processor", usage = "annotation processor class names",
      metaVar = "<NAME>[,<NAME>...]")
  @CheckForNull
  private String processor;

  @Nonnull
  public static final BooleanPropertyId ANNOTATION_PROCESSOR_MANUAL =
      BooleanPropertyId.create(
        "jack.annotation-processor.manual", "run only specified annotation processors")
        .addDefaultValue(false).addCategory(DumpInLibrary.class);

  @Nonnull
  public static final ListPropertyId<String> ANNOTATION_PROCESSOR_MANUAL_LIST =
      new ListPropertyId<String>("jack.annotation-processor.manual.list",
          "Annotation processor class names", new ClassNameCodec()).minElements(0)
              .requiredIf(ANNOTATION_PROCESSOR_MANUAL.getValue().isTrue());

  @Nonnull
  public static final PropertyId<Directory> ANNOTATION_PROCESSOR_SOURCE_OUTPUT_DIR =
    PropertyId.create(
      "jack.annotation-processor.source.output",
      "Output folder for sources generated by annotation processors",
      new DirectoryCodec(Existence.MUST_EXIST, Permission.WRITE | Permission.READ));

  @Nonnull
  public static final PropertyId<Directory> ANNOTATION_PROCESSOR_CLASS_OUTPUT_DIR =
    PropertyId.create(
      "jack.annotation-processor.class.output",
      "Output folder for classes generated by annotation processors",
      new DirectoryCodec(Existence.MUST_EXIST, Permission.WRITE | Permission.READ));

  @Nonnull
  public static final BooleanPropertyId ANNOTATION_PROCESSOR_PATH =
      BooleanPropertyId.create(
        "jack.annotation-processor.path",
        "Use annotation processor classpath for annotation processor loading")
        .addDefaultValue(false);

  @Nonnull
  public static final ListPropertyId<FileOrDirectory> ANNOTATION_PROCESSOR_PATH_LIST =
      new ListPropertyId<FileOrDirectory>("jack.annotation-processor.path.list",
          "Annotation processor classpath", new InputFileOrDirectoryCodec()).on(File.pathSeparator)
          .minElements(0).requiredIf(ANNOTATION_PROCESSOR_PATH.getValue().isTrue());

  /*
   *
   */

  @Nonnull
  public static final BooleanPropertyId USE_DEFAULT_LIBRARIES = BooleanPropertyId.create(
      "jack.classpath.default-libraries", "Use default libraries as first classpath entries")
      .addDefaultValue(Boolean.TRUE).addCategory(DumpInLibrary.class);

  @Nonnull
  public static final ListPropertyId<FileOrDirectory> SOURCE_PATH =
      new ListPropertyId<FileOrDirectory>("jack.source.path",
          "Source path", new InputFileOrDirectoryCodec()).on(File.pathSeparator)
          .minElements(0).addDefaultValue(Collections.<FileOrDirectory>emptyList());

  @Nonnull
  @Option(name = "-cp", aliases = "--classpath", usage = "set classpath", metaVar = "<PATH>")
  protected String classpath = "";

  // This is a trick to document @<FILE>, but it has no real link to ecjArguments
  @Argument(usage = "read command line from file", metaVar = "@<FILE>")
  @CheckForNull
  protected List<File> inputSources;

  @Nonnull
  public static final ListPropertyId<FileOrDirectory> SOURCES =
      new ListPropertyId<FileOrDirectory>("jack.source", "Sources to compile",
          new ReaderFileOrDirectoryCodec()).on(File.pathSeparator).minElements(0)
          .addDefaultValue(Collections.<FileOrDirectory>emptyList());

  @Nonnull
  private final List<String> ecjExtraArguments = new ArrayList<String>();

  @Option(name = "-g", usage = "emit debug infos")
  private Boolean emitLocalDebugInfo;

  /**
   * Available mode for the multidex feature
   */
  public enum MultiDexKind {
    NONE,
    NATIVE,
    LEGACY
  }

  @Option(name = "--multi-dex",
      usage = "whether to split code into multiple dex files (default: none)",
      handler = JackEnumOptionHandler.class)
  private MultiDexKind multiDexKind = MultiDexKind.NONE;

  @Nonnull
  public static final BooleanPropertyId OPTIMIZE_INNER_CLASSES_ACCESSORS = BooleanPropertyId.create(
      "jack.optimization.inner-class.accessors",
      "Avoid creating synthethic accessors for outer class private fields and methods")
      .addDefaultValue(Boolean.FALSE).addCategory(DumpInLibrary.class);

  @Nonnull
  public static final BooleanPropertyId OPTIMIZE_TAIL_RECURSION =
      BooleanPropertyId.create("jack.optimization.tail-recursion", "Optimize tail recursive calls")
          .addDefaultValue(Boolean.FALSE)
          .addCategory(DumpInLibrary.class)
          .addCategory(PrebuiltCompatibility.class);

  @Nonnull
  public static final BooleanPropertyId EMIT_LOCAL_DEBUG_INFO =
      BooleanPropertyId.create(
              "jack.dex.debug.vars", "Emit local variable debug info into generated dex")
          .addDefaultValue(Boolean.FALSE)
          .addCategory(DumpInLibrary.class)
          .addCategory(PrebuiltCompatibility.class);

  @Nonnull
  public static final BooleanPropertyId EMIT_LINE_NUMBER_DEBUG_INFO =
      BooleanPropertyId.create(
              "jack.dex.debug.lines", "Emit line number debug info into generated dex")
          .addDefaultValue(Boolean.TRUE)
          .addCategory(DumpInLibrary.class)
          .addCategory(PrebuiltCompatibility.class);

  @Nonnull
  public static final BooleanPropertyId EMIT_SOURCE_FILE_DEBUG_INFO =
      BooleanPropertyId.create(
              "jack.dex.debug.source", "Emit source file debug info into generated dex")
          .addDefaultValue(Boolean.TRUE)
          .addCategory(DumpInLibrary.class)
          .addCategory(PrebuiltCompatibility.class);

  @Nonnull
  public static final PropertyId<AndroidApiLevel> ANDROID_MIN_API_LEVEL = PropertyId
      .create("jack.android.min-api-level", "Minimum Android API level compatibility",
          new AndroidApiLevelCodec())
      .addDefaultValue(new AndroidApiLevel(AndroidApiLevel.ReleasedLevel.B))
      .addCategory(DumpInLibrary.class)
      .addCategory(Carnac.class)
      .addCategory(new PrebuiltCompatibility() {
        @Override
        public boolean isCompatible(@Nonnull Config config, @Nonnull String valueFromLibrary)
            throws ParsingException {
          AndroidApiLevel levelFromLib = config.parseAs(valueFromLibrary, ANDROID_MIN_API_LEVEL);
          AndroidApiLevel levelFromConf = config.get(ANDROID_MIN_API_LEVEL);

          if (levelFromLib.isReleasedLevel() && levelFromConf.isReleasedLevel()) {
            return levelFromLib.getReleasedLevel() <= levelFromConf.getReleasedLevel();
          } else if (!levelFromLib.isReleasedLevel() && !levelFromConf.isReleasedLevel()) {
            return levelFromLib.getProvisionalLevel() == levelFromConf.getProvisionalLevel();
          } else {
            return false;
          }
        }
      });

  @Nonnull
  public static final BooleanPropertyId DROP_METHOD_BODY = BooleanPropertyId.create(
      "jack.internal.dropmethodbody", "Drop method bodies when they are no longer useful")
      .addDefaultValue(Boolean.TRUE);

  @Nonnull
  public static final BooleanPropertyId SHRINKING_ENABLED =
      BooleanPropertyId.create("jack.shrob.shrink", "Enable shrinking feature")
      .addDefaultValue(false).addCategory(DumpInLibrary.class);

  @Nonnull
  public static final BooleanPropertyId OBFUSCATION_ENABLED =
      BooleanPropertyId.create("jack.shrob.obfuscate", "Enable obfuscation feature")
      .addDefaultValue(false).addCategory(DumpInLibrary.class);

  @CheckForNull
  protected Flags flags = null;

  @Nonnull
  public static final ObjectId<Flags> FLAGS = new ObjectId<Flags>("jack.shrob.flags", Flags.class);

  @Nonnull
  public static final BooleanPropertyId USE_MIXED_CASE_CLASSNAME =
      BooleanPropertyId
          .create("jack.obfuscation.mixedcaseclassname",
              "Use mixed case class name when obfuscating")
          .addDefaultValue(Boolean.FALSE).addCategory(DumpInLibrary.class);

  @Nonnull
  public static final BooleanPropertyId EMIT_CLASS_FILES =
      BooleanPropertyId.create("jack.class-file", "Generate class files")
      .addDefaultValue(false);

  @Nonnull
  public static final PropertyId<Directory> EMIT_CLASS_FILES_FOLDER =
    PropertyId.create(
      "jack.class-file.output.dir",
      "Output folder for class files",
      new DirectoryCodec(Existence.MUST_EXIST, Permission.WRITE | Permission.READ))
    .requiredIf(EMIT_CLASS_FILES.getValue().isTrue());

  @SuppressWarnings("unchecked")
  @Nonnull
  public static final ImplementationPropertyId<Filter<JMethod>> METHOD_FILTER =
      (ImplementationPropertyId<Filter<JMethod>>) (Object) ImplementationPropertyId.create(
          "jack.internal.filter.method", "Define which filter will be used for methods",
          Filter.class).addDefaultValue("all-methods");

  @CheckForNull
  private OutputStream reporterStream = null;

  /*
   * CodecContext
   */

  @CheckForNull
  private File workingDirectory = null;

  @CheckForNull
  private PrintStream standardError = null;

  @CheckForNull
  private PrintStream standardOutput = null;

  public void setWorkingDirectory(@Nonnull File workingDirectory) {
    this.workingDirectory = workingDirectory;
  }

  public void setStandardError(@Nonnull PrintStream standardError) {
    this.standardError = standardError;
  }

  public void setStandardOutput(@Nonnull PrintStream standardOutput) {
    this.standardOutput = standardOutput;
  }

  @CheckForNull
  private Charset defaultCharset = null;

  public void setDefaultCharset(@Nonnull Charset charset) {
    this.defaultCharset = charset;
  }

  @CheckForNull
  private CodecContext codecContext = null;

  @Nonnull
  private CodecContext getCodecContext() throws IllegalOptionsException {
    if (codecContext == null) {
      codecContext = new CodecContext();

      if (workingDirectory != null) {
        try {
          codecContext.setWorkingDirectory(workingDirectory);
        } catch (NotDirectoryException e) {
          throw new IllegalOptionsException(e.getMessage(), e);
        } catch (WrongPermissionException e) {
          throw new IllegalOptionsException(e.getMessage(), e);
        } catch (NoSuchFileException e) {
          throw new IllegalOptionsException(e.getMessage(), e);
        }
      }

      if (standardError != null) {
        codecContext.setStandardError(standardError);
      }

      if (standardOutput != null) {
        codecContext.setStandardOutput(standardOutput);
      }

      if (defaultCharset != null) {
        codecContext.setDefaultCharset(defaultCharset);
      }

      if (sanityChecks) {
        codecContext.setDebug();
      }
    }

    assert codecContext != null;
    return codecContext;
  }

  /*
   * Plugin Manager
   */

  @Option(name = "--list-plugins", usage = "display all available plugins")
  private boolean listPlugins;

  @Option(name = "--pluginpath", usage = "jack plugin classpath", metaVar = "<PATH>")
  @Nonnull
  private String pluginPath = "";

  @Option(name = "--plugin", usage = "jack plugin names", metaVar = "<NAME>[,<NAME>...] (unique)")
  @Nonnull
  private String pluginNames = "";

  public void setPluginPath(@CheckForNull String pluginPath) {
    if (pluginPath == null) {
      this.pluginPath = "";
    } else {
      this.pluginPath = pluginPath;
    }
  }

  public void setPluginNames(@Nonnull String pluginNames) {
    this.pluginNames = pluginNames;
  }

  @CheckForNull
  private PluginManager pluginManager = null;

  @Nonnull
  public static final ListCodec<InputJarFile> PLUGIN_PATH_CODEC =
      new ListCodec<InputJarFile>(new JackPluginJarCodec()).setSeparator(File.pathSeparator);

  @Nonnull
  public static final ListCodec<String> PLUGIN_NAMES_CODEC =
      new ListCodec<String>(new StringValueCodec("a Jack plugin name", "plugin"))
          .setSeparator(",")
          .ensureUnicity();

  public void ensurePluginManager()
      throws IllegalOptionsException {
    if (pluginManager == null) {
      List<InputJarFile> jars;
      try {
        jars = PLUGIN_PATH_CODEC.checkString(getCodecContext(), pluginPath);
        if (jars == null) {
          jars = PLUGIN_PATH_CODEC.parseString(getCodecContext(), pluginPath);
        }
        pluginManager = new PluginManager();
        try {
          for (InputJarFile jar : jars) {
            pluginManager.addPlugin(new URL[]{jar.getFile().toURI().toURL()});
          }
        } catch (NotJackPluginException | MalformedURLException e) {
          throw new AssertionError(e);
        }
      } catch (ParsingException e) {
        throw new IllegalOptionsException("option --pluginpath: " + e.getMessage(), e);
      }

      try {
        List<String> names = PLUGIN_NAMES_CODEC.checkString(getCodecContext(), pluginNames);
        if (names == null) {
          names = PLUGIN_NAMES_CODEC.parseString(getCodecContext(), pluginNames);
        }
        for (String name : names) {
          try {
            assert pluginManager != null;
            pluginManager.loadPlugin(name);
          } catch (PluginNotFoundException e) {
            throw new IllegalOptionsException("option --plugin: " + e.getMessage(), e);
          }
        }
      } catch (ParsingException e) {
        throw new IllegalOptionsException("option --plugin: " + e.getMessage(), e);

      }
    }
  }

  @Nonnull
  public PluginManager getPluginManager() {
    assert pluginManager != null;
    return pluginManager;
  }

  /*
   *
   */

  public void setVerbosityLevel(@Nonnull VerbosityLevel verbose) {
    this.verbose = verbose;
  }

  public boolean askForVersion() {
    return version;
  }

  public boolean askForHelp() {
    return help;
  }

  public boolean askForPropertiesHelp() {
    return helpProperties;
  }

  public boolean askForPluginsList() {
    return listPlugins;
  }

  public void setInputSources(@Nonnull Collection<File> inputSources) {
    this.inputSources = new ArrayList<File>(inputSources);
  }

  public void setOutputDir(File out) {
    this.out = out;
  }

  public void setOutputZip(File out) {
    this.outZip = out;
  }

  @CheckForNull
  private Config config = null;

  @Nonnull
  public Config getConfig() {
    assert config != null;

    return config;
  }

  @Nonnull
  public GatherConfigBuilder getDefaultConfigBuilder()
      throws IOException, IllegalOptionsException {
    ensurePluginManager();

    GatherConfigBuilder configBuilder = new GatherConfigBuilder(sanityChecks,
        getPluginManager().getReflectionManager(ReflectionFactory.getManager()));
    assert codecContext != null; // ensured by ensurePluginManager()
    configBuilder.setCodecContext(codecContext);
    String resourceName = "/config.properties";

    InputStream is = Main.class.getResourceAsStream(resourceName);
    if (is != null) {
      try {
        configBuilder.load(is, new StringLocation("resource " + resourceName));
      } finally {
        is.close();
      }
    }

    return configBuilder;
  }

  @Nonnull
  public GatherConfigBuilder getConfigBuilder(@Nonnull RunnableHooks hooks)
      throws IllegalOptionsException {

    GatherConfigBuilder configBuilder;

    if (propertiesFile != null) {
      if (!propertiesFile.exists()) {
        throw new IllegalOptionsException(
            "The specified config file '" + propertiesFile.getPath() + "' does not exist.");
      }

      if (!propertiesFile.isFile()) {
        throw new IllegalOptionsException(
            "The specified config file '" + propertiesFile.getPath() + "' is not a file.");
      }

      if (!propertiesFile.canRead()) {
        throw new IllegalOptionsException(
            "The specified config file '" + propertiesFile.getPath() + "' cannot be read.");
      }

      ensurePluginManager();
      configBuilder = new GatherConfigBuilder(sanityChecks,
          getPluginManager().getReflectionManager(ReflectionFactory.getManager()));
      configBuilder.setCodecContext(getCodecContext());

      try {
        InputStream is = new BufferedInputStream(new FileInputStream(propertiesFile));
        try {
          configBuilder.load(is, new FileLocation(propertiesFile));
        } finally {
          is.close();
        }
      } catch (FileNotFoundException e) {
        // Already check
        throw new AssertionError();
      } catch (IOException e) {
        throw new IllegalOptionsException(
            "The specified config file '" + propertiesFile.getPath() + "' cannot be read.",
            e.getCause());
      }
    } else {
      try {
        configBuilder = getDefaultConfigBuilder();
      } catch (IOException e) {
        throw new IllegalOptionsException(e.getMessage(), e);
      }
    }


    configBuilder.pushDefaultLocation(new StringLocation("Options"));

    configBuilder.set(VERBOSITY_LEVEL, verbose);

    if (reporterStream != null) {
      configBuilder.set(Reporter.REPORTER_WRITER,
          new WriterFile(reporterStream, new NoLocation()));
    }

    if (!jarjarRulesFiles.isEmpty()) {
      configBuilder.set(PackageRenamer.JARJAR_ENABLED, true);
      String sep = PackageRenamer.JARJAR_FILES.getCodec().getSeparator();
      configBuilder.setString(PackageRenamer.JARJAR_FILES, Joiner.on(sep).join(jarjarRulesFiles));
      configBuilder.set(Options.USE_PREBUILT_FROM_LIBRARY, false);
      logger.log(Level.WARNING,
          "Prebuilts from libraries are not used due to usage of jarjar");
    }

    if (processor != null) {
      configBuilder.set(ANNOTATION_PROCESSOR_MANUAL, true);
      configBuilder.setString(ANNOTATION_PROCESSOR_MANUAL_LIST, processor);
    }
    configBuilder.set(ANNOTATION_PROCESSOR_SOURCE_OUTPUT_DIR, createTempDir(hooks));
    Directory annotationProcessorOutputClasses = createTempDir(hooks);
    configBuilder.set(ANNOTATION_PROCESSOR_CLASS_OUTPUT_DIR, annotationProcessorOutputClasses);
    addResource(annotationProcessorOutputClasses.getFile());
    if (processorPath != null) {
      configBuilder.set(ANNOTATION_PROCESSOR_PATH, true);
      configBuilder.setString(ANNOTATION_PROCESSOR_PATH_LIST, processorPath);
    }

    if (annotationProcessorOption != null) {
      configBuilder.set(ANNOTATION_PROCESSOR_OPTIONS, annotationProcessorOption);
    }

    if (!resImport.isEmpty()) {
      configBuilder.setString(ResourceImporter.IMPORTED_RESOURCES,
          Joiner.on(File.pathSeparator).join(resImport));
    }

    if (!metaImport.isEmpty()) {
      configBuilder.setString(MetaImporter.IMPORTED_META,
          Joiner.on(File.pathSeparator).join(metaImport));
    }

    if (inputSources != null && !inputSources.isEmpty()) {
      configBuilder.setString(SOURCES, Joiner.on(File.pathSeparator).join(inputSources));
    }

    if (emitLocalDebugInfo != null) {
      configBuilder.set(EMIT_LOCAL_DEBUG_INFO, emitLocalDebugInfo);
    }

    configBuilder.pushDefaultLocation(new StringLocation("proguard flags"));

    configBuilder.set(SHRINKING_ENABLED, flags != null && flags.shrink());
    configBuilder.set(OBFUSCATION_ENABLED, flags != null && flags.obfuscate());

    if (flags != null) {
      if (flags.obfuscate() || flags.shrink()) {
        configBuilder.set(Options.USE_PREBUILT_FROM_LIBRARY, false);
        logger
            .log(
                Level.WARNING,
                "Prebuilts from libraries are not use due to usage of shrinking or obfuscation");
      }

      if (flags.obfuscate()) { // keepAttribute only makes sense when obfuscating
        boolean emitRuntimeInvisibleAnnotation = flags.keepAttribute("RuntimeInvisibleAnnotations");
        configBuilder.set(
            AnnotationRemover.EMIT_SOURCE_RETENTION_ANNOTATION, emitRuntimeInvisibleAnnotation);
        configBuilder.set(
            AnnotationRemover.EMIT_CLASS_RETENTION_ANNOTATION, emitRuntimeInvisibleAnnotation);
        configBuilder.set(AnnotationRemover.EMIT_RUNTIME_RETENTION_ANNOTATION,
            flags.keepAttribute("RuntimeVisibleAnnotations"));

        boolean emitRuntimeInvisibleParameterAnnotation =
            flags.keepAttribute("RuntimeInvisibleParameterAnnotations");
        configBuilder.set(
            ParameterAnnotationRemover.EMIT_SOURCE_RETENTION_PARAMETER_ANNOTATION,
            emitRuntimeInvisibleParameterAnnotation);
        configBuilder.set(
            ParameterAnnotationRemover.EMIT_CLASS_RETENTION_PARAMETER_ANNOTATION,
            emitRuntimeInvisibleParameterAnnotation);
        configBuilder.set(
            ParameterAnnotationRemover.EMIT_RUNTIME_RETENTION_PARAMETER_ANNOTATION,
            flags.keepAttribute("RuntimeVisibleParameterAnnotations"));

        configBuilder.set(EMIT_LINE_NUMBER_DEBUG_INFO, flags.keepAttribute("LineNumberTable"));
        configBuilder.set(EMIT_LOCAL_DEBUG_INFO, flags.keepAttribute("LocalVariableTable"));
      }

      configBuilder.set(Options.FLAGS, flags);
      configBuilder.set(
          Options.USE_MIXED_CASE_CLASSNAME, flags.getUseMixedCaseClassName());
      configBuilder.set(Renamer.USE_UNIQUE_CLASSMEMBERNAMES,
          flags.getUseUniqueClassMemberNames());

      File mapping = flags.getObfuscationMapping();
      if (mapping != null) {
        configBuilder.set(Renamer.USE_MAPPING, true);
        configBuilder.setString(Renamer.MAPPING_FILE, mapping.getPath());
      } else {
        configBuilder.set(Renamer.USE_MAPPING, false);
      }

      File seeds = flags.getSeedsFile();
      if (seeds != null) {
        configBuilder.setString(SeedPrinter.SEEDS_OUTPUT_FILE, seeds.getPath());
      }

      File dictionary = flags.getObfuscationDictionary();
      if (dictionary != null) {
        configBuilder.set(Renamer.USE_OBFUSCATION_DICTIONARY, true);
        configBuilder.setString(Renamer.OBFUSCATION_DICTIONARY, dictionary.getPath());
      } else {
        configBuilder.set(Renamer.USE_OBFUSCATION_DICTIONARY, false);
      }

      File classDictionary = flags.getClassObfuscationDictionary();
      if (classDictionary != null) {
        configBuilder.set(Renamer.USE_CLASS_OBFUSCATION_DICTIONARY, true);
        configBuilder.setString(Renamer.CLASS_OBFUSCATION_DICTIONARY,
            classDictionary.getPath());
      } else {
        configBuilder.set(Renamer.USE_CLASS_OBFUSCATION_DICTIONARY, false);
      }

      File packageDictionary = flags.getPackageObfuscationDictionary();
      if (packageDictionary != null) {
        configBuilder.set(Renamer.USE_PACKAGE_OBFUSCATION_DICTIONARY, true);
        configBuilder.setString(
            Renamer.PACKAGE_OBFUSCATION_DICTIONARY, packageDictionary.getPath());
      } else {
        configBuilder.set(Renamer.USE_PACKAGE_OBFUSCATION_DICTIONARY, false);
      }
      configBuilder.set(MappingPrinter.MAPPING_OUTPUT_ENABLED, flags.printMapping());
      File outputmapping = flags.getOutputMapping();
      if (outputmapping != null) {
        configBuilder.setString(MappingPrinter.MAPPING_OUTPUT_FILE,
            outputmapping.getPath());
      }

      if (flags.getUseMixedCaseClassName()) {
        configBuilder.setString(NameProviderFactory.NAMEPROVIDER, "mixed-case");
      }

      String packageForRenamedClasses = flags.getPackageForRenamedClasses();
      if (packageForRenamedClasses != null) {
        configBuilder.set(Renamer.REPACKAGE_CLASSES, true);
        configBuilder.set(Renamer.PACKAGE_FOR_RENAMED_CLASSES, packageForRenamedClasses);
        if (flags.getPackageForFlatHierarchy() != null) {
          throw new IllegalOptionsException("Flatten package and repackage classes cannot be used"
              + " simultaneously");
        }
      } else {
        configBuilder.set(Renamer.REPACKAGE_CLASSES, false);
      }

      String packageForRenamedPackages = flags.getPackageForFlatHierarchy();
      if (packageForRenamedPackages != null) {
        configBuilder.set(Renamer.FLATTEN_PACKAGE, true);
        configBuilder.set(Renamer.PACKAGE_FOR_RENAMED_PACKAGES, packageForRenamedPackages);
      } else {
        configBuilder.set(Renamer.FLATTEN_PACKAGE, false);
      }

      String renameSourceFileAttribute = flags.getRenameSourceFileAttribute();
      if (renameSourceFileAttribute != null) {
        configBuilder.set(SourceFileRenamer.RENAME_SOURCEFILE, true);
        configBuilder.set(SourceFileRenamer.NEW_SOURCEFILE_NAME,
            new File(renameSourceFileAttribute));
      } else {
        configBuilder.set(SourceFileRenamer.RENAME_SOURCEFILE, false);
      }
    }

    configBuilder.popDefaultLocation();

    if (importedLibraries != null) {
      configBuilder.setString(
          IMPORTED_LIBRARIES, Joiner.on(File.pathSeparator).join(importedLibraries));
    }

    if (classpath != null) {
      configBuilder.setString(CLASSPATH, classpath);
    }

    if (libraryOutZip != null) {
      configBuilder.setString(LIBRARY_OUTPUT_ZIP, libraryOutZip.getPath());
      configBuilder.set(LIBRARY_OUTPUT_CONTAINER_TYPE, Container.ZIP);
      configBuilder.set(GENERATE_JACK_LIBRARY, true);
      configBuilder.set(GENERATE_JAYCE_IN_LIBRARY, true);
      configBuilder.set(GENERATE_DEPENDENCIES_IN_LIBRARY, true);
    } else if (libraryOutDir != null) {
      configBuilder.setString(LIBRARY_OUTPUT_DIR, libraryOutDir.getPath());
      configBuilder.set(LIBRARY_OUTPUT_CONTAINER_TYPE, Container.DIR);
      configBuilder.set(GENERATE_JACK_LIBRARY, true);
      configBuilder.set(GENERATE_JAYCE_IN_LIBRARY, true);
      configBuilder.set(GENERATE_DEPENDENCIES_IN_LIBRARY, true);
    } else {
      configBuilder.setString(Options.LIBRARY_OUTPUT_DIR, createTempDir(hooks).getPath());
      configBuilder.set(LIBRARY_OUTPUT_CONTAINER_TYPE, Container.DIR);
      configBuilder.set(GENERATE_JACK_LIBRARY, true);
    }

    switch (multiDexKind) {
      case NATIVE:
        configBuilder.setString(DexFileWriter.DEX_WRITING_POLICY, "multidex");
        break;
      case LEGACY:
        configBuilder.setString(DexFileWriter.DEX_WRITING_POLICY, "multidex");
        configBuilder.set(MultiDexLegacy.MULTIDEX_LEGACY, true);
        break;
      case NONE:
        break;
      default:
        throw new AssertionError("Unsupported multi dex kind: '" + multiDexKind.name() + "'");
    }


    if (outZip != null) {
      configBuilder.setString(DEX_OUTPUT_ZIP, outZip.getPath());
      configBuilder.set(DEX_OUTPUT_CONTAINER_TYPE, Container.ZIP);
      configBuilder.set(GENERATE_DEX_FILE, true);
      configBuilder.set(AndroidCompatibilityChecker.CHECK_COMPATIBILITY, true);
    } else if (out != null) {
      configBuilder.setString(DEX_OUTPUT_DIR, out.getPath());
      configBuilder.set(DEX_OUTPUT_CONTAINER_TYPE, Container.DIR);
      configBuilder.set(GENERATE_DEX_FILE, true);
      configBuilder.set(AndroidCompatibilityChecker.CHECK_COMPATIBILITY, true);
    }

    // use a variable to keep record of whether incremental compilation is enabled or not,
    // because we cannot check the value through configBuilder
    boolean isIncrementalEnabled = false;
    if (incrementalFolder != null) {
      if (multiDexKind == MultiDexKind.LEGACY) {
        logger.log(Level.WARNING,
            "Incremental mode is disabled due to multi-dex legacy mode");
      } else if (flags != null && (flags.shrink() || flags.obfuscate())) {
        logger.log(Level.WARNING,
            "Incremental mode is disabled due to usage of shrinking or obfuscation");
      } else if (!jarjarRulesFiles.isEmpty()) {
        logger.log(Level.WARNING,
            "Incremental mode is disabled due to usage of jarjar");
      } else if (properties.containsKey(SOURCE_PATH.getName())) {
        logger.log(Level.WARNING,
            "Incremental mode is disabled due to usage of source path");
      } else {
        configBuilder.set(Options.INCREMENTAL_MODE, true);
        configBuilder.setString(Options.INPUT_FILTER, "incremental");
        configBuilder.set(Options.GENERATE_JACK_LIBRARY, true);
        configBuilder.set(GENERATE_JAYCE_IN_LIBRARY, true);
        configBuilder.set(GENERATE_DEPENDENCIES_IN_LIBRARY, true);
        configBuilder.setString(Options.LIBRARY_OUTPUT_CONTAINER_TYPE, "dir");
        configBuilder.setString(Options.LIBRARY_OUTPUT_DIR, incrementalFolder.getPath());
        if (libraryOutZip != null) {
          configBuilder.set(GENERATE_LIBRARY_FROM_INCREMENTAL_FOLDER, true);
        }
        isIncrementalEnabled = true;
      }
    }

    if (tracerDir != null) {
      configBuilder.setString(TracerFactory.TRACER, "html");
      configBuilder.setString(StatsTracerFtl.TRACER_DIR, tracerDir.getPath());
    }

    configBuilder.set(SANITY_CHECKS, sanityChecks);

    configBuilder.popDefaultLocation();

    configBuilder.setString(CLASSPATH, classpath);

    for (Entry<String, String> entry : properties.entrySet()) {
      configBuilder.setString(entry.getKey(), entry.getValue(), new StringLocation("-D option"));
    }

    if (isIncrementalEnabled) {
      // if the incremental compilation is enabled, the switch enum optimization cannot
      // be enabled because it will generates non-deterministic code. This has to be done after
      // -D options are set
      configBuilder.set(OPTIMIZED_ENUM_SWITCH.getName(), SwitchEnumOptStrategy.NEVER);
    }

    configBuilder.processEnvironmentVariables("JACK_CONFIG_");
    configBuilder.setHooks(hooks);

    return configBuilder;
  }

  public void checkValidity(@Nonnull RunnableHooks hooks)
      throws IllegalOptionsException, ConfigurationException {
    ecjExtraArguments.clear();
    config = getConfigBuilder(hooks).build();

    // FINDBUGS
    Config config = this.config;
    assert config != null;

    // FINDBUGS
    assert config != null;

    // Check ecj arguments
    if (inputSources != null) {
      if (config.get(VERBOSITY_LEVEL) == VerbosityLevel.ERROR) {
        ecjExtraArguments.add(0, "-nowarn");
      }
      ecjExtraArguments.add("-source");
      ecjExtraArguments.add(config.get(Options.JAVA_SOURCE_VERSION).toString());

      if (!config.get(Options.ANNOTATION_PROCESSOR_ENABLED).booleanValue()) {
        ecjExtraArguments.add("-proc:none");
      }

      if (config.get(Options.EMIT_CLASS_FILES).booleanValue()) {
        ecjExtraArguments.add("-d");
        ecjExtraArguments.add(config.get(Options.EMIT_CLASS_FILES_FOLDER).getPath());
      }
    }

    // Check Jack arguments
    if (config.get(CodeItemBuilder.EMIT_SYNTHETIC_LOCAL_DEBUG_INFO).booleanValue()
        && !config.get(Options.EMIT_LOCAL_DEBUG_INFO).booleanValue()) {
      throw new PropertyIdException(CodeItemBuilder.EMIT_SYNTHETIC_LOCAL_DEBUG_INFO,
          new NoLocation(),
          "Impossible to emit synthetic debug info when not emitting debug info");
    }

    if (verbose == VerbosityLevel.DEBUG || verbose == VerbosityLevel.TRACE) {
      config.get(Reporter.REPORTER).report(Severity.NON_FATAL, new DeprecatedVerbosity(verbose));
    }
  }

  public void setJayceOutputDir(@Nonnull File outputDir) {
    libraryOutDir = outputDir;
  }

  public void setJayceOutputZip(@Nonnull File outputZip) {
    libraryOutZip = outputZip;
  }

  public void setImportedLibraries(@Nonnull List<File> importedLibraries) {
    this.importedLibraries = importedLibraries;
  }

  @CheckForNull
  public Flags getFlags() {
    return flags;
  }

  public void setFlags(@Nonnull Flags flags) {
    this.flags = flags;
  }

  public void applyShrobFlags() {
    assert flags != null;
    List<File> inJars = flags.getInJars();
    if (inJars.size() > 0) {
      importedLibraries = new ArrayList<File>(inJars.size());
      importedLibraries.addAll(inJars);
    }
    List<File> outJars = flags.getOutJars();
    if (outJars.size() > 0) {
      File outJar = outJars.get(0);
      if (outJar.isDirectory()) {
        libraryOutDir = outJar;
      } else {
        libraryOutZip = outJar;
      }
    }
    String libraryJars = flags.getLibraryJars();
    if (libraryJars != null) {
      if (classpath.isEmpty()) {
        classpath = libraryJars;
      } else {
        classpath += File.pathSeparatorChar + libraryJars;
      }
    }
  }

  public void setClasspath(@CheckForNull String classpath) {
    if (classpath == null) {
      this.classpath = "";
    } else {
      this.classpath = classpath;
    }
  }

  public void setMultiDexKind(@Nonnull MultiDexKind multiDexKind) {
    this.multiDexKind = multiDexKind;
  }

  public void addProguardFlagsFile(@Nonnull File flags) {
    if (proguardFlagsFiles == null) {
      proguardFlagsFiles = new ArrayList<File>();
    }
    proguardFlagsFiles.add(flags);
  }

  public void addProperty(@Nonnull String propertyName, @Nonnull String propertyValue) {
    properties.put(propertyName, propertyValue);
  }

  @Nonnull
  List<String> getEcjExtraArguments() {
    return ecjExtraArguments;
  }

  public void setProguardFlagsFile(@Nonnull List<File> proguardFlagsFiles) {
    this.proguardFlagsFiles = proguardFlagsFiles;
  }

  public void setJarjarRulesFiles(@Nonnull List<File> jarjarRulesFiles) {
    this.jarjarRulesFiles = jarjarRulesFiles;
  }

  public void disableDxOptimizations() {
    properties.put(CodeItemBuilder.DEX_OPTIMIZE.getName(), "false");
  }

  public void setSanityChecks(boolean sanityChecks) {
    this.sanityChecks = sanityChecks;
  }

  public void setIncrementalFolder(@Nonnull File incrementalFolder) {
    this.incrementalFolder = incrementalFolder;
  }

  public void addResource(@Nonnull File resource) {
    resImport.add(resource);
  }

  public void setResourceDirs(@Nonnull List<File> resourceDirs) {
    resImport = new ArrayList<File>(resourceDirs);
  }

  public void setMetaDirs(@Nonnull List<File> metaDirs) {
    metaImport = metaDirs;
  }

  public void setReporterStream(@Nonnull OutputStream reporterStream) {
    this.reporterStream = reporterStream;
  }

  public List<File> getProguardFlagsFile() {
    List<File> proguardFlagsFileFromWorkingDir = new ArrayList<File>(proguardFlagsFiles.size());
    for (File proguardFlagsFile : proguardFlagsFiles) {
      if (workingDirectory != null && !proguardFlagsFile.isAbsolute()) {
        proguardFlagsFileFromWorkingDir.add(
            new File(workingDirectory, proguardFlagsFile.getPath()));
      } else {
        proguardFlagsFileFromWorkingDir.add(proguardFlagsFile);
      }
    }
    return proguardFlagsFileFromWorkingDir;
  }

  @Nonnull
  private static Directory createTempDir(
      @Nonnull RunnableHooks hooks) {
    try {
      File tmp = Files.createTempDir("jack-");
      Directory dir = new Directory(tmp.getPath(), hooks, Existence.MUST_EXIST, Permission.WRITE,
          ChangePermission.NOCHANGE);
      hooks.addHook(new TempDirDeleter(dir));
      return dir;
    } catch (CannotChangePermissionException | CannotCreateFileException
        | FileAlreadyExistsException | NotDirectoryException | NoSuchFileException
        | WrongPermissionException e) {
      throw new JackUserException(e);
    }
  }

  private static class TempDirDeleter implements Runnable {

    @Nonnull
    private final Directory dir;

    public TempDirDeleter(@Nonnull Directory dir) {
      this.dir = dir;
    }

    @Override
    public void run() {
      try {
        FileUtils.deleteDir(dir.getFile());
      } catch (IOException e) {
        throw new JackIOException(
            "Failed to delete temporary " + dir.getLocation().getDescription(), e);
      }
    }
  }
}