module View.App
  ( widget
  ) where

import qualified Data.Text            as T
import           Prelude              hiding (error, init)
import           Reflex.Dom           (Dynamic, MonadWidget)
import qualified Reflex.Dom           as R

import           Common.Model         (Currency, Init (..), InitResult (..),
                                       UserId)
import qualified Common.Msg           as Msg

import           Model.Route          (Route (..))
import qualified Util.Router          as Router
import qualified View.Header          as Header
import qualified View.Income.Income   as Income
import qualified View.NotFound        as NotFound
import qualified View.Payment.Payment as Payment
import qualified View.SignIn          as SignIn

widget :: InitResult -> IO ()
widget initResult =
  R.mainWidget $ R.divClass "app" $ do

    route <- getRoute

    header <- Header.view $ Header.In
      { Header._in_initResult = initResult
      , Header._in_isInitSuccess =
        case initResult of
          InitSuccess _ -> True
          _             -> False
      , Header._in_route = route
      }

    let signOut =
          Header._out_signOut header

        mainContent =
          case initResult of
            InitSuccess init ->
              signedWidget init route

            InitEmpty ->
              SignIn.view SignIn.EmptyMessage

            InitError error ->
              SignIn.view (SignIn.ErrorMessage error)

        signOutContent =
          SignIn.view (SignIn.SuccessMessage $ Msg.get Msg.SignIn_DisconnectSuccess)

    _ <- R.widgetHold (mainContent) (signOutContent <$ signOut)

    R.blank

signedWidget :: MonadWidget t m => Init -> Dynamic t Route -> m ()
signedWidget init route = do
  R.dyn . R.ffor route $ \case
    RootRoute ->
      Payment.view $ Payment.In
        { Payment._in_currentUser = _init_currentUser init
        , Payment._in_currency = _init_currency init
        , Payment._in_users = _init_users init
        }

    IncomeRoute ->
      Income.view $ Income.In
        { Income._in_currentUser = _init_currentUser init
        , Income._in_currency = _init_currency init
        , Income._in_users = _init_users init
        }

    NotFoundRoute ->
      NotFound.view

  return ()

getRoute :: MonadWidget t m => m (Dynamic t Route)
getRoute = do
  r <- Router.partialPathRoute "" . R.switchPromptlyDyn =<< R.holdDyn R.never R.never
  return . R.ffor r $ \case
    [""] ->
      RootRoute

    ["income"] ->
      IncomeRoute

    _ ->
      NotFoundRoute