module Imp.Type.Context where

import qualified Control.Monad as Monad
import qualified Control.Monad.Catch as Exception
import qualified Data.Map as Map
import qualified Imp.Exception.ShowHelp as ShowHelp
import qualified Imp.Exception.ShowVersion as ShowVersion
import qualified Imp.Type.Alias as Alias
import qualified Imp.Type.Config as Config
import qualified Imp.Type.Package as Package
import qualified Imp.Type.PackageName as PackageName
import qualified Imp.Type.Source as Source
import qualified Imp.Type.Target as Target

data Context = Context
  { Context -> Map Target Source
aliases :: Map.Map Target.Target Source.Source,
    Context -> Map Target PackageName
packages :: Map.Map Target.Target PackageName.PackageName
  }
  deriving (Context -> Context -> Bool
(Context -> Context -> Bool)
-> (Context -> Context -> Bool) -> Eq Context
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Context -> Context -> Bool
== :: Context -> Context -> Bool
$c/= :: Context -> Context -> Bool
/= :: Context -> Context -> Bool
Eq, Int -> Context -> ShowS
[Context] -> ShowS
Context -> String
(Int -> Context -> ShowS)
-> (Context -> String) -> ([Context] -> ShowS) -> Show Context
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Context -> ShowS
showsPrec :: Int -> Context -> ShowS
$cshow :: Context -> String
show :: Context -> String
$cshowList :: [Context] -> ShowS
showList :: [Context] -> ShowS
Show)

fromConfig :: (Exception.MonadThrow m) => Config.Config -> m Context
fromConfig :: forall (m :: * -> *). MonadThrow m => Config -> m Context
fromConfig Config
config = do
  Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Monad.when (Config -> Bool
Config.help Config
config) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ ShowHelp -> m ()
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
Exception.throwM ShowHelp
ShowHelp.new
  Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Monad.when (Config -> Bool
Config.version Config
config) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ ShowVersion -> m ()
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
Exception.throwM ShowVersion
ShowVersion.new
  Context -> m Context
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    Context
      { aliases :: Map Target Source
aliases = [Alias] -> Map Target Source
Alias.toMap ([Alias] -> Map Target Source) -> [Alias] -> Map Target Source
forall a b. (a -> b) -> a -> b
$ Config -> [Alias]
Config.aliases Config
config,
        packages :: Map Target PackageName
packages = [Package] -> Map Target PackageName
Package.toMap ([Package] -> Map Target PackageName)
-> [Package] -> Map Target PackageName
forall a b. (a -> b) -> a -> b
$ Config -> [Package]
Config.packages Config
config
      }