module LoggedIn.Home.Update
  ( update
  ) where

import Date
import Dict
import Debug
import Task
import String

import Effects exposing (Effects)
import Http exposing (Error(..))

import Server

import LoggedIn.Home.Action as LoggedInAction
import LoggedIn.Home.Model as LoggedInModel

import LoggedIn.Home.Account.Action as AccountAction
import LoggedIn.Home.Account.Update as AccountUpdate

import LoggedIn.Home.AddPayment.Action as AddPaymentAction
import LoggedIn.Home.AddPayment.Model as AddPaymentModel
import LoggedIn.Home.AddPayment.Update as AddPaymentUpdate

import LoggedIn.Home.Monthly.Action as MonthlyAction
import LoggedIn.Home.Monthly.Model as MonthlyModel
import LoggedIn.Home.Monthly.Update as MonthlyUpdate

import Model exposing (Model)
import Model.User exposing (UserId)
import Model.Payment exposing (..)
import Model.Translations exposing (Translations, getMessage)

update : Model -> LoggedInAction.Action -> LoggedInModel.Model -> (LoggedInModel.Model, Effects LoggedInAction.Action)
update model action loggedInModel =
  case action of

    LoggedInAction.NoOp -> (loggedInModel, Effects.none)

    LoggedInAction.UpdateAdd addPaymentAction ->
      ( { loggedInModel | add = AddPaymentUpdate.update addPaymentAction loggedInModel.add }
      , Effects.none
      )

    LoggedInAction.UpdatePayments payments ->
      ( { loggedInModel | payments = payments }
      , Effects.none
      )

    LoggedInAction.AddPayment name cost frequency ->
      ( { loggedInModel | add = AddPaymentUpdate.update AddPaymentAction.WaitingServer loggedInModel.add }
      , Server.addPayment name cost frequency
          |> Task.map (\paymentId ->
               case String.toInt cost of
                 Err _ ->
                   LoggedInAction.UpdateAdd (AddPaymentAction.AddError Nothing (Just (getMessage "CostRequired" model.translations)))
                 Ok costNumber ->
                   LoggedInAction.ValidateAddPayment paymentId name costNumber frequency
             )
          |> flip Task.onError (\err ->
              case err of
                BadResponse 400 jsonErr ->
                  case AddPaymentUpdate.addPaymentError model.translations jsonErr of
                    Just addPaymentAction -> Task.succeed (LoggedInAction.UpdateAdd addPaymentAction)
                    Nothing -> Task.succeed LoggedInAction.NoOp
                _ ->
                  Task.succeed LoggedInAction.NoOp
             )
          |> Effects.task
      )

    LoggedInAction.ValidateAddPayment paymentId name cost frequency ->
      let newPayment = Payment paymentId (Date.fromTime model.currentTime) name cost loggedInModel.account.me
          newAdd = AddPaymentModel.init frequency
      in  case frequency of
            Punctual ->
              ( { loggedInModel
                | currentPage = 1
                , add = newAdd
                , account = loggedInModel.account
                , payments = newPayment :: loggedInModel.payments
                }
              , Effects.none
              )
            Monthly ->
              ( { loggedInModel
                | add = newAdd
                , monthly = MonthlyUpdate.update (MonthlyAction.AddPayment newPayment) loggedInModel.monthly
                }
              , Effects.none
              )

    LoggedInAction.ToggleEdit id ->
      ( { loggedInModel | paymentEdition = if loggedInModel.paymentEdition == Just id then Nothing else Just id }
      , Effects.none
      )

    LoggedInAction.DeletePayment payment frequency ->
      ( loggedInModel
      , Server.deletePayment payment frequency
          |> Task.map (always (LoggedInAction.ValidateDeletePayment payment frequency))
          |> flip Task.onError (always <| Task.succeed LoggedInAction.NoOp)
          |> Effects.task
      )

    LoggedInAction.ValidateDeletePayment payment frequency ->
      case frequency of
        Monthly ->
          ( { loggedInModel
            | monthly = MonthlyUpdate.update (MonthlyAction.DeletePayment payment) loggedInModel.monthly
            }
          , Effects.none
          )
        Punctual ->
          ( { loggedInModel
            | account = loggedInModel.account
            , payments = deletePayment payment.id loggedInModel.payments
            }
          , Effects.none
          )

    LoggedInAction.UpdatePage page ->
      ( { loggedInModel | currentPage = page }
      , Effects.none
      )

    LoggedInAction.UpdateMonthly monthlyAction ->
      ( { loggedInModel | monthly = MonthlyUpdate.update monthlyAction loggedInModel.monthly }
      , Effects.none
      )

    LoggedInAction.UpdateAccount accountAction ->
      let (newAccount, accountEffects) = AccountUpdate.update accountAction loggedInModel.account
      in  ( { loggedInModel | account = newAccount }
          , Effects.map LoggedInAction.UpdateAccount accountEffects
          )