App.purs

module Stores.App where


import Prelude
import Data.Generic
import Data.Maybe
-- import Control.Monad.Eff
import Control.Monad.Eff.Console (log)
import Data.Maybe.Unsafe (fromJust)
import Signal (Signal(), foldp, dropRepeats, mergeMany, constant)
import Data.Argonaut (Json(), (~>), (:=), (.?), jsonEmptyObject)
import Data.Argonaut.Encode (EncodeJson, gEncodeJson, encodeJson)
import Data.Argonaut.Decode (DecodeJson, gDecodeJson, decodeJson, decodeMaybe)


import Debug.Trace


import Types.Foo


type AppState =
  { foo :: Foo
  }


data Action =
  NoOp
  | Update AppState
  -- | DoFoo Json
  | DoFoo (Maybe Foo)


initialState :: AppState
initialState =
  { foo: initialFoo
  }


update :: Action -> AppState -> AppState
update action state = case action of
  -- DoFoo foo' -> case decodeMaybe foo' of
  --   Just f -> state { foo = runFoo f }
  --   Nothing -> state
  DoFoo foo' -> traceAny foo' \_ ->
    case foo' of
      Just f -> state { foo = f }
      Nothing -> state
  NoOp -> state


actions :: Maybe (Signal Action)
actions =
  mergeMany
    [ -- , map DoFoo outgoingFoo
    , map DoFoo incomingFoo
    ]


outgoingFoo :: Signal Json
outgoingFoo = constant $ encodeJson $ foo


incomingFoo :: Signal (Maybe Foo)
incomingFoo = map convert outgoingFoo


convert :: Json -> Maybe Foo
convert f = traceAny f \_ ->
  case decodeMaybe f of
    Just f' -> traceAny f' \_ ->
      runFooMaybe f'
    Nothing -> Nothing


changes :: Signal AppState
changes = foldp update initialState $ fromJust actions