-- The CommandLine module handles parsing of the command-line options.
-- It should more or less be a black box, providing Main with only the
-- information it requires.

module CommandLine
( help_set,
  help_text,
  input_function,
  Mode(..),
  parse_errors,
  parse_mode
) where

import Data.Char(toLower)
import System.Console.GetOpt
import System.Environment (getArgs)


-- | Lowercase an entire string.
lowercase :: String -> String
lowercase = map toLower


-- | The application currently has four modes. The default, Regex,
--   will compute a regular expression matching the input
--   CIDRs. Reduce, on the other hand, will combine any
--   redundant/adjacent CIDR blocks into one. Dupe will show you what
--   would be removed by Reduce, and Diff will show both additions and
--   deletions in a diff-like format.
data Mode = Regex | Reduce | Dupe | Diff


-- | A record containing values for all available options.
data Options = Options { opt_help  :: Bool,
                         opt_input :: IO String }


-- | This constructs an instance of Options, with each of its members
--   set to default values.
default_options :: Options
default_options = Options { opt_help = False,
                            opt_input = getContents }


-- | The options list that we construct associates a function with
--   each option. This function is responsible for updating an Options
--   record with the appropriate value.
--
--   For more information and an example of this idiom, see,
--
--   http://www.haskell.org/haskellwiki/High-level_option_handling_with_GetOpt
--
options :: [OptDescr (Options -> IO Options)]
options =
  [ Option "h" ["help"] (NoArg set_help) "Prints this help message.",
    Option "i" ["input"] (ReqArg set_input "FILE") "Read FILE instead of stdin." ]

-- | Takes an Options as an argument, and sets its opt_help member to
--   True.
set_help :: Options -> IO Options
set_help opts = 
  return opts { opt_help = True }


-- | If the input file option is set, this function will update the
--   passed Options record with a new function for opt_input. The
--   default opt_input is to read from stdin, but if this option is
--   set, we replace that with readFile.
set_input :: String -> Options -> IO Options
set_input arg opts =
  return opts { opt_input = readFile arg }


-- | The usage header.
usage :: String
usage = "Usage: hath [regexed|reduced|duped|diffed] [-h] [-i FILE] <input>"


-- | The usage header, and all available flags (as generated by GetOpt).
help_text :: String
help_text = usageInfo usage options


-- | Return a list of options.
parse_options :: IO Options
parse_options = do
  argv <- getArgs
  let (actions, _, _) = getOpt Permute options argv

  -- This will execute each of the functions contained in our options
  -- list, one after another, on a default_options record. The end
  -- result should be an Options instance with all of its members set
  -- correctly.
  foldl (>>=) (return default_options) actions



-- | Return the mode if one was given.
parse_mode :: IO Mode
parse_mode = do
  argv <- getArgs
  let (_, non_options, _) = getOpt Permute options argv
  case non_options of
    -- Default
    []     -> return Regex
    -- Some non-option was given, but were any of them modes?    
    (x:_) ->
      case (lowercase x) of
        "regex"   -> return Regex
        "regexed" -> return Regex
        "reduce"  -> return Reduce
        "reduced" -> return Reduce
        "dupe"    -> return Dupe
        "duped"   -> return Dupe
        "diff"    -> return Diff
        "diffed"  -> return Diff
        _         -> return Regex




-- | Return a list of errors.
parse_errors :: IO [String]
parse_errors = do
  argv <- getArgs
  let (_, _, errors) = getOpt Permute options argv
  return errors



-- | Is the help option set?
help_set :: IO Bool
help_set = do
    opts <- parse_options
    return (opt_help opts)


-- | Return our input function, getContents by default, or readFile if
--   the input file option was set.
input_function :: IO (IO String)
input_function = do
    opts <- parse_options
    return (opt_input opts)