{-# LANGUAGE Arrows #-}

module LiveCoding.Gloss.Debugger where

-- base
import Control.Arrow
import Data.Data

-- transformers
import Control.Monad.Trans.Class
import Control.Monad.Trans.State.Strict
import Control.Monad.Trans.Writer.Strict

-- syb
import Data.Generics.Text

-- gloss
import Graphics.Gloss

-- essence-of-live-coding
import LiveCoding

-- essence-of-live-coding-gloss
import LiveCoding.Gloss.PictureM

statePicture :: Data s => s -> Picture
statePicture :: forall s. Data s => s -> Picture
statePicture = Float -> Float -> Picture -> Picture
translate (-Float
100) Float
200 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Float -> Picture -> Picture
scale Float
0.2 Float
0.2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Color -> Picture -> Picture
color Color
red forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Picture
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s. Data s => s -> String
stateShow

statePlay :: Debugger PictureM
statePlay :: Debugger PictureM
statePlay = forall (m :: * -> *).
(forall s. Data s => LiveProgram (StateT s m)) -> Debugger m
Debugger forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => Cell m () () -> LiveProgram m
liveCell forall a b. (a -> b) -> a -> b
$ forall s.
Data s =>
Integer -> Cell (StateT s PictureM) () (Maybe Picture)
every Integer
2 forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall a (m :: * -> *).
(Data a, Monad m) =>
a -> Cell m (Maybe a) a
hold Picture
blank forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> forall a (m :: * -> *) b. (a -> m b) -> Cell m a b
arrM (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) w. Monad m => w -> WriterT w m ()
tell)

every :: Data s => Integer -> Cell (StateT s PictureM) () (Maybe Picture)
every :: forall s.
Data s =>
Integer -> Cell (StateT s PictureM) () (Maybe Picture)
every Integer
maxN = proc () -> do
  Integer
n <- forall (m :: * -> *) a. (Monad m, Num a, Data a) => Cell m a a
sumC -< Integer
1
  if Integer
n forall a. Integral a => a -> a -> a
`mod` Integer
maxN forall a. Eq a => a -> a -> Bool
== Integer
0
    then do
      s
s <- forall (m :: * -> *) s a. Monad m => Cell (StateT s m) a s
getC -< ()
      let pic :: Picture
pic = forall s. Data s => s -> Picture
statePicture s
s
      forall (a :: * -> * -> *) b. Arrow a => a b b
returnA -< forall a. a -> Maybe a
Just Picture
pic
    else forall (a :: * -> * -> *) b. Arrow a => a b b
returnA -< forall a. Maybe a
Nothing