import Data.List (intercalate, intersperse)
import System.Exit (ExitCode(..), exitWith)
import System.IO (stderr, hPutStrLn)

import Text.Regex.Posix

import Cidr (Cidr,
             from_string,
             min_first_octet,
             min_second_octet,
             min_third_octet,
             min_fourth_octet,
             max_first_octet,
             max_second_octet,
             max_third_octet,
             max_fourth_octet)

import CommandLine (help_set,
                    help_text,
                    input_function,
                    Mode(..),
                    parse_errors,
                    parse_mode)

-- Some exit codes, used in the ExitFailure constructor.
exit_invalid_cidr :: Int
exit_invalid_cidr = 1

exit_args_parse_failed :: Int
exit_args_parse_failed = 2


-- A regular expression that matches a non-address character.
non_addr_char :: String
non_addr_char = "[^\\.0-9]"


-- Add non_addr_chars on either side of the given String. This
-- prevents (for example) the regex '127.0.0.1' from matching
-- '127.0.0.100'.
addr_barrier :: String -> String
addr_barrier x = non_addr_char ++ x ++ non_addr_char


-- The magic happens here. We take a CIDR String as an argument, and
-- return the equivalent regular expression. We do this as follows:
--
-- 1. Compute the minimum possible value of each octet.
-- 2. Compute the maximum possible value of each octet.
-- 3. Generate a regex matching every value between those min and
--    max values.
-- 4. Join the regexes from step 3 with regexes matching periods.
-- 5. Stick an address boundary on either side of the result.
--cidr_to_regex :: String -> String
cidr_to_regex :: Cidr.Cidr -> String
cidr_to_regex cidr =
    addr_barrier (intercalate "\\." [range1, range2, range3, range4])
    where
      range1 = numeric_range min1 max1
      range2 = numeric_range min2 max2
      range3 = numeric_range min3 max3
      range4 = numeric_range min4 max4
      min1   = min_first_octet cidr
      min2   = min_second_octet cidr
      min3   = min_third_octet cidr
      min4   = min_fourth_octet cidr
      max1   = max_first_octet cidr
      max2   = max_second_octet cidr
      max3   = max_third_octet cidr
      max4   = max_fourth_octet cidr


-- Will return True if the passed String is in CIDR notation, False
-- otherwise.
is_valid_cidr :: String -> Bool
is_valid_cidr cidr = cidr =~ "([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}"


-- Take a list of Strings, and return a regular expression matching
-- any of them.
alternate :: [String] -> String
alternate terms = "(" ++ (concat (intersperse "|" terms)) ++ ")"


-- Take two Ints as parameters, and return a regex matching any
-- integer between them (inclusive).
numeric_range :: Int -> Int -> String
numeric_range x y =
    alternate (map show [lower..upper])
     where
       lower = minimum [x,y]
       upper = maximum [x,y]


-- Take a CIDR String, and exit with a failure if it's invalid.
validate_or_die :: String -> IO ()
validate_or_die cidr = do
  if (is_valid_cidr cidr)
    then do
      return ()
    else do
        putStrLn "Error: not valid CIDR notation."
        exitWith (ExitFailure exit_invalid_cidr)



main :: IO ()
main = do
  -- First, check for any errors that occurred while parsing
  -- the command line options.
  errors <- CommandLine.parse_errors
  if not (null errors)
    then do
      hPutStrLn stderr (concat errors)
      putStrLn CommandLine.help_text
      exitWith (ExitFailure exit_args_parse_failed)
    else do -- Nothing

  -- Next, check to see if the 'help' option was passed to the
  -- program. If it was, display the help, and exit successfully.
  help_opt_set <- CommandLine.help_set
  if help_opt_set
    then do
      putStrLn CommandLine.help_text
      exitWith ExitSuccess
    else do -- Nothing

  -- The input function we receive here should know what to read.
  inputfunc <- (CommandLine.input_function)
  input <- inputfunc

  let cidr_strings = lines input
  mapM validate_or_die cidr_strings
  let cidrs = map Cidr.from_string cidr_strings

  -- Get the mode of operation.
  mode <- CommandLine.parse_mode

  case mode of
    Regex -> do
        let regexes = map cidr_to_regex cidrs
        putStrLn $ alternate regexes
    Reduce -> do
        putStr input