import Data.List (intercalate, intersperse)
import System.Exit (exitFailure)
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)


-- 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 exitFailure 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."
        exitFailure


main :: IO ()
main = do
  input <- getContents
  let cidr_strings = lines input
  mapM validate_or_die cidr_strings
  let cidrs = map Cidr.from_string cidr_strings
  let regexes = map cidr_to_regex cidrs
  putStrLn $ alternate regexes