module View.Payment
  ( widget
  , PaymentIn(..)
  , PaymentOut(..)
  ) 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        (CreatedPayment (..), Frequency, Init (..),
                                      Payment (..), PaymentCategory (..),
                                      PaymentId)
import qualified Common.Util.Text    as T
import           View.Payment.Header (HeaderIn (..), HeaderOut (..))
import qualified View.Payment.Header as Header
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

data PaymentIn = PaymentIn
  { _paymentIn_init :: Init
  }

data PaymentOut = PaymentOut
  {
  }

widget :: forall t m. MonadWidget t m => PaymentIn -> m PaymentOut
widget paymentIn = do
  R.elClass "main" "payment" $ do
    rec
      let init = _paymentIn_init paymentIn
          paymentsPerPage = 7

      payments <- getPayments
        (_init_payments init)
        (_createdPayment_payment <$> _headerOut_addPayment header)
        (_tableOut_deletePayment table)

      paymentCategories <- getPaymentCategories
        (_init_paymentCategories init)
        (_createdPayment_paymentCategory <$> _headerOut_addPayment header)

      let searchPayments =
            getSearchPayments
              debouncedSearchName
              (_headerOut_searchFrequency header)
              payments

      debouncedSearchNameEvt <-
        R.debounce (0.5 :: NominalDiffTime) (R.updated $ _headerOut_searchName header)

      debouncedSearchName <-
        R.holdDyn "" debouncedSearchNameEvt

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

      table <- Table.widget $ TableIn
        { _tableIn_init = init
        , _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 $
            [ const () <$> debouncedSearchNameEvt
            , const () <$> _headerOut_addPayment header
            ]
        }

    pure $ PaymentOut {}

getPayments
  :: forall t m. MonadWidget t m
  => [Payment]
  -> Event t Payment
  -> Event t PaymentId
  -> m (Dynamic t [Payment])
getPayments initPayments addPayment deletePayment =
  R.foldDyn id initPayments $ R.leftmost
    [ (:) <$> addPayment
    , flip fmap deletePayment (\paymentId -> filter ((/= paymentId) . _payment_id))
    ]

getPaymentCategories
  :: forall t m. MonadWidget t m
  => [PaymentCategory]
  -> Event t PaymentCategory
  -> m (Dynamic t [PaymentCategory])
getPaymentCategories initPaymentCategories addPaymentCategory =
  R.foldDyn id initPaymentCategories $ R.leftmost
    [ (:) <$> addPaymentCategory
    ]

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)
    ))