import System.IO.Error(tryIOError)
import System.Directory (listDirectory,getCurrentDirectory)
import Data.Either(rights)
--1

--(i) syntax error: contents <- readFile filename
--(ii) type error: readFile is IO String not String.
--(iii) readFile  gives IO String, so return
-- makes it into IO (IO String)

-- 2 
readAllFiles :: IO [(FilePath,String)]
-- readAllFiles = undefined
zipFiles     :: [(FilePath,String)] -> String
zipFiles = undefined





-- 2 
backupDirectory :: IO ()
backupDirectory = do
  fileTable <- readAllFiles
  writeFile "backup.zip" (zipFiles fileTable)


-- 3 
kidInCar :: IO ()
kidInCar = do
         putStrLn "Are we there yet?"
         reply <- getLine
         if reply /= "yes" then kidInCar else return ()

-- hlint suggests: Control.Monad.when (reply /= "yes") kidInCar

-- 4

-- v1 - don't care about errors.
-- we use getCurrentDirectory and listDirectory, both of which can throw exceptions

readAllFiles1 = do
  current <- getCurrentDirectory
  files <- listDirectory current
  sequence (map readOne files)  -- hlint suggests: mapM readOne files

readOne :: FilePath -> IO (FilePath,String)
readOne f = do contents <- readFile f
               return (f,contents)
  
-- v2 Let's avoid exceptions in the simplest way possible:
readAllFiles2 = do
     fs <- tryIOError readAllFiles1
     case fs of
        Right fileTable -> return fileTable
        _               -> return []
 
-- v3 catch the error at the readFile level, so we return as
-- many files as we manage to read. 

-- utility to return [] instead of throwing IO exception
tryIO :: IO [a] -> IO [a]
tryIO io = do t <- tryIOError io
              return $ case t of
                          Right as -> as
                          _        -> []
-- equivalent to System.IO.catchIOError io (const $ return []) 

readAllFiles = do
       dir   <- tryIO getCurrentDirectory -- hack!
       files <- tryIO $ listDirectory dir
       rights <$> mapM (tryIOError . readOne) files

-- Data.Either.rights :: Either a b -> [b]

-- You notice that this easily gets very messy.  We used a hack here
-- to keep the code simple (relying on the fact that listDirectory "" thows an exception)

-- What we really want here is to take advantage of the fact that
-- Either is also a monad, but we can't use two different monads in a single do block
-- The solution here is outside the scope of the course: we need to
-- use EitherT - a monad *transformer* that allows us to combine Either
-- and IO into a single monad.