[submodule "reactclient"]
	path = reactclient
	url = git@github.com:MarcoEzekiel/Aftok-React.git

-- |
-- - The depreciation function should return a value between 0 and 1;
-- - this result is multiplied by the length of an interval of work to determine
-- - the depreciated value of the work.
type DepF = C.UTCTime -> Interval C.UTCTime -> NDT

-- |
-- - The depreciation function should return a value between 0 and 1;
-- - this result is multiplied by the length of an interval of work to determine
-- - the depreciated value of the work.
--
-- arguments:
--  * date of first revenue (if applicable)
--  * date on which the depreciated value is being computed
--  *
type DepF = Maybe C.UTCTime -> C.UTCTime -> Interval C.UTCTime -> NDT

daysToNDT :: C.Days -> NDT
daysToNDT d = C.fromSeconds $ 60 * 60 * 24 * d

-- - A very simple linear function for calculating depreciation.
linearDepreciation ::
  -- | The number of initial days during which no depreciation occurs
  C.Days ->
  -- | The number of days over which each logged interval will be depreciated
  C.Days ->
  -- | The resulting configured depreciation function.
  DepF
linearDepreciation undepDays depDays =
  let -- length of a number of days as NominalDiffTime
      undepLength = daysToNDT undepDays
      depLength = daysToNDT depDays
      -- The percentage of the depreciation period that the end of the interval
      -- represents.
      depPercentage :: NDT -> Rational
      depPercentage intervalAge =
        if intervalAge < undepLength
          then 1
          else max 0 (1 - (C.toSeconds (intervalAge ^-^ undepLength) / C.toSeconds depLength))
   in \firstRevenue payoutDate ival ->
        let ivalEnd = case firstRevenue of
              -- if the end of the interval was before first revenue, count it as
              -- having ended at the first revenue date for the purpose of depreciation
              Just dt -> max dt (ival ^. end)
              Nothing -> ival ^. end
         in depPercentage (payoutDate .-. ivalEnd) *^ ilen ival
-- |

  bimap getSum getSum $ F.foldMap ((Sum . ilen &&& Sum . depf ptime) . fmap (view eventTime)) ivals

  let intervalCredit ival = (Sum . ilen &&& Sum . depf Nothing ptime) $ fmap (view eventTime) ival
   in bimap getSum getSum $ F.foldMap intervalCredit ivals

-- |
-- - A very simple linear function for calculating depreciation.
linearDepreciation ::
  -- | The number of initial days during which no depreciation occurs
  C.Days ->
  -- | The number of days over which each logged interval will be depreciated
  C.Days ->
  -- | The resulting configured depreciation function.
  DepF
linearDepreciation undepLength depLength =
  let daysLength :: C.Days -> NDT
      daysLength d = C.fromSeconds $ 60 * 60 * 24 * d
      maxDepreciable :: NDT
      maxDepreciable = daysLength undepLength ^+^ daysLength depLength
      depPct :: NDT -> Rational
      depPct dt =
        if dt < daysLength undepLength
          then 1
          else
            C.toSeconds (max zeroV (maxDepreciable ^-^ dt))
              / C.toSeconds maxDepreciable
   in \ptime ival ->
        let depreciation = depPct $ ptime .-. (ival ^. end)
         in depreciation *^ ilen ival

import Data.AffineSpace

import Data.AffineSpace ((.-.), (.+^))
import Data.VectorSpace ((*^), Sum (..), (^+^), (^-^), getSum, zeroV)

import Data.Thyme.Time as T

import qualified Data.Thyme.Clock as C
import qualified Data.Thyme.Time as C

import Test.QuickCheck

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

--   delta     <- arbitrary :: Gen (Positive T.NominalDiffTime)

--   delta     <- arbitrary :: Gen (Positive C.NominalDiffTime)

genIntervals :: Gen (L.NonEmpty (I.Interval T.UTCTime))

genIntervals :: Gen (L.NonEmpty (I.Interval C.UTCTime))

        fmap T.fromSeconds

        fmap C.fromSeconds

      buildIntervals :: T.UTCTime -> [NominalDiffTime] -> [I.Interval T.UTCTime]

      buildIntervals :: C.UTCTime -> [C.NominalDiffTime] -> [I.Interval C.UTCTime]

genWorkIndex :: Gen (WorkIndex T.UTCTime)

genWorkIndex :: Gen (WorkIndex C.UTCTime)

  let recordGen :: Gen (CreditTo, L.NonEmpty (I.Interval T.UTCTime))

  let recordGen :: Gen (CreditTo, L.NonEmpty (I.Interval C.UTCTime))

            toThyme

            C.toThyme

            toThyme

            C.toThyme

          testIntervals :: [(CreditTo, I.Interval T.UTCTime)]

          testIntervals :: [(CreditTo, I.Interval C.UTCTime)]

      let initTime = toThyme . fromJust $ parseISO8601 "2014-01-01T00:08:00Z"
          len = fromInteger @NominalDiffTime 360
          timestamps = iterate (addUTCTime len) initTime

      let initTime = C.toThyme . fromJust $ parseISO8601 "2014-01-01T00:08:00Z"
          len = fromInteger @C.NominalDiffTime 360
          timestamps = iterate (.+^ len) initTime

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

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

  describe "depreciation functions" $ do
    it "computes linear depreciation" $ do
      let depf = linearDepreciation 10 100
          hour = fromInteger (60 * 60)
          t0 :: C.UTCTime = C.toThyme . fromJust $ parseISO8601 "2014-01-01T00:08:00Z"
          ival = I.Interval (t0 .+^ negate hour) t0
          t1 = t0 .+^ daysToNDT 5
          t2 = t0 .+^ daysToNDT 10
          t3 = t0 .+^ daysToNDT 20
          t4 = t0 .+^ daysToNDT 60
          t5 = t0 .+^ daysToNDT 110
      daysToNDT 1 `shouldBe` (60 * 60 * 24)
      -- undepreciated; within the first 10 days
      depf Nothing t1 ival `shouldBe` 3600
      -- still undepreciated if it ends at the last depreciation moment
      depf Nothing t2 ival `shouldBe` 3600
      -- depreciated by 10% of its value
      depf Nothing t3 ival `shouldBe` 3240
      -- depreciated by 50% of its value
      depf Nothing t4 ival `shouldBe` 1800
      -- depreciated by 100% of its value
      depf Nothing t5 ival `shouldBe` 0
      -- undepreciated - before first revenue
      depf (Just t3) t1 ival `shouldBe` 3600
      -- undepreciated - before first revenue
      depf (Just t3) t2 ival `shouldBe` 3600
      -- depreciated by 10% of its value
      depf (Just t3) t3 ival `shouldBe` 3600
      -- depreciated by 30% of its value
      depf (Just t3) t4 ival `shouldBe` 2520
      -- depreciated by 80% of its value
      depf (Just t3) t5 ival `shouldBe` 720