module App.Page.RegisterSpec (spec) where

import Prelude

import App.DSL.Auth (AuthF(..), AuthInfo(..), Role(..), AUTH, _auth)
import App.Page.Register (Query(..), eval)
import App.Types (unsafeName)
import Control.Monad.Free (foldFree)
import Control.Monad.Writer (WriterT, runWriterT, tell)
import Data.Tuple (Tuple(..))
import Effect.Aff (Aff)
import Halogen.Query.HalogenM (HalogenF(..), HalogenM(..))
import Run (Run, case_, on)
import Run as Run
import Test.Spec (Spec, describe, it)
import Test.Spec.Assertions (shouldContain)
import Unsafe.Coerce (unsafeCoerce)

spec :: Spec Unit
spec = describe "Register page" do
  it "sends register request" $ do
    Tuple _ log <- runWriterT $ Run.interpret (case_ # on _auth interpretAuth) $ runHalogenM do
      eval (SetName "test name" unit)
      eval (SetEmail "test@gmail.com" unit)
      eval (SetPassword "test password" unit)
      eval (SetPasswordCheck "test password" unit)
      eval (MakeRequest unit)
      pure unit
    log `shouldContain` "register"

interpretAuth :: AuthF ~> WriterT (Array String) Aff
interpretAuth = case _ of
  Register info next -> do
    tell [ "register" ]
    pure next
  Login creds fnext -> do
    tell [ "login" ]
    pure $ fnext $ AuthInfo { name: unsafeName "Yura", role: User }

type M = Run (auth :: AUTH)

runHalogenM
  :: ∀ s f g p o a
   . HalogenM s f g p o M a
  -> Run (auth :: AUTH) a
runHalogenM (HalogenM hm) = foldFree nt hm where
  nt :: HalogenF s f g p o M ~> M
  nt = case _ of
    State f -> unsafeCoerce unit
    Subscribe _ next -> pure next
    Lift ma -> ma
    Halt msg -> unsafeCoerce unit
    GetSlots f -> unsafeCoerce unit
    CheckSlot p f -> unsafeCoerce unit
    ChildQuery p c -> unsafeCoerce unit
    Raise o a -> pure a
    Par ap -> unsafeCoerce unit
    Fork f -> unsafeCoerce unit
    GetRef label f -> unsafeCoerce unit