module Chiasma.Interpreter.Codec where

import Chiasma.Codec (TmuxCodec)
import Chiasma.Data.CodecError (CodecError (CodecError))
import Chiasma.Data.DecodeError (DecodeError)
import qualified Chiasma.Data.Panes as Panes
import Chiasma.Data.Panes (Panes)
import qualified Chiasma.Data.TmuxCommand as TmuxCommand
import Chiasma.Data.TmuxCommand (TmuxCommand)
import Chiasma.Data.TmuxRequest (TmuxRequest)
import Chiasma.Data.TmuxResponse (TmuxResponse)
import qualified Chiasma.Effect.Codec as Codec
import Chiasma.Effect.Codec (Codec)

interpretCodecNative ::
  (∀ x . cmd x -> TmuxRequest) ->
  (∀ x . TmuxResponse -> cmd x -> Either DecodeError x) ->
  InterpreterFor (Codec cmd TmuxRequest TmuxResponse !! CodecError) r
interpretCodecNative :: forall (cmd :: * -> *) (r :: [Effect]).
(forall x. cmd x -> TmuxRequest)
-> (forall x. TmuxResponse -> cmd x -> Either DecodeError x)
-> InterpreterFor
     (Codec cmd TmuxRequest TmuxResponse !! CodecError) r
interpretCodecNative forall x. cmd x -> TmuxRequest
enc forall x. TmuxResponse -> cmd x -> Either DecodeError x
dec =
  (forall x (r0 :: [Effect]).
 Codec cmd TmuxRequest TmuxResponse (Sem r0) x
 -> Tactical
      (Resumable CodecError (Codec cmd TmuxRequest TmuxResponse))
      (Sem r0)
      (Stop CodecError : r)
      x)
-> InterpreterFor
     (Resumable CodecError (Codec cmd TmuxRequest TmuxResponse)) r
forall err (eff :: Effect) (r :: [Effect]).
(forall x (r0 :: [Effect]).
 eff (Sem r0) x
 -> Tactical (Resumable err eff) (Sem r0) (Stop err : r) x)
-> InterpreterFor (Resumable err eff) r
interpretResumableH \case
    Codec.Encode cmd a1
cmd ->
      x
-> Sem
     (WithTactics
        (Resumable CodecError (Codec cmd TmuxRequest TmuxResponse))
        f
        (Sem r0)
        (Stop CodecError : r))
     (f x)
forall (f :: * -> *) a (e :: Effect) (m :: * -> *) (r :: [Effect]).
Functor f =>
a -> Sem (WithTactics e f m r) (f a)
pureT (cmd a1 -> TmuxRequest
forall x. cmd x -> TmuxRequest
enc cmd a1
cmd)
    Codec.WithCodec cmd x
cmd TmuxRequest -> Sem r0 TmuxResponse
use -> do
      let req :: TmuxRequest
req = cmd x -> TmuxRequest
forall x. cmd x -> TmuxRequest
enc cmd x
cmd
      f TmuxResponse
out <- Sem r0 TmuxResponse
-> Tactical
     (Resumable CodecError (Codec cmd TmuxRequest TmuxResponse))
     (Sem r0)
     (Stop CodecError : r)
     TmuxResponse
forall (m :: * -> *) a (e :: Effect) (r :: [Effect]).
m a -> Tactical e m r a
runTSimple (TmuxRequest -> Sem r0 TmuxResponse
use TmuxRequest
req)
      Inspector forall x. f x -> Maybe x
ins <- Sem
  (WithTactics
     (Resumable CodecError (Codec cmd TmuxRequest TmuxResponse))
     f
     (Sem r0)
     (Stop CodecError : r))
  (Inspector f)
forall (e :: Effect) (f :: * -> *) (m :: * -> *) (r :: [Effect]).
Sem (WithTactics e f m r) (Inspector f)
getInspectorT
      x
-> Sem
     (WithTactics
        (Resumable CodecError (Codec cmd TmuxRequest TmuxResponse))
        f
        (Sem r0)
        (Stop CodecError : r))
     (f x)
forall (f :: * -> *) a (e :: Effect) (m :: * -> *) (r :: [Effect]).
Functor f =>
a -> Sem (WithTactics e f m r) (f a)
pureT (x
 -> Sem
      (WithTactics
         (Resumable CodecError (Codec cmd TmuxRequest TmuxResponse))
         f
         (Sem r0)
         (Stop CodecError : r))
      (f x))
-> Sem
     (WithTactics
        (Resumable CodecError (Codec cmd TmuxRequest TmuxResponse))
        f
        (Sem r0)
        (Stop CodecError : r))
     x
-> Sem
     (WithTactics
        (Resumable CodecError (Codec cmd TmuxRequest TmuxResponse))
        f
        (Sem r0)
        (Stop CodecError : r))
     (f x)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (DecodeError -> CodecError)
-> Either DecodeError x
-> Sem
     (WithTactics
        (Resumable CodecError (Codec cmd TmuxRequest TmuxResponse))
        f
        (Sem r0)
        (Stop CodecError : r))
     x
forall err err' (r :: [Effect]) a.
Member (Stop err') r =>
(err -> err') -> Either err a -> Sem r a
stopEitherWith (TmuxRequest -> DecodeError -> CodecError
CodecError TmuxRequest
req) (TmuxResponse -> cmd x -> Either DecodeError x
forall x. TmuxResponse -> cmd x -> Either DecodeError x
dec (Maybe TmuxResponse -> TmuxResponse
forall m. Monoid m => Maybe m -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold (f TmuxResponse -> Maybe TmuxResponse
forall x. f x -> Maybe x
ins f TmuxResponse
out)) cmd x
cmd)

interpretCodecTmuxCommand ::
  InterpreterFor (Codec TmuxCommand TmuxRequest TmuxResponse !! CodecError) r
interpretCodecTmuxCommand :: forall (r :: [Effect]) a.
Sem
  ((Codec TmuxCommand TmuxRequest TmuxResponse !! CodecError) : r) a
-> Sem r a
interpretCodecTmuxCommand =
  (forall x. TmuxCommand x -> TmuxRequest)
-> (forall x.
    TmuxResponse -> TmuxCommand x -> Either DecodeError x)
-> InterpreterFor
     (Codec TmuxCommand TmuxRequest TmuxResponse !! CodecError) r
forall (cmd :: * -> *) (r :: [Effect]).
(forall x. cmd x -> TmuxRequest)
-> (forall x. TmuxResponse -> cmd x -> Either DecodeError x)
-> InterpreterFor
     (Codec cmd TmuxRequest TmuxResponse !! CodecError) r
interpretCodecNative TmuxCommand x -> TmuxRequest
forall x. TmuxCommand x -> TmuxRequest
TmuxCommand.encode TmuxResponse -> TmuxCommand x -> Either DecodeError x
forall x. TmuxResponse -> TmuxCommand x -> Either DecodeError x
TmuxCommand.decode
{-# inline interpretCodecTmuxCommand #-}

interpretCodecPanes ::
  TmuxCodec p =>
  InterpreterFor (Codec (Panes p) TmuxRequest TmuxResponse !! CodecError) r
interpretCodecPanes :: forall p (r :: [Effect]).
TmuxCodec p =>
InterpreterFor
  (Codec (Panes p) TmuxRequest TmuxResponse !! CodecError) r
interpretCodecPanes =
  (forall x. Panes p x -> TmuxRequest)
-> (forall x. TmuxResponse -> Panes p x -> Either DecodeError x)
-> InterpreterFor
     (Codec (Panes p) TmuxRequest TmuxResponse !! CodecError) r
forall (cmd :: * -> *) (r :: [Effect]).
(forall x. cmd x -> TmuxRequest)
-> (forall x. TmuxResponse -> cmd x -> Either DecodeError x)
-> InterpreterFor
     (Codec cmd TmuxRequest TmuxResponse !! CodecError) r
interpretCodecNative Panes p x -> TmuxRequest
forall x. Panes p x -> TmuxRequest
forall p a. TmuxCodec p => Panes p a -> TmuxRequest
Panes.encode TmuxResponse -> Panes p x -> Either DecodeError x
forall x. TmuxResponse -> Panes p x -> Either DecodeError x
forall p a.
TmuxCodec p =>
TmuxResponse -> Panes p a -> Either DecodeError a
Panes.decode
{-# inline interpretCodecPanes #-}

interpretCodecPure ::
  (∀ a . command a -> Sem r (Either Text a)) ->
  InterpreterFor (Codec command () decode !! Text) r
interpretCodecPure :: forall (command :: * -> *) (r :: [Effect]) decode.
(forall a. command a -> Sem r (Either Text a))
-> InterpreterFor (Codec command () decode !! Text) r
interpretCodecPure forall a. command a -> Sem r (Either Text a)
run =
  (forall x (r0 :: [Effect]).
 Codec command () decode (Sem r0) x
 -> Tactical
      (Resumable Text (Codec command () decode))
      (Sem r0)
      (Stop Text : r)
      x)
-> InterpreterFor (Resumable Text (Codec command () decode)) r
forall err (eff :: Effect) (r :: [Effect]).
(forall x (r0 :: [Effect]).
 eff (Sem r0) x
 -> Tactical (Resumable err eff) (Sem r0) (Stop err : r) x)
-> InterpreterFor (Resumable err eff) r
interpretResumableH \case
    Codec.Encode command a1
_ ->
      x
-> Sem
     (WithTactics
        (Resumable Text (Codec command () decode))
        f
        (Sem r0)
        (Stop Text : r))
     (f x)
forall (f :: * -> *) a (e :: Effect) (m :: * -> *) (r :: [Effect]).
Functor f =>
a -> Sem (WithTactics e f m r) (f a)
pureT ()
    Codec.WithCodec command x
cmd () -> Sem r0 decode
_ ->
      (Text
 -> Sem
      (WithTactics
         (Resumable Text (Codec command () decode))
         f
         (Sem r0)
         (Stop Text : r))
      (f x))
-> (x
    -> Sem
         (WithTactics
            (Resumable Text (Codec command () decode))
            f
            (Sem r0)
            (Stop Text : r))
         (f x))
-> Either Text x
-> Sem
     (WithTactics
        (Resumable Text (Codec command () decode))
        f
        (Sem r0)
        (Stop Text : r))
     (f x)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Text
-> Sem
     (WithTactics
        (Resumable Text (Codec command () decode))
        f
        (Sem r0)
        (Stop Text : r))
     (f x)
forall e (r :: [Effect]) a. Member (Stop e) r => e -> Sem r a
stop x
-> Sem
     (WithTactics
        (Resumable Text (Codec command () decode))
        f
        (Sem r0)
        (Stop Text : r))
     (f x)
forall (f :: * -> *) a (e :: Effect) (m :: * -> *) (r :: [Effect]).
Functor f =>
a -> Sem (WithTactics e f m r) (f a)
pureT (Either Text x
 -> Sem
      (WithTactics
         (Resumable Text (Codec command () decode))
         f
         (Sem r0)
         (Stop Text : r))
      (f x))
-> Sem
     (WithTactics
        (Resumable Text (Codec command () decode))
        f
        (Sem r0)
        (Stop Text : r))
     (Either Text x)
-> Sem
     (WithTactics
        (Resumable Text (Codec command () decode))
        f
        (Sem r0)
        (Stop Text : r))
     (f x)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Sem (Stop Text : r) (Either Text x)
-> Sem
     (WithTactics
        (Resumable Text (Codec command () decode))
        f
        (Sem r0)
        (Stop Text : r))
     (Either Text x)
forall (e :: Effect) (r :: [Effect]) a. Sem r a -> Sem (e : r) a
raise (Sem r (Either Text x) -> Sem (Stop Text : r) (Either Text x)
forall (e :: Effect) (r :: [Effect]) a. Sem r a -> Sem (e : r) a
raise (command x -> Sem r (Either Text x)
forall a. command a -> Sem r (Either Text a)
run command x
cmd))