module Update
  ( routerConfig
  , update
  ) where

import Task

import Effects exposing (Effects)
import TransitRouter
import RouteParser

import Route exposing (Route)

import Server

import Action exposing (..)

import Model exposing (Model)
import Model.Translations exposing (getMessage)
import Model.View as V

import LoggedIn.Model as LoggedInModel
import LoggedIn.Action as LoggedInAction
import LoggedIn.Update as LoggedInUpdate

import SignIn.Model as SignInModel
import SignIn.Action as SignInAction
import SignIn.Update as SignInUpdate

import Utils.Http exposing (errorKey)

routerConfig : TransitRouter.Config Route Action Model
routerConfig =
  { mountRoute = \_ _ model -> (model, Effects.none)
  , getDurations = \_ _ _ -> (50, 200)
  , actionWrapper = RouterAction
  , routeDecoder = Maybe.withDefault Route.Home << RouteParser.match Route.matchers
  }

update : Action -> Model -> (Model, Effects Action)
update action model =
  case action of

    NoOp ->
      (model, Effects.none)

    SignIn email ->
      ( applySignIn model (SignInAction.WaitingServer)
      , Server.signIn email
          |> Task.map (always (UpdateSignIn SignInAction.ValidLogin))
          |> flip Task.onError (\error ->
               Task.succeed (UpdateSignIn (SignInAction.ErrorLogin (errorKey error)))
             )
          |> Effects.task
      )

    GoLoggedInView init ->
      ( { model | view = V.LoggedInView (LoggedInModel.init init) }
      , Effects.none
      )

    UpdateTime time ->
      ({ model | currentTime = time }, Effects.none)

    GoSignInView ->
      ({ model | view = V.SignInView (SignInModel.init Nothing) }, Effects.none)

    UpdateSignIn signInAction ->
      (applySignIn model signInAction, Effects.none)

    UpdateLoggedIn loggedInAction ->
      applyLoggedIn model loggedInAction

    RouterAction routeAction ->
      TransitRouter.update
        routerConfig
        (Debug.log "routeAction" routeAction)
        model

    SignOut ->
      ( model
      , Server.signOut
          |> Task.map (always GoSignInView)
          |> flip Task.onError (always <| Task.succeed NoOp)
          |> Effects.task
      )

applySignIn : Model -> SignInAction.Action -> Model
applySignIn model signInAction =
  case model.view of
    V.SignInView signInView ->
      { model | view = V.SignInView (SignInUpdate.update model.translations signInAction signInView) }
    _ ->
      model

applyLoggedIn : Model -> LoggedInAction.Action -> (Model, Effects Action)
applyLoggedIn model loggedInAction =
  case model.view of
    V.LoggedInView loggedInView ->
      let (loggedInView, effects) = LoggedInUpdate.update model loggedInAction loggedInView
      in  ( { model | view = V.LoggedInView loggedInView }
          , Effects.map UpdateLoggedIn effects
          )
    _ ->
      (model, Effects.none)