module View.Payment.Payment
  ( init
  , view
  , PaymentIn(..)
  ) where

import           Data.Text           (Text)
import qualified Data.Text           as T
import           Data.Time.Clock     (NominalDiffTime)
import           Prelude             hiding (init)
import           Reflex.Dom          (Dynamic, Event, MonadWidget, Reflex)
import qualified Reflex.Dom          as R

import           Common.Model        (Currency, Frequency, Income (..),
                                      Payment (..), PaymentCategory (..),
                                      PaymentId, SavedPayment (..), User,
                                      UserId)
import qualified Common.Util.Text    as T

import           Model.Loadable      (Loadable (..))
import qualified Model.Loadable      as Loadable
import qualified Util.Ajax           as AjaxUtil
import           View.Payment.Header (HeaderIn (..), HeaderOut (..))
import qualified View.Payment.Header as Header
import           View.Payment.Init   (Init (..))
import           View.Payment.Pages  (PagesIn (..), PagesOut (..))
import qualified View.Payment.Pages  as Pages
import           View.Payment.Table  (TableIn (..), TableOut (..))
import qualified View.Payment.Table  as Table

init :: forall t m. MonadWidget t m => m (Dynamic t (Loadable Init))
init = do
  postBuild <- R.getPostBuild

  incomesEvent <- AjaxUtil.get (R.tag (R.constant "api/incomes") postBuild)
  incomes <- Loadable.fromEvent incomesEvent

  usersEvent <- AjaxUtil.get (R.tag (R.constant "api/users") postBuild)
  users <- Loadable.fromEvent usersEvent

  paymentsEvent <- AjaxUtil.get (R.tag (R.constant "api/payments") postBuild)
  payments <- Loadable.fromEvent paymentsEvent

  paymentCategoriesEvent <- AjaxUtil.get (R.tag (R.constant "api/paymentCategories") postBuild)
  paymentCategories <- Loadable.fromEvent paymentCategoriesEvent

  categoriesEvent <- AjaxUtil.get (R.tag (R.constant "api/categories") postBuild)
  categories <- Loadable.fromEvent categoriesEvent

  return $ do
    us <- users
    ps <- payments
    is <- incomes
    cs <- categories
    pcs <- paymentCategories
    return $ Init <$> us <*> ps <*> is <*> cs <*> pcs

data PaymentIn t = PaymentIn
  { _paymentIn_currentUser :: UserId
  , _paymentIn_currency    :: Currency
  , _paymentIn_init        :: Dynamic t (Loadable Init)
  }

view :: forall t m. MonadWidget t m => PaymentIn t -> m ()
view paymentIn = do
  R.dyn . R.ffor (_paymentIn_init paymentIn) . Loadable.view $ \init ->

    R.elClass "main" "payment" $ do
      rec
        let addPayment = R.leftmost
              [ _headerOut_addPayment header
              , _tableOut_addPayment table
              ]

            paymentsPerPage = 7

        payments <- reducePayments
          (_init_payments init)
          (_savedPayment_payment <$> addPayment)
          (_savedPayment_payment <$> _tableOut_editPayment table)
          (_tableOut_deletePayment table)

        paymentCategories <- reducePaymentCategories
          (_init_paymentCategories init)
          payments
          (_savedPayment_paymentCategory <$> addPayment)
          (_savedPayment_paymentCategory <$> _tableOut_editPayment table)
          (_tableOut_deletePayment table)

        (searchNameEvent, searchName) <-
          debounceSearchName (_headerOut_searchName header)

        let searchPayments =
              getSearchPayments searchName (_headerOut_searchFrequency header) payments

        header <- Header.widget $ HeaderIn
          { _headerIn_init = init
          , _headerIn_currency = _paymentIn_currency paymentIn
          , _headerIn_payments = payments
          , _headerIn_searchPayments = searchPayments
          , _headerIn_paymentCategories = paymentCategories
          }

        table <- Table.widget $ TableIn
          { _tableIn_init = init
          , _tableIn_currency = _paymentIn_currency paymentIn
          , _tableIn_currentUser = _paymentIn_currentUser paymentIn
          , _tableIn_currentPage = _pagesOut_currentPage pages
          , _tableIn_payments = searchPayments
          , _tableIn_perPage = paymentsPerPage
          , _tableIn_paymentCategories = paymentCategories
          }

        pages <- Pages.widget $ PagesIn
          { _pagesIn_total = length <$> searchPayments
          , _pagesIn_perPage = paymentsPerPage
          , _pagesIn_reset = R.leftmost $
              [ () <$ searchNameEvent
              , () <$ _headerOut_addPayment header
              ]
          }

      pure ()

  return ()

debounceSearchName
  :: forall t m. MonadWidget t m
  => Dynamic t Text
  -> m (Event t Text, Dynamic t Text)
debounceSearchName searchName = do
  event <- R.debounce (0.5 :: NominalDiffTime) (R.updated searchName)
  dynamic <- R.holdDyn "" event
  return (event, dynamic)

reducePayments
  :: forall t m. MonadWidget t m
  => [Payment]
  -> Event t Payment -- add payment
  -> Event t Payment -- edit payment
  -> Event t Payment -- delete payment
  -> m (Dynamic t [Payment])
reducePayments initPayments addPayment editPayment deletePayment =
  R.foldDyn id initPayments $ R.leftmost
    [ (:) <$> addPayment
    , R.ffor editPayment (\p -> (p:) . filter ((/= (_payment_id p)) . _payment_id))
    , R.ffor deletePayment (\p -> filter ((/= (_payment_id p)) . _payment_id))
    ]

reducePaymentCategories
  :: forall t m. MonadWidget t m
  => [PaymentCategory]
  -> Dynamic t [Payment]      -- payments
  -> Event t PaymentCategory  -- add payment category
  -> Event t PaymentCategory  -- edit payment category
  -> Event t Payment          -- delete payment
  -> m (Dynamic t [PaymentCategory])
reducePaymentCategories
  initPaymentCategories
  payments
  addPaymentCategory
  editPaymentCategory
  deletePayment
    =
  R.foldDyn id initPaymentCategories $ R.leftmost
    [ (:) <$> addPaymentCategory
    , R.ffor editPaymentCategory (\pc -> (pc:) . filter ((/= (_paymentCategory_name pc)) . _paymentCategory_name))
    , R.ffor deletePaymentName (\name -> filter ((/=) (T.toLower name) . _paymentCategory_name))
    ]
  where
    deletePaymentName =
      R.attachWithMaybe
        (\ps p ->
          if any (\p2 -> _payment_id p2 /= _payment_id p && lowerName p2 == lowerName p) ps then
            Nothing
          else
            Just (_payment_name p))
        (R.current payments)
        deletePayment
    lowerName = T.toLower . _payment_name

getSearchPayments
  :: forall t. Reflex t
  => Dynamic t Text
  -> Dynamic t Frequency
  -> Dynamic t [Payment]
  -> Dynamic t [Payment]
getSearchPayments name frequency payments = do
  n <- name
  f <- frequency
  ps <- payments
  pure $ flip filter ps (\p ->
    (  (T.search n (_payment_name p) || T.search n (T.pack . show . _payment_cost $ p))
    && (_payment_frequency p == f)
    ))