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         (Init, InitResult (..))
import qualified Common.Msg           as Msg

import           Model.Route          (Route (..))
import qualified Util.Router          as Router
import           View.Header          (HeaderIn (..))
import qualified View.Header          as Header
import           View.Income.Income   (IncomeIn (..))
import qualified View.Income.Income   as Income
import qualified View.NotFound        as NotFound
import           View.Payment.Payment (PaymentIn (..))
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

    headerOut <- Header.view $ HeaderIn
      { _headerIn_initResult = initResult
      , _headerIn_isInitSuccess =
        case initResult of
          InitSuccess _ -> True
          _             -> False
      , _headerIn_route = route
      }

    let signOut =
          Header._headerOut_signOut headerOut

        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 $ PaymentIn
        { _paymentIn_init = init
        }

    IncomeRoute ->
      Income.view $ IncomeIn
        { _incomeIn_init = 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