(* $Id: commands.sml 66 2008-08-27 01:54:40Z tbourke $
 *
 * Copyright (c) 2008 Timothy Bourke (University of NSW and NICTA)
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the "BSD License" which is distributed with the
 * software in the file LICENSE.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the BSD
 * License for more details.
 *)

structure Commands : COMMANDS
=
let structure GO  = GetOpt
          and O   = Option
          and TIO = TextIO
in
struct
  type options = {inputfile: string option, outputfile: string option}
  val defaults = {inputfile=NONE, outputfile=NONE}

  datatype command = ScriptFile of string
                   | ScriptText of string
                   | ScriptTerminal
                   | ShowConfig
                   | ConfigFile of string
                   | ConfigText of string
                   | TestFlip

  datatype args = ShowUsage
                | ShowVersion
                | InputFile of string
                | OutputFile of string
                | Command of command
                | Ignore

  fun showError msg = TIO.output (TIO.stdErr,
        String.concat [Settings.progName, ": ", msg, "\n"])

  fun filterCommand (Command cmd) = SOME cmd
    | filterCommand _             = NONE

  val optionList = [
      {short="h", long=["help"], desc=GO.NoArg (fn ()=>ShowUsage),
       help="show this summary of command line options"},

      {short="v", long=["version"],
       desc=GO.NoArg (fn ()=>ShowVersion),
       help="show the version number"},

      {short="i", long=["input"],
       desc=GO.ReqArg (InputFile, "path"),
       help="Uppaal xml file to use for input"},

      {short="o", long=["output"],
       desc=GO.ReqArg (OutputFile, "path"),
       help="Path to file which should be overwritten with results"},

      {short="e", long=["eval"],
       desc=GO.ReqArg (fn t=>Command (ScriptText t), "script"),
       help="Evaluate script expressions directly."},

      {short="f", long=["scriptfile"],
       desc=GO.ReqArg (fn f=>Command (ScriptFile f), "path"),
       help="Evaluate script commands from a file."},

      {short="t", long=["terminal"],
       desc=GO.NoArg (fn ()=>Command (ScriptTerminal)),
       help="Invoke interactive terminal."},

      {short="c", long=["config"],
       desc=GO.ReqArg (fn f=>Command (ConfigFile f), "path"),
       help="Path to a configuration file."},

      {short="s", long=["set"],
       desc=GO.ReqArg (fn t=>Command (ConfigText t), "configtext"),
       help="Specify configuration settings directly."},

      {short="", long=["showconfig"],
       desc=GO.NoArg (fn ()=> Command ShowConfig),
       help="Write all settings to standard output"},

      {short="", long=["testflip"],
       desc=GO.NoArg (fn ()=>Command TestFlip),
       help="Test template flipping."}
    ]

  fun warningIfUsed NONE     = ()
    | warningIfUsed (SOME f) = showError ("file ignored '"^f^"'")

  fun processOptions (arg, opt as {inputfile=inf, outputfile=outf}) =
      case arg of
        ShowUsage        => opt before (
                              TextIO.print (GO.usageInfo {
                                header=(Settings.progName^" "^
                                        Settings.version^
                                        " -- "^Settings.copyright),
                                options=optionList});
                              TextIO.print "\n")
      | ShowVersion      => opt before TextIO.print (Settings.progName ^ " " ^
                                                     Settings.version ^
                                                     " -- " ^
                                                     Settings.copyright ^ "\n")
      | InputFile f      => {inputfile=SOME f,outputfile=outf}
                            before warningIfUsed inf
      | OutputFile f     => {outputfile=SOME f, inputfile=inf}
                            before warningIfUsed outf
      | Command com      => opt
      | Ignore           => opt

  fun wrapFiles []       = []
    | wrapFiles (f::fs)  = InputFile f::wrapFiles' fs
  and wrapFiles' []      = []
    | wrapFiles' (f::fs) = OutputFile f::wrapFiles fs

  fun showRequest ShowUsage   = true
    | showRequest ShowVersion = true
    | showRequest _           = false

  fun processCommands args = let
      val (ops, files) = GO.getOpt {argOrder=GO.Permute,
                                    options=optionList,
                                    errFn=showError} args
      val options = foldl processOptions defaults (ops @ wrapFiles files)
      val commands = List.mapPartial filterCommand ops
    in
      if null commands andalso not (List.exists showRequest ops)
      then ([ScriptTerminal], options) else (commands, options)
    end

end
end