{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Cardano.CLI.Byron.Query
  ( ByronQueryError(..)
  , renderByronQueryError
  , runGetLocalNodeTip
  ) where

import           Cardano.Api

import           Control.Monad.IO.Unlift (MonadIO (..))
import           Control.Monad.Trans.Except (ExceptT)
import           Control.Monad.Trans.Except.Extra (firstExceptT, newExceptT)
import           Data.Aeson.Encode.Pretty (encodePretty)
import qualified Data.ByteString.Lazy as LB
import           Data.Text (Text)
import qualified Data.Text.Encoding as Text
import qualified Data.Text.IO as Text


{- HLINT ignore "Reduce duplication" -}

newtype ByronQueryError = ByronQueryEnvVarSocketErr EnvSocketError
  deriving Int -> ByronQueryError -> ShowS
[ByronQueryError] -> ShowS
ByronQueryError -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ByronQueryError] -> ShowS
$cshowList :: [ByronQueryError] -> ShowS
show :: ByronQueryError -> String
$cshow :: ByronQueryError -> String
showsPrec :: Int -> ByronQueryError -> ShowS
$cshowsPrec :: Int -> ByronQueryError -> ShowS
Show

renderByronQueryError :: ByronQueryError -> Text
renderByronQueryError :: ByronQueryError -> Text
renderByronQueryError ByronQueryError
err =
  case ByronQueryError
err of
    ByronQueryEnvVarSocketErr EnvSocketError
sockEnvErr -> EnvSocketError -> Text
renderEnvSocketError EnvSocketError
sockEnvErr

--------------------------------------------------------------------------------
-- Query local node's chain tip
--------------------------------------------------------------------------------

runGetLocalNodeTip :: NetworkId -> ExceptT ByronQueryError IO ()
runGetLocalNodeTip :: NetworkId -> ExceptT ByronQueryError IO ()
runGetLocalNodeTip NetworkId
networkId = do
    SocketPath String
sockPath <- forall (m :: * -> *) x y a.
Functor m =>
(x -> y) -> ExceptT x m a -> ExceptT y m a
firstExceptT EnvSocketError -> ByronQueryError
ByronQueryEnvVarSocketErr
                             forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) x a. m (Either x a) -> ExceptT x m a
newExceptT IO (Either EnvSocketError SocketPath)
readEnvSocketPath
    let connctInfo :: LocalNodeConnectInfo ByronMode
connctInfo =
          LocalNodeConnectInfo {
            localNodeSocketPath :: String
localNodeSocketPath    = String
sockPath,
            localNodeNetworkId :: NetworkId
localNodeNetworkId     = NetworkId
networkId,
            localConsensusModeParams :: ConsensusModeParams ByronMode
localConsensusModeParams = EpochSlots -> ConsensusModeParams ByronMode
ByronModeParams (Word64 -> EpochSlots
EpochSlots Word64
21600)
          }

    ChainTip
tip <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall mode. LocalNodeConnectInfo mode -> IO ChainTip
getLocalChainTip LocalNodeConnectInfo ByronMode
connctInfo
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> IO ()
Text.putStrLn forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Text
Text.decodeUtf8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
LB.toStrict forall a b. (a -> b) -> a -> b
$ forall a. ToJSON a => a -> ByteString
encodePretty ChainTip
tip