{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE ViewPatterns #-}

{-# LANGUAGE TemplateHaskell #-}

{-# LANGUAGE ViewPatterns #-}

import Control.Lens (Lens', (.~), (^.), makeClassy, makeLenses, makePrisms, view)

import Control.Lens ((.~), Lens', (^.), makeClassy, makeLenses, makePrisms, view)

workCredit depf ptime ivals =
  let intervalCredit ival = (Sum . ilen &&& Sum . depf Nothing ptime) $ fmap (view eventTime) ival

workCredit depf payoutDate ivals =
  let intervalCredit ival = (Sum . ilen &&& Sum . depf Nothing payoutDate) $ fmap (view eventTime) ival

payouts dep ptime (WorkIndex widx) =

payouts depf payoutDate (WorkIndex widx) =

        let (logged, depreciated) = workCredit dep ptime ivals

        let (logged, depreciated) = workCredit depf payoutDate ivals

      (StartWork t, StopWork t') | t' > t -> Right $ Interval e e' -- complete interval found
      (StartWork t, StartWork t') -> Left $ if t > t' then e else e' -- ignore redundant starts
      (StopWork t, StopWork t') -> Left $ if t <= t' then e else e' -- ignore redundant ends

      (StartWork t, StopWork t')
        | t' > t ->
          -- complete interval found
          Right $ Interval e e'
      (StartWork t, StartWork t') ->
        -- ignore redundant starts
        Left $ if t > t' then e else e'
      (StopWork t, StopWork t') ->
        -- ignore redundant ends
        Left $ if t <= t' then e else e'

import qualified Debug.Trace as T

traceWith :: Show b => (a -> b) -> a -> a
traceWith f a = T.trace (show $ f a) a

                _timeDevoted = Hours . (`div` 360) . round . C.toSeconds' $ ws ^. wsLogged,

                _timeDevoted = Hours . (`div` 3600) . round . C.toSeconds' $ ws ^. wsLogged,

{-# LANGUAGE TypeApplications #-}

{-# LANGUAGE TypeApplications #-}

import Prelude hiding (head, tail)

import Aftok.Types (UserId (..), DepreciationFunction(..))
import Control.Lens ((^.), view, to)
import Data.AffineSpace ((.-.), (.+^))
import Data.VectorSpace ((*^), Sum (..), (^+^), (^-^), getSum, zeroV)
import Data.Maybe (fromJust)

import Aftok.Types (DepreciationFunction (..), UserId (..))
import Control.Lens ((^.), to, view)
import Data.AffineSpace ((.+^))

import Data.Ratio ((%))

import Data.Maybe (fromJust)
import Data.Ratio ((%))

import Test.QuickCheck (Gen, forAll, sample', listOf, suchThat, arbitrary, choose)

import Test.QuickCheck (Gen, arbitrary, choose, forAll, listOf, sample', suchThat)
import Prelude hiding (head, tail)

          len = fromInteger @C.NominalDiffTime 360

          len = fromInteger @C.NominalDiffTime 3600

            . filter (\i -> fst i `mod` 2 == 0)
            $ ([(0 :: Int)..] `zip` (timestamps `zip` tail timestamps))
          widx = WorkIndex $ M.fromList
            [ (u0, L.fromList $ take 10 intervals)
            , (u1, L.fromList $ take 30 intervals)
            , (u2, L.fromList $ take 120 intervals)
            ]

              . filter (\i -> fst i `mod` 2 == 0)
              $ ([(0 :: Int) ..] `zip` (timestamps `zip` tail timestamps))
          widx =
            WorkIndex $
              M.fromList
                [ (u0, L.fromList $ take 10 intervals),
                  (u1, L.fromList $ take 30 intervals),
                  (u2, L.fromList $ take 120 intervals)
                ]

      (shares ^. loggedTotal `shouldBe` (fromInteger @C.NominalDiffTime (360 * 160)))

      (shares ^. loggedTotal `shouldBe` (fromInteger @C.NominalDiffTime (3600 * 160)))