module Page.EditValue
  ( Model,
    initialModel,
    Action,
    updateModel,
    viewModel,
  )
where

import Api
import Data.Aeson qualified as A
import Data.Aeson.KeyMap qualified as AM
import Data.ByteString.Lazy.UTF8 as LB
import Data.Maybe
import Form qualified as F
import Miso
import Miso.String (toMisoString)
import Schema

data Model = Model
  { collection :: String,
    fileName :: String,
    input :: Maybe A.Value,
    schema :: Schema
  }
  deriving (Show, Eq)

initialModel :: String -> String -> JSM (Either String Model)
initialModel collection fileName = do
  schema' <- fetchSchema
  input' <- fetchPost fileName
  pure do
    schema <- schema'
    input <- input'
    pure $ Model {..}

data Action
  = NoOp
  | FormChanged A.Value
  | FormSubmitted A.Value
  | EntityWritten (Either String ())
  deriving (Eq, Show)

updateModel :: Action -> Model -> Effect Action Model
updateModel NoOp m = noEff m
updateModel (FormChanged (Just -> input)) m = noEff m {input}
updateModel (FormSubmitted output) m =
  m <# do EntityWritten <$> updatePost m.fileName output
updateModel (EntityWritten _) m = noEff m

viewModel :: Model -> View Action
viewModel m = do
  let input = (fromMaybe (A.Object AM.empty) m.input)
  div_ [] $
    [ viewForm input m.schema,
      viewInput input,
      viewOutput input m.schema
    ]

viewForm :: A.Value -> Schema -> View Action
viewForm input =
  fmap (either FormChanged FormSubmitted)
    . flip F.runForm input
    . schemaForm

viewInput :: A.Value -> View Action
viewInput input =
  pre_ [] [text (toMisoString (A.encode input))]

viewOutput :: A.Value -> Schema -> View Action
viewOutput input schema =
  pre_ [] $
    [ text $
        toMisoString
          ( either ("Left " <>) (("Right " <>) . LB.toString) $
              (A.encode <$> ((schemaForm schema).fill input))
          )
    ]