{-# LANGUAGE ExplicitForAll #-}

module View.Income.Income
  ( init
  , view
  , In(..)
  ) where

import qualified Data.Text as T
import           Data.Aeson          (FromJSON)
import qualified Data.Maybe          as Maybe
import           Prelude             hiding (init)
import           Reflex.Dom          (Dynamic, Event, MonadWidget)
import qualified Reflex.Dom          as R

import           Common.Model        (Currency, Income (..),
                                      IncomesAndCount (..), UserId)

import qualified Component.Pages     as Pages
import           Loadable            (Loadable (..))
import qualified Loadable
import qualified Util.Ajax           as AjaxUtil
import qualified Util.Reflex         as ReflexUtil
-- import qualified View.Income.Header as Header
import           View.Income.Init    (Init (..))
import qualified View.Income.Reducer as Reducer
import qualified View.Income.Table   as Table

data In t = In
  { _in_currentUser :: UserId
  , _in_currency    :: Currency
  , _in_init        :: Dynamic t (Loadable Init)
  }

init :: forall t m. MonadWidget t m => m (Dynamic t (Loadable Init))
init = do
  users <- AjaxUtil.getNow "api/users"
  incomes <- AjaxUtil.getNow "api/incomes"
  payments <- AjaxUtil.getNow "api/payments"
  return $ do
    us <- users
    is <- incomes
    ps <- payments
    return $ Init <$> us <*> is <*> ps

view :: forall t m. MonadWidget t m => In t -> m ()
view input = do
  rec
    incomes <- Reducer.reducer $ Reducer.In
      { Reducer._in_newPage      = newPage
      , Reducer._in_currentPage  = currentPage
      , Reducer._in_addIncome    = addIncome
      , Reducer._in_editIncome   = editIncome
      , Reducer._in_deleteIncome = deleteIncome
      }

    let eventFromResult :: forall a. ((Table.Out t, Pages.Out t) -> Event t a) -> m (Event t a)
        eventFromResult op = ReflexUtil.flatten . fmap (Maybe.fromMaybe R.never . fmap op) $ result

    newPage <- eventFromResult $ Pages._out_newPage . snd
    currentPage <- R.holdDyn 1 newPage
    addIncome <- eventFromResult $ Table._out_add . fst
    editIncome <- eventFromResult $ Table._out_edit . fst
    deleteIncome <- eventFromResult $ Table._out_delete . fst

    result <- R.dyn . R.ffor ((,) <$> incomes <*> currentPage) $ \(is, p) ->
      flip Loadable.view is $ \(IncomesAndCount incomes count) -> do
        table <- Table.view $ Table.In
          { Table._in_currentUser = _in_currentUser input
          , Table._in_currency = _in_currency input
          , Table._in_incomes = incomes
          }

        pages <- Pages.view $ Pages.In
          { Pages._in_total = R.constDyn count
          , Pages._in_perPage = Reducer.perPage
          , Pages._in_page = p
          }

        return (table, pages)

  return ()