App.hs

module Tricorder.CLI.App (run) where

import Atelier.Effects.Clock (Clock)
import Atelier.Effects.Conc (Conc)
import Atelier.Effects.Console (Console)
import Atelier.Effects.Delay (Delay)
import Atelier.Effects.Exit (Exit)
import Atelier.Effects.File (File)
import Atelier.Effects.FileSystem (FileSystem)
import Atelier.Effects.Posix.Daemons (Daemons)
import Atelier.Effects.Process (Process)
import Atelier.Effects.Timeout (Timeout)
import Effectful (IOE)
import Effectful.Concurrent (Concurrent)
import Effectful.Reader.Static (Reader, ask, asks)
import Prelude hiding (force)

import Atelier.Effects.Console qualified as Console
import Data.Text qualified as T

import Tricorder.Build (BuildState (..))
import Tricorder.CLI.Arguments (Command (..), LogMode (..))
import Tricorder.CLI.Daemon
    ( restartDaemon
    , startDaemon
    , stopDaemon
    , waitForDaemon
    )
import Tricorder.CLI.Operations
    ( showEvalComments
    , showLog
    , showSource
    , showStatus
    , showTests
    )
import Tricorder.CLI.UI (viewUi)
import Tricorder.CLI.UI.Brick (Brick)
import Tricorder.CLI.UI.BrickChan (BrickChan)
import Tricorder.Daemon.DaemonInfo (DaemonInfo (..))
import Tricorder.Runtime (LogPath (..), PidFile (..), SocketPath (..))
import Tricorder.Socket.Client (isDaemonRunning, queryStatus)
import Tricorder.Socket.UnixSocket (UnixSocket)

import Tricorder.CLI.UI.Keys qualified as Keys


run
    :: ( Brick :> es
       , BrickChan :> es
       , Clock :> es
       , Conc :> es
       , Concurrent :> es
       , Console :> es
       , Daemons :> es
       , Delay :> es
       , Exit :> es
       , File :> es
       , FileSystem :> es
       , IOE :> es
       , Process :> es
       , Reader Command :> es
       , Reader Keys.Config :> es
       , Reader LogPath :> es
       , Reader PidFile :> es
       , Reader SocketPath :> es
       , Timeout :> es
       , UnixSocket :> es
       )
    => Eff es ()
run =
    ask >>= \case
        Start -> do
            running <- isDaemonRunning
            if running then
                Console.putStrLn "Daemon already running."
            else do
                startDaemon
                ready <- waitForDaemon
                if ready then
                    Console.putStrLn "Daemon started."
                else
                    Console.putStrLn "Daemon started, but the socket is not responding yet."
        Stop force -> do
            running <- isDaemonRunning
            when running
                $ stopDaemon force >>= \case
                    Left reasons ->
                        Console.putTextLn
                            $ T.intercalate "\n"
                            $ "Was unable to stop the daemon:" : reasons
                    Right result -> do
                        Console.putTextLn result
        Status opts -> do
            running <- isDaemonRunning
            if not running then
                Console.putStrLn "Stopped."
            else
                showStatus opts
        Test opts -> do
            running <- isDaemonRunning
            if not running then
                Console.putStrLn "Stopped."
            else
                showTests opts
        Log logMode -> do
            running <- isDaemonRunning
            logFile <-
                if running then do
                    SocketPath sp <- ask
                    result <- queryStatus sp
                    LogPath fallback <- ask
                    pure $ case result of
                        Right state -> state.daemonInfo.logFile
                        Left _ -> fallback
                else
                    asks @LogPath (.getLogPath)
            case logMode of
                ShowLog followMode -> showLog logFile followMode
                ShowLogPath -> Console.putTextLn (toText logFile)
        UI -> do
            running <- isDaemonRunning
            unless running do
                startDaemon
                void waitForDaemon
            viewUi
        Source moduleNames -> do
            running <- isDaemonRunning
            unless running $ do
                startDaemon
                void waitForDaemon
            showSource moduleNames
        Restart force ->
            restartDaemon force >>= \case
                Just (Left reasons) -> traverse_ Console.putTextLn reasons
                _ -> pass
        EvalComments opts -> do
            running <- isDaemonRunning
            unless running do
                startDaemon
                void waitForDaemon
            showEvalComments opts