module Update.Update
  ( Action(..)
  , updates
  , update
  ) where

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

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

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

import Utils.Maybe (..)

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

updates : Signal.Channel Action
updates = Signal.channel 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 action ->
      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 action)) 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 <- Dict.update id (Maybe.map (updateTimer Pause)) model.timers
      }
    ValidEdition ->
      validEdition model
    ClickAway ->
      { model | edition <- Nothing }
    KeyPressed keyCode ->
      if isRemoveKeyCode keyCode
        then
          { model | edition <- Maybe.map (updateEdition DeleteLast) model.edition }
        else
          { model | edition <- Maybe.map (updateEdition (AddChar keyCode)) model.edition }

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

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