module Update.Update
  ( Action(..)
  , actions
  , logUpdate
  , update
  ) where

import Signal
import Dict
import Dict exposing (Dict)
import Time exposing (Time)
import Maybe
import Keyboard exposing (KeyCode)
import Char
import List
import Debug

import Model.Model exposing (..)
import Model.Timer exposing (..)
import Model.Edition.Edition exposing (..)
import Model.Edition.NameEdition exposing (..)
import Model.Edition.TimeEdition exposing (..)
import Model.Id exposing (..)
import Model.IdGenerator exposing (..)

import Update.UpdateTimer exposing (..)
import Update.UpdateEdition exposing (..)

import Utils.Maybe exposing (..)

type Action =
  NoOp
  | Initialize
  | AddNewTimer
  | DeltaTime Time
  | UpdateTimer Id TimerAction
  | RemoveTimer Id
  | Edit Id Kind
  | ClickAway
  | KeyPressed KeyCode

actions : Signal.Mailbox Action
actions = Signal.mailbox NoOp

logUpdate : Action -> Model -> Model
logUpdate action model =
  case action of
    DeltaTime _ -> update action model
    _ -> update (Debug.log "action" action) model

update : Action -> Model -> Model
update action model =
  case action of
    NoOp -> model
    Initialize ->
      initialModel model.currentTime
    AddNewTimer ->
      let (id, newTimerIdGenerator) = getId model.timerIdGenerator
      in  { model
          | timers <- Dict.insert id (initialTimer model.currentTime) model.timers
          , timerIdGenerator <- newTimerIdGenerator
          }
    DeltaTime delta ->
      { model
      | currentTime <- model.currentTime + delta
      , timers <- Dict.map (\id timer -> updateTimer (SubstractTime delta) timer) model.timers
      }
    UpdateTimer id timerAction ->
      let maybeEdition = filterMaybe (\edition -> edition.id == id) model.edition
          newModel =
            case maybeEdition of
              Just edition ->
                if edition.kind == Time then validEdition model else model
              Nothing ->
                model
      in  { newModel | timers <- Dict.update id (Maybe.map (updateTimer timerAction)) newModel.timers }
    RemoveTimer id ->
      if numberOfTimers model > 1
        then
          { model | timers <- Dict.remove id model.timers }
        else
          model
    Edit id kind ->
      { model
      | edition <- Just (newEdition id kind)
      , timers <-
          if kind == Time
            then Dict.update id (Maybe.map (updateTimer Pause)) model.timers
            else model.timers
      }
    ClickAway ->
      { model | edition <- Nothing }
    KeyPressed keyCode ->
      if isEnterKeyCode keyCode
        then
          validEdition model
        else
          let editionAction =
            if isRemoveKeyCode keyCode
              then DeleteLast
              else AddChar keyCode
          in  { model | edition <- Maybe.map (updateEdition editionAction) model.edition }

validEdition : Model -> Model
validEdition model =
  case model.edition of
    Just edition ->
      if isEmpty edition
        then
          { model
          | edition <- Nothing
          }
        else
          let timerAction =
            case edition.kind of
              Name ->
                Rename (renderNameEdition edition.chars)
              Time ->
                SetTime (toTime edition.chars)
          in  { model
              | timers <- Dict.update edition.id (Maybe.map (updateTimer timerAction)) model.timers
              , edition <- Nothing
              }
    Nothing ->
      model

isEnterKeyCode : KeyCode -> Bool
isEnterKeyCode = (==) 13

isRemoveKeyCode : KeyCode -> Bool
isRemoveKeyCode = (==) 8