Configuration System

case class Settings(
  help: Boolean,                    // Show help flag
  version: Boolean,                 // Show version flag
  consoleLog: ConsoleOptions,       // Console logging configuration
  captureLog: Option[File],         // Optional log capture file
  sources: Seq[File],               // Source files to compile
  classpath: Seq[File],             // Compilation classpath
  classesDirectory: File,           // Output directory for compiled classes
  scala: ScalaLocation,             // Scala compiler location configuration
  scalacOptions: Seq[String],       // Scala compiler options
  javaHome: Option[File],           // Java home directory
  forkJava: Boolean,                // Fork Java compiler flag
  javaOnly: Boolean,                // Java-only compilation flag
  javacOptions: Seq[String],        // Java compiler options
  compileOrder: CompileOrder,       // Compilation order strategy
  sbt: SbtJars,                     // SBT jar locations
  incOptions: IncOptions,           // Incremental compilation options
  analysis: AnalysisOptions,        // Analysis configuration
  properties: Seq[String]           // JVM system properties
)

object Settings {
  /**
   * Parse command-line arguments into Settings
   * @param args Command-line argument sequence
   * @return Parsed settings or error information
   */
  def parse(args: Seq[String]): Parsed[Settings]
  
  /**
   * Print usage information to console
   */
  def printUsage(): Unit
  
  /**
   * Normalize file paths relative to working directory
   * @param settings Settings to normalize
   * @param cwd Optional working directory
   * @return Settings with normalized paths
   */
  def normalise(settings: Settings, cwd: Option[File]): Settings
  
  /**
   * Convert string to CompileOrder enumeration
   * @param order Order string ("Mixed", "JavaThenScala", "ScalaThenJava")
   * @return CompileOrder enumeration value
   */
  def compileOrder(order: String): CompileOrder
  
  /**
   * Check if string is command-line option flag
   * @param s String to check
   * @return True if string starts with option prefix
   */
  def isOpt(s: String): Boolean
}

case class ConsoleOptions(
  logLevel: Level.Value,            // Logging level (Debug/Info/Warn/Error)
  color: Boolean,                   // Enable colored output
  logPhases: Boolean,               // Log compilation phases
  printProgress: Boolean,           // Print compilation progress
  heartbeatSecs: Int,               // Heartbeat interval in seconds
  fileFilters: Seq[Regex],          // File name filters for warnings
  msgFilters: Seq[Regex]            // Message filters for warnings
)

case class ScalaLocation(
  home: Option[File],               // Scala home directory
  path: Seq[File],                  // Direct path to Scala jars
  compiler: Option[File],           // Scala compiler jar file
  library: Option[File],            // Scala library jar file
  extra: Seq[File]                  // Additional Scala jars
)

object ScalaLocation {
  /**
   * Java API constructor for ScalaLocation
   * @param home Scala home directory
   * @param path Direct path to Scala jars
   * @param compiler Scala compiler jar
   * @param library Scala library jar
   * @param extra Additional Scala jars
   * @return ScalaLocation instance
   */
  def create(home: File, path: JList[File], compiler: File, 
             library: File, extra: JList[File]): ScalaLocation
  
  /**
   * Create ScalaLocation from Scala home directory
   * @param home Scala installation directory
   * @return ScalaLocation with auto-detected jars
   */
  def fromHome(home: File): ScalaLocation
  
  /**
   * Create ScalaLocation from explicit jar paths
   * @param path List of Scala jar files
   * @return ScalaLocation with specified jars
   */
  def fromPath(path: JList[File]): ScalaLocation
}

case class SbtJars(
  sbtInterface: Option[File] = None,         // SBT interface jar location
  compilerInterfaceSrc: Option[File] = None  // Compiler interface source location
)

case class AnalysisOptions(
  cache: Option[File],              // Analysis cache file location
  cacheMap: Map[File, File]         // Mapping of dependency analysis locations
)

case class IncOptions(
  transitiveStep: Int,              // Steps before transitive closure
  recompileAllFraction: Double,     // Fraction limit before recompiling all
  relationsDebug: Boolean,          // Enable relations debug logging
  apiDebug: Boolean,                // Enable API debug logging
  apiDiffContextSize: Int,          // API diff context size
  apiDumpDirectory: Option[File],   // Directory for API dumps
  transactional: Boolean,           // Enable transactional compilation
  backup: Option[File],             // Backup directory for transactional mode
  recompileOnMacroDef: Boolean,     // Recompile dependencies on macro definition
  nameHashing: Boolean              // Enable name hashing algorithm
) {
  /**
   * Convert to SBT IncOptions for compatibility
   * @return SBT IncOptions instance
   */
  def options: sbt.inc.IncOptions
  
  /**
   * Get classfile manager for incremental compilation
   * @return Function creating ClassfileManager
   */
  def classfileManager: () => ClassfileManager
}

case class Inputs(
  classpath: Seq[File],             // Compilation classpath
  sources: Seq[File],               // Source files to compile
  classesDirectory: File,           // Output directory for classes
  scalacOptions: Seq[String],       // Scala compiler options
  javacOptions: Seq[String],        // Java compiler options
  cacheFile: File,                  // Analysis cache file
  analysisMap: AnalysisMap,         // Analysis mapping for dependencies
  javaOnly: Boolean,                // Java-only compilation flag
  compileOrder: CompileOrder,       // Compilation order strategy
  incOptions: IncOptions            // Incremental compilation options
)

object Inputs {
  /**
   * Create Inputs from Settings configuration
   * @param log Logger for input processing
   * @param settings Settings containing compilation configuration
   * @return Inputs instance ready for compilation
   */
  def apply(log: Logger, settings: Settings): Inputs
  
  /**
   * Java API constructor for Inputs
   * @param log Logger instance
   * @param classpath Compilation classpath
   * @param sources Source files to compile
   * @param classesDirectory Output directory
   * @param scalacOptions Scala compiler options
   * @param javacOptions Java compiler options
   * @param analysisCache Analysis cache file
   * @param analysisMap Analysis mapping
   * @param compileOrder Compilation order string
   * @param incOptions Incremental compilation options
   * @return Inputs instance
   */
  def create(log: Logger, classpath: JList[File], sources: JList[File],
             classesDirectory: File, scalacOptions: JList[String],
             javacOptions: JList[String], analysisCache: File,
             analysisMap: JMap[File, File], compileOrder: String,
             incOptions: IncOptions): Inputs
  
  /**
   * Verify and normalize input configuration
   * @param inputs Inputs to verify
   * @return Verified and normalized inputs
   */
  def verify(inputs: Inputs): Inputs
  
  /**
   * Get default cache file location
   * @param classesDir Output classes directory
   * @return Default cache file location
   */
  def defaultCacheLocation(classesDir: File): File
  
  /**
   * Debug display of inputs configuration
   * @param inputs Inputs to display
   * @param output Output function for display
   */
  def show(inputs: Inputs, output: String => Unit): Unit
}

case class Setup(
  scalaCompiler: File,              // Scala compiler jar
  scalaLibrary: File,               // Scala library jar
  scalaExtra: Seq[File],            // Additional Scala jars
  sbtInterface: File,               // SBT interface jar
  compilerInterfaceSrc: File,       // Compiler interface sources
  javaHome: Option[File],           // Java home directory
  forkJava: Boolean,                // Fork Java compiler flag
  cacheDir: File                    // Cache directory
)

object Setup {
  /**
   * Create Setup from Settings configuration
   * @param settings Settings containing setup information
   * @return Setup instance ready for compiler creation
   */
  def apply(settings: Settings): Setup
  
  /**
   * Verify setup configuration is valid
   * @param setup Setup to verify
   * @param log Logger for verification messages
   * @return True if setup is valid
   */
  def verify(setup: Setup, log: Logger): Boolean
  
  /**
   * Print Zinc version information
   */
  def printVersion(): Unit
  
  /**
   * Get Zinc cache directory location
   * @return Cache directory file
   */
  def zincCacheDir: File
  
  /**
   * Format version string for display
   * @return Formatted version string
   */
  def versionString: String
}

import org.pantsbuild.zinc._
import java.io.File

// Parse command-line arguments
val args = Seq(
  "-scala-home", "/usr/local/scala",
  "-classpath", "/path/to/deps",
  "-d", "/output",
  "Example.scala"
)

val Parsed(settings, remaining, errors) = Settings.parse(args)
if (errors.nonEmpty) {
  throw new IllegalArgumentException(s"Parse errors: ${errors.mkString(", ")}")
}

// Create setup and inputs
val setup = Setup(settings)
val inputs = Inputs(log, settings)

// Use for compilation...

// Compilation order strategies
sealed trait CompileOrder
case object Mixed extends CompileOrder
case object JavaThenScala extends CompileOrder  
case object ScalaThenJava extends CompileOrder

// Command-line parsing results
case class Parsed[Context](
  context: Context,                 // Parsed configuration object
  remaining: Seq[String],           // Remaining unparsed arguments
  errors: Seq[String] = Seq.empty   // Any parsing errors encountered
)