module View.Payment.Add
  ( view
  , AddIn(..)
  , AddOut(..)
  ) where

import           Control.Monad.IO.Class    (liftIO)
import qualified Data.Map                  as M
import qualified Data.Maybe                as Maybe
import qualified Data.Text                 as T
import qualified Data.Time.Calendar        as Calendar
import qualified Data.Time.Clock           as Time
import qualified Data.Validation           as V
import           Reflex.Dom                (Event, MonadWidget, Reflex)
import qualified Reflex.Dom                as R
import qualified Text.Read                 as T

import           Common.Model              (Category (..), CreatePayment (..),
                                            CreatedPayment (..), Frequency (..),
                                            Payment (..), PaymentCategory (..))
import qualified Common.Msg                as Msg
import qualified Common.Util.Time          as Time
import qualified Common.Validation.Payment as PaymentValidation
import           Component                 (ButtonIn (..), InputIn (..),
                                            InputOut (..), SelectIn (..),
                                            SelectOut (..))
import qualified Component                 as Component
import qualified Util.Ajax                 as Ajax
import qualified Util.Either               as EitherUtil
import qualified Util.Validation           as ValidationUtil
import qualified Util.WaitFor              as WaitFor

data AddIn t = AddIn
  { _addIn_categories :: [Category]
  , _addIn_cancel     :: Event t ()
  }

data AddOut t = AddOut
  { _addOut_cancel             :: Event t ()
  , _addOut_addPayment         :: Event t CreatedPayment
  , _addOut_addPaymentCategory :: Event t PaymentCategory
  }

view :: forall t m. MonadWidget t m => AddIn t -> m (AddOut t)
view addIn = do
  R.divClass "add" $ do
    R.divClass "addHeader" $ R.text $ Msg.get Msg.Payment_Add

    R.divClass "addContent" $ do
      rec
        let reset = R.leftmost
              [ const "" <$> cancel
              , const "" <$> addPayment
              , const "" <$> _addIn_cancel addIn
              ]

        name <- _inputOut_value <$> (Component.input
          (Component.defaultInputIn
            { _inputIn_label = Msg.get Msg.Payment_Name
            , _inputIn_validation = PaymentValidation.name
            })
          reset
          validate)

        cost <- _inputOut_value <$> (Component.input
          (Component.defaultInputIn
            { _inputIn_label = Msg.get Msg.Payment_Cost
            , _inputIn_validation = PaymentValidation.cost
            })
          reset
          validate)

        now <- liftIO Time.getCurrentTime

        currentDay <- do
          d <- liftIO $ Time.timeToDay now
          return . T.pack . Calendar.showGregorian $ d

        date <- _inputOut_value <$> (Component.input
          (Component.defaultInputIn
            { _inputIn_label = Msg.get Msg.Payment_Date
            , _inputIn_initialValue = currentDay
            , _inputIn_inputType = "date"
            , _inputIn_hasResetButton = False
            , _inputIn_validation = PaymentValidation.date
            })
          (const currentDay <$> reset)
          validate)

        frequency <- _selectOut_value <$> (Component.select $ SelectIn
          { _selectIn_label = Msg.get Msg.Payment_Frequency
          , _selectIn_initialValue = Punctual
          , _selectIn_values = R.constDyn frequencies
          , _selectIn_reset = reset
          , _selectIn_isValid = const True
          , _selectIn_validate = validate
          })

        category <- _selectOut_value <$> (Component.select $ SelectIn
          { _selectIn_label = Msg.get Msg.Payment_Category
          , _selectIn_initialValue = -1
          , _selectIn_values = R.constDyn categories
          , _selectIn_reset = reset
          , _selectIn_isValid = \id -> id /= -1
          , _selectIn_validate = validate
          })

        let payment = do
              n <- name
              c <- cost
              d <- date
              cat <- category
              f <- frequency
              pure $ do
                n' <- n
                c' <- c
                d' <- d
                pure $ CreatePayment
                  <$> ValidationUtil.nelError n'
                  <*> ValidationUtil.nelError c'
                  <*> ValidationUtil.nelError d'
                  <*> ValidationUtil.nelError (V.Success cat)
                  <*> ValidationUtil.nelError (V.Success f)

        (addPayment, cancel, validate) <- R.divClass "buttons" $ do
          rec
            cancel <- Component._buttonOut_clic <$> (Component.button $
              (Component.defaultButtonIn (R.text $ Msg.get Msg.Dialog_Undo))
                { _buttonIn_class = R.constDyn "undo" })

            validate <- Component._buttonOut_clic <$> (Component.button $
              (Component.defaultButtonIn (R.text $ Msg.get Msg.Dialog_Confirm))
                { _buttonIn_class = R.constDyn "confirm"
                , _buttonIn_waiting = waiting
                , _buttonIn_submit = True
                })

            (addPayment, waiting) <- WaitFor.waitFor
              (Ajax.postJson "/payment")
              (ValidationUtil.fireValidation payment validate)

          return (R.fmapMaybe EitherUtil.eitherToMaybe addPayment, cancel, validate)

      return AddOut
        { _addOut_cancel = cancel
        , _addOut_addPayment = addPayment
        }

  where
    frequencies = M.fromList
      [ (Punctual, Msg.get Msg.Payment_PunctualMale)
      , (Monthly, Msg.get Msg.Payment_MonthlyMale)
      ]

    categories = M.fromList . flip map (_addIn_categories addIn) $ \c ->
      (_category_id c, _category_name c)