module Hix where

import Control.Monad.Trans.Class (lift)
import Path.IO (getCurrentDir)

import Hix.Data.Error (Error (..), printEnvError, printGhciError, printPreprocError, printFatalError)
import Hix.Env (printEnvRunner)
import Hix.Ghci (printGhciCmdline, printGhcidCmdline)
import Hix.Monad (M, runM)
import qualified Hix.Options as Options
import Hix.Options (
  Command (EnvRunner, GhciCmd, GhcidCmd, Preproc),
  GlobalOptions (GlobalOptions),
  Options (Options),
  parseCli,
  )
import Hix.Preproc (preprocess)

handleError ::
  MonadIO m =>
  GlobalOptions ->
  Error ->
  m ()
handleError :: forall (m :: * -> *). MonadIO m => GlobalOptions -> Error -> m ()
handleError GlobalOptions {Maybe Bool
$sel:verbose:GlobalOptions :: GlobalOptions -> Maybe Bool
verbose :: Maybe Bool
verbose} = \case
  PreprocError Text
err -> forall (m :: * -> *). MonadIO m => Text -> m ()
printPreprocError Text
err
  EnvError Text
err -> forall (m :: * -> *). MonadIO m => Text -> m ()
printEnvError Text
err
  GhciError Text
err -> forall (m :: * -> *). MonadIO m => Text -> m ()
printGhciError Text
err
  NoMatch Text
msg | forall a. a -> Maybe a -> a
fromMaybe Bool
False Maybe Bool
verbose -> forall (m :: * -> *). MonadIO m => Text -> m ()
printPreprocError Text
msg
  NoMatch Text
_ -> forall (f :: * -> *). Applicative f => f ()
unit
  Fatal Text
err -> forall (m :: * -> *). MonadIO m => Text -> m ()
printFatalError Text
err

runCommand :: Command -> M ()
runCommand :: Command -> M ()
runCommand = \case
  Preproc PreprocOptions
opts -> forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (PreprocOptions -> ExceptT Error IO ()
preprocess PreprocOptions
opts)
  EnvRunner EnvRunnerCommandOptions
opts -> EnvRunnerOptions -> M ()
printEnvRunner EnvRunnerCommandOptions
opts.options
  GhcidCmd GhciOptions
opts -> GhciOptions -> M ()
printGhcidCmdline GhciOptions
opts
  GhciCmd GhciOptions
opts -> GhciOptions -> M ()
printGhciCmdline GhciOptions
opts

main :: IO ()
main :: IO ()
main = do
  Options GlobalOptions
global Command
cmd <- IO Options
parseCli
  Path Abs Dir
cwd <- forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getCurrentDir
  forall (m :: * -> *) a b.
Applicative m =>
(a -> m b) -> Either a b -> m b
leftA (forall (m :: * -> *). MonadIO m => GlobalOptions -> Error -> m ()
handleError GlobalOptions
global) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a. Path Abs Dir -> M a -> IO (Either Error a)
runM Path Abs Dir
cwd (Command -> M ()
runCommand Command
cmd)