{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Deal.DealQuery (queryDealBool ,patchDateToStats,patchDatesToStats,testPre
                      ,calcTargetAmount, testPre2
                      ,queryCompound, calcBondTargetBalance) 
  where

import Deal.DealBase
import Types
import qualified Asset as P
import qualified AssetClass.AssetBase as AB 
import Data.List
import Data.Fixed
import Data.Maybe
import Data.Text (replace, pack, unpack)
import Numeric.Limits
import Control.Monad.Loops
import GHC.Real
import qualified Data.Map as Map
import qualified Data.Set as S
import qualified Liability as L
import qualified Cashflow as CF
import qualified Data.Time as T
import qualified Data.DList as DL 
import qualified Accounts as A
import qualified Ledger as LD
import qualified Expense as F
import qualified Triggers as Trg
import qualified CreditEnhancement as CE
import qualified Hedge as H
import qualified Analytics as A
import qualified Pool as Pl
import qualified InterestRate as IR
import Stmt
import Util
import Errors
import DateUtil
import Control.Lens hiding (element)
import Control.Lens.Extras (is)
import Control.Lens.TH
import Control.Applicative
import Data.Map.Lens
import Data.List.Lens
import Debug.Trace
import Lib
import qualified Cashflow as P
debug :: c -> [Char] -> c
debug = ([Char] -> c -> c) -> c -> [Char] -> c
forall a b c. (a -> b -> c) -> b -> a -> c
flip [Char] -> c -> c
forall a. [Char] -> a -> a
trace

-- | calcuate target balance for a reserve account, 0 for a non-reserve account
calcTargetAmount :: P.Asset a => TestDeal a -> Date -> A.Account -> Either String Balance
calcTargetAmount :: forall a.
Asset a =>
TestDeal a -> Date -> Account -> Either [Char] Balance
calcTargetAmount TestDeal a
t Date
d (A.Account Balance
_ [Char]
_ Maybe InterestInfo
_ Maybe ReserveAmount
Nothing Maybe Statement
_ ) = Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right Balance
0
calcTargetAmount TestDeal a
t Date
d (A.Account Balance
_ [Char]
_ Maybe InterestInfo
_ (Just ReserveAmount
r) Maybe Statement
_ ) =
   ReserveAmount -> Either [Char] Balance
eval ReserveAmount
r 
   where
     eval :: A.ReserveAmount -> Either String Balance
     eval :: ReserveAmount -> Either [Char] Balance
eval ReserveAmount
ra = case ReserveAmount
ra of
       A.PctReserve DealStats
ds Rational
_rate -> do 
                                  Rational
v <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds)
                                  Balance -> Either [Char] Balance
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Balance
forall a. Fractional a => Rational -> a
fromRational (Rational
v Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
* Rational
_rate))
       A.FixReserve Balance
amt -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right Balance
amt
       A.Either Pre
p ReserveAmount
ra1 ReserveAmount
ra2 -> do 
                               Bool
q <- Date -> TestDeal a -> Pre -> Either [Char] Bool
forall a.
Asset a =>
Date -> TestDeal a -> Pre -> Either [Char] Bool
testPre Date
d TestDeal a
t Pre
p
                               if Bool
q then 
                                 ReserveAmount -> Either [Char] Balance
eval ReserveAmount
ra1
                               else 
                                 ReserveAmount -> Either [Char] Balance
eval ReserveAmount
ra2 
       A.Max [ReserveAmount]
ras -> [Balance] -> Balance
forall a. Ord a => [a] -> a
maximum' ([Balance] -> Balance)
-> Either [Char] [Balance] -> Either [Char] Balance
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Either [Char] Balance] -> Either [Char] [Balance]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA (ReserveAmount -> Either [Char] Balance
eval (ReserveAmount -> Either [Char] Balance)
-> [ReserveAmount] -> [Either [Char] Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ReserveAmount]
ras)
       A.Min [ReserveAmount]
ras -> [Balance] -> Balance
forall a. Ord a => [a] -> a
minimum' ([Balance] -> Balance)
-> Either [Char] [Balance] -> Either [Char] Balance
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Either [Char] Balance] -> Either [Char] [Balance]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA (ReserveAmount -> Either [Char] Balance
eval (ReserveAmount -> Either [Char] Balance)
-> [ReserveAmount] -> [Either [Char] Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ReserveAmount]
ras)

-- | calculate target bond balance for a bond 
calcBondTargetBalance :: P.Asset a => TestDeal a -> Date -> L.Bond -> Either String Balance
calcBondTargetBalance :: forall a.
Asset a =>
TestDeal a -> Date -> Bond -> Either [Char] Balance
calcBondTargetBalance TestDeal a
t Date
d (L.BondGroup Map [Char] Bond
bMap Maybe BondType
mPt) = 
  case Maybe BondType
mPt of 
    Maybe BondType
Nothing -> do 
                [Balance]
vs <- [Either [Char] Balance] -> Either [Char] [Balance]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA ([Either [Char] Balance] -> Either [Char] [Balance])
-> [Either [Char] Balance] -> Either [Char] [Balance]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Date -> Bond -> Either [Char] Balance
forall a.
Asset a =>
TestDeal a -> Date -> Bond -> Either [Char] Balance
calcBondTargetBalance TestDeal a
t Date
d (Bond -> Either [Char] Balance)
-> [Bond] -> [Either [Char] Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map [Char] Bond -> [Bond]
forall k a. Map k a -> [a]
Map.elems Map [Char] Bond
bMap
                Balance -> Either [Char] Balance
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Balance -> Either [Char] Balance)
-> Balance -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Balance]
vs 

    Just (L.PAC PlannedAmorSchedule
_target) -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right (Balance -> Either [Char] Balance)
-> Balance -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ PlannedAmorSchedule -> Date -> Balance
getValOnByDate PlannedAmorSchedule
_target Date
d
    Just (L.PacAnchor PlannedAmorSchedule
_target [[Char]]
_bnds)
      | TestDeal a -> DealStats -> Date -> Either [Char] Bool
forall a.
Asset a =>
TestDeal a -> DealStats -> Date -> Either [Char] Bool
queryDealBool TestDeal a
t ([[Char]] -> DealStats
IsPaidOff [[Char]]
_bnds) Date
d Either [Char] Bool -> Either [Char] Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> Either [Char] Bool
forall a b. b -> Either a b
Right Bool
True -> 
          do
            [Balance]
subBondTargets <- [Either [Char] Balance] -> Either [Char] [Balance]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA ([Either [Char] Balance] -> Either [Char] [Balance])
-> [Either [Char] Balance] -> Either [Char] [Balance]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Date -> Bond -> Either [Char] Balance
forall a.
Asset a =>
TestDeal a -> Date -> Bond -> Either [Char] Balance
calcBondTargetBalance TestDeal a
t Date
d (Bond -> Either [Char] Balance)
-> [Bond] -> [Either [Char] Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map [Char] Bond -> [Bond]
forall k a. Map k a -> [a]
Map.elems Map [Char] Bond
bMap
            Balance -> Either [Char] Balance
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Balance -> Either [Char] Balance)
-> Balance -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Balance]
subBondTargets
      | TestDeal a -> DealStats -> Date -> Either [Char] Bool
forall a.
Asset a =>
TestDeal a -> DealStats -> Date -> Either [Char] Bool
queryDealBool TestDeal a
t ([[Char]] -> DealStats
IsPaidOff [[Char]]
_bnds) Date
d Either [Char] Bool -> Either [Char] Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> Either [Char] Bool
forall a b. b -> Either a b
Right Bool
False -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right (Balance -> Either [Char] Balance)
-> Balance -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ PlannedAmorSchedule -> Date -> Balance
getValOnByDate PlannedAmorSchedule
_target Date
d
      | Bool
otherwise -> [Char] -> Either [Char] Balance
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Balance)
-> [Char] -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ [Char]
"Calculate paid off bonds failed"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
forall a. Show a => a -> [Char]
show [[Char]]
_bnds [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" in calc target balance"
    Just (L.AmtByPeriod PerCurve Balance
pc) -> case PerCurve Balance
-> DateDirection -> CutoffType -> Int -> Maybe Balance
forall a.
PerCurve a -> DateDirection -> CutoffType -> Int -> Maybe a
getValFromPerCurve PerCurve Balance
pc DateDirection
Past CutoffType
Inc (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
0 (TestDeal a -> DealStatFields -> Maybe Int
forall a. TestDeal a -> DealStatFields -> Maybe Int
getDealStatInt TestDeal a
t DealStatFields
BondPaidPeriod)) of
                                 Just Balance
v -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right Balance
v
                                 Maybe Balance
Nothing -> [Char] -> Either [Char] Balance
forall a b. a -> Either a b
Left [Char]
"Failed to find value in calcTargetBalance"
    Maybe BondType
_ -> [Char] -> Either [Char] Balance
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Balance)
-> [Char] -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ [Char]
"not support principal type for bond group"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Maybe BondType -> [Char]
forall a. Show a => a -> [Char]
show Maybe BondType
mPt
calcBondTargetBalance TestDeal a
t Date
d Bond
b = 
  case Bond -> BondType
L.bndType Bond
b of
    BondType
L.Sequential -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right Balance
0
    L.Lockout Date
ld | Date
d Date -> Date -> Bool
forall a. Ord a => a -> a -> Bool
>= Date
ld -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right Balance
0
                 | Bool
otherwise -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right (Balance -> Either [Char] Balance)
-> Balance -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ Bond -> Balance
L.bndBalance Bond
b
    BondType
L.Z 
      | (Bool -> Bool) -> [Bool] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
==Bool
True) (Bond -> Bool
forall lb. Liable lb => lb -> Bool
isPaidOff (Bond -> Bool) -> [Bond] -> [Bool]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Map [Char] Bond -> [Bond]
forall k a. Map k a -> [a]
Map.elems ([Char] -> Map [Char] Bond -> Map [Char] Bond
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete (Bond -> [Char]
L.bndName Bond
b) (TestDeal a -> Map [Char] Bond
forall a. TestDeal a -> Map [Char] Bond
bonds TestDeal a
t)))) -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right Balance
0
      | Bool
otherwise -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right (Balance -> Either [Char] Balance)
-> Balance -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ Bond -> Balance
L.bndBalance Bond
b
    BondType
L.IO -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right Balance
0
    BondType
L.Equity -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right Balance
0
    L.PAC PlannedAmorSchedule
_target -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right (Balance -> Either [Char] Balance)
-> Balance -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ PlannedAmorSchedule -> Date -> Balance
getValOnByDate PlannedAmorSchedule
_target Date
d
    L.PacAnchor PlannedAmorSchedule
_target [[Char]]
_bnds
      | TestDeal a -> DealStats -> Date -> Either [Char] Bool
forall a.
Asset a =>
TestDeal a -> DealStats -> Date -> Either [Char] Bool
queryDealBool TestDeal a
t ([[Char]] -> DealStats
IsPaidOff [[Char]]
_bnds) Date
d Either [Char] Bool -> Either [Char] Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> Either [Char] Bool
forall a b. b -> Either a b
Right Bool
True -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right Balance
0
      | TestDeal a -> DealStats -> Date -> Either [Char] Bool
forall a.
Asset a =>
TestDeal a -> DealStats -> Date -> Either [Char] Bool
queryDealBool TestDeal a
t ([[Char]] -> DealStats
IsPaidOff [[Char]]
_bnds) Date
d Either [Char] Bool -> Either [Char] Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> Either [Char] Bool
forall a b. b -> Either a b
Right Bool
False -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right (Balance -> Either [Char] Balance)
-> Balance -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ PlannedAmorSchedule -> Date -> Balance
getValOnByDate PlannedAmorSchedule
_target Date
d
      | Bool
otherwise -> [Char] -> Either [Char] Balance
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Balance)
-> [Char] -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ [Char]
"Calculate paid off bonds failed"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
forall a. Show a => a -> [Char]
show [[Char]]
_bnds [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" in calc target balance"
    L.AmtByPeriod PerCurve Balance
pc -> case PerCurve Balance
-> DateDirection -> CutoffType -> Int -> Maybe Balance
forall a.
PerCurve a -> DateDirection -> CutoffType -> Int -> Maybe a
getValFromPerCurve PerCurve Balance
pc DateDirection
Past CutoffType
Inc (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
0 (TestDeal a -> DealStatFields -> Maybe Int
forall a. TestDeal a -> DealStatFields -> Maybe Int
getDealStatInt TestDeal a
t DealStatFields
BondPaidPeriod)) of
                          Just Balance
v -> Balance -> Either [Char] Balance
forall a b. b -> Either a b
Right Balance
v
                          Maybe Balance
Nothing -> [Char] -> Either [Char] Balance
forall a b. a -> Either a b
Left [Char]
"Failed to find value in calcTargetBalance"
    BondType
_ -> [Char] -> Either [Char] Balance
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Balance)
-> [Char] -> Either [Char] Balance
forall a b. (a -> b) -> a -> b
$ [Char]
"Bond "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Bond -> [Char]
L.bndName Bond
b [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" is not a bond with target balance setting"


patchDateToStats :: Date -> DealStats -> DealStats
patchDateToStats :: Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
t
  = case DealStats
t of
      CurrentPoolBalance Maybe [PoolId]
mPns -> Maybe [PoolId] -> DealStats
FutureCurrentPoolBalance Maybe [PoolId]
mPns
      CurrentPoolBegBalance Maybe [PoolId]
mPns -> Maybe [PoolId] -> DealStats
FutureCurrentPoolBegBalance Maybe [PoolId]
mPns
      PoolFactor Maybe [PoolId]
mPns -> Date -> Maybe [PoolId] -> DealStats
FutureCurrentPoolFactor Date
d Maybe [PoolId]
mPns
      LastBondIntPaid [[Char]]
bns -> Date -> [[Char]] -> DealStats
BondsIntPaidAt Date
d [[Char]]
bns
      LastFeePaid [[Char]]
fns -> Date -> [[Char]] -> DealStats
FeesPaidAt Date
d [[Char]]
fns
      LastBondPrinPaid [[Char]]
bns -> Date -> [[Char]] -> DealStats
BondsPrinPaidAt Date
d [[Char]]
bns
      BondBalanceGap [Char]
bn -> Date -> [Char] -> DealStats
BondBalanceGapAt Date
d [Char]
bn
      ReserveGap [[Char]]
ans -> Date -> [[Char]] -> DealStats
ReserveGapAt Date
d [[Char]]
ans
      ReserveExcess [[Char]]
ans -> Date -> [[Char]] -> DealStats
ReserveExcessAt Date
d [[Char]]
ans
      Sum [DealStats]
_ds -> [DealStats] -> DealStats
Sum ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ (DealStats -> DealStats) -> [DealStats] -> [DealStats]
forall a b. (a -> b) -> [a] -> [b]
map (Date -> DealStats -> DealStats
patchDateToStats Date
d) [DealStats]
_ds
      Substract [DealStats]
_ds -> [DealStats] -> DealStats
Substract ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ (DealStats -> DealStats) -> [DealStats] -> [DealStats]
forall a b. (a -> b) -> [a] -> [b]
map (Date -> DealStats -> DealStats
patchDateToStats Date
d) [DealStats]
_ds
      Subtract [DealStats]
_ds -> [DealStats] -> DealStats
Subtract ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ (DealStats -> DealStats) -> [DealStats] -> [DealStats]
forall a b. (a -> b) -> [a] -> [b]
map (Date -> DealStats -> DealStats
patchDateToStats Date
d) [DealStats]
_ds
      Min [DealStats]
dss -> [DealStats] -> DealStats
Min ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds | DealStats
ds <- [DealStats]
dss ] 
      Max [DealStats]
dss -> [DealStats] -> DealStats
Max ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds | DealStats
ds <- [DealStats]
dss ]
      Factor DealStats
_ds Rational
r -> DealStats -> Rational -> DealStats
Factor (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
_ds) Rational
r
      FloorWithZero DealStats
ds -> DealStats -> DealStats
FloorWithZero (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds) 
      UseCustomData [Char]
n -> [Char] -> Date -> DealStats
CustomData [Char]
n Date
d
      CurrentPoolBorrowerNum Maybe [PoolId]
mPns -> Date -> Maybe [PoolId] -> DealStats
FutureCurrentPoolBorrowerNum Date
d Maybe [PoolId]
mPns
      FeeTxnAmt [[Char]]
ns Maybe TxnComment
mCmt -> Date -> [[Char]] -> Maybe TxnComment -> DealStats
FeeTxnAmtBy Date
d [[Char]]
ns Maybe TxnComment
mCmt
      BondTxnAmt [[Char]]
ns Maybe TxnComment
mCmt -> Date -> [[Char]] -> Maybe TxnComment -> DealStats
BondTxnAmtBy Date
d [[Char]]
ns Maybe TxnComment
mCmt
      AccTxnAmt [[Char]]
ns Maybe TxnComment
mCmt -> Date -> [[Char]] -> Maybe TxnComment -> DealStats
AccTxnAmtBy Date
d [[Char]]
ns Maybe TxnComment
mCmt -- `debug` ("Hitttt")
      PoolScheduleCfPv PricingMethod
pm Maybe [PoolId]
pns -> Date -> PricingMethod -> Maybe [PoolId] -> DealStats
FuturePoolScheduleCfPv Date
d PricingMethod
pm Maybe [PoolId]
pns
      Excess [DealStats]
dss -> [DealStats] -> DealStats
Excess ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds | DealStats
ds <- [DealStats]
dss ]
      Abs DealStats
ds -> DealStats -> DealStats
Abs (DealStats -> DealStats) -> DealStats -> DealStats
forall a b. (a -> b) -> a -> b
$ Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds
      Avg [DealStats]
dss -> [DealStats] -> DealStats
Avg ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds | DealStats
ds <- [DealStats]
dss ]
      Divide DealStats
ds1 DealStats
ds2 -> DealStats -> DealStats -> DealStats
Divide (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds1) (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds2)
      FloorAndCap DealStats
f DealStats
c DealStats
s -> DealStats -> DealStats -> DealStats -> DealStats
FloorAndCap (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
f) (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
c) (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
s)
      Multiply [DealStats]
dss -> [DealStats] -> DealStats
Multiply ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds | DealStats
ds <- [DealStats]
dss ]
      FloorWith DealStats
ds DealStats
f -> DealStats -> DealStats -> DealStats
FloorWith (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds) (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
f)
      CapWith DealStats
ds DealStats
c -> DealStats -> DealStats -> DealStats
CapWith (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds) (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
c)
      Round DealStats
ds RoundingBy Rational
rb -> DealStats -> RoundingBy Rational -> DealStats
Round (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds) RoundingBy Rational
rb
      DivideRatio DealStats
ds1 DealStats
ds2 -> DealStats -> DealStats -> DealStats
DivideRatio (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds1) (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds2)
      AvgRatio [DealStats]
ss -> [DealStats] -> DealStats
AvgRatio ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds | DealStats
ds <- [DealStats]
ss ]
      DealStats
_ -> DealStats
t -- `debug` ("Failed to patch date to stats"++show t)

patchDatesToStats :: P.Asset a => TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats :: forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds 
  = case DealStats
ds of 
      CurrentBondBalanceOf [[Char]]
bns -> Date -> Date -> [[Char]] -> DealStats
WeightedAvgCurrentBondBalance Date
d1 Date
d2 [[Char]]
bns
      OriginalBondBalanceOf [[Char]]
bns -> Date -> Date -> [[Char]] -> DealStats
WeightedAvgOriginalBondBalance Date
d1 Date
d2 [[Char]]
bns
      CurrentPoolBalance Maybe [PoolId]
mPns -> Date -> Date -> Maybe [PoolId] -> DealStats
WeightedAvgCurrentPoolBalance Date
d1 Date
d2 Maybe [PoolId]
mPns
      OriginalPoolBalance Maybe [PoolId]
mPns -> Date -> Date -> Maybe [PoolId] -> DealStats
WeightedAvgOriginalPoolBalance Date
d1 Date
d2 Maybe [PoolId]
mPns
      DealStats
CurrentBondBalance -> Date -> Date -> [[Char]] -> DealStats
WeightedAvgCurrentBondBalance Date
d1 Date
d2 (Map [Char] Bond -> [[Char]]
forall k a. Map k a -> [k]
Map.keys (Map [Char] Bond -> [[Char]]) -> Map [Char] Bond -> [[Char]]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Map [Char] Bond
forall a. TestDeal a -> Map [Char] Bond
bonds TestDeal a
t)
      DealStats
OriginalBondBalance -> Date -> Date -> [[Char]] -> DealStats
WeightedAvgOriginalBondBalance Date
d1 Date
d2 (Map [Char] Bond -> [[Char]]
forall k a. Map k a -> [k]
Map.keys (Map [Char] Bond -> [[Char]]) -> Map [Char] Bond -> [[Char]]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Map [Char] Bond
forall a. TestDeal a -> Map [Char] Bond
bonds TestDeal a
t)
      Excess [DealStats]
dss -> [DealStats] -> DealStats
Excess ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds | DealStats
ds <- [DealStats]
dss ]
      Abs DealStats
ds -> DealStats -> DealStats
Abs (DealStats -> DealStats) -> DealStats -> DealStats
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds
      Avg [DealStats]
dss -> [DealStats] -> DealStats
Avg ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds | DealStats
ds <- [DealStats]
dss ]
      Divide DealStats
ds1 DealStats
ds2 -> DealStats -> DealStats -> DealStats
Divide (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds1) (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds2)
      FloorAndCap DealStats
f DealStats
c DealStats
s -> DealStats -> DealStats -> DealStats -> DealStats
FloorAndCap (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
f) (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
c) (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
s)
      Multiply [DealStats]
dss -> [DealStats] -> DealStats
Multiply ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds | DealStats
ds <- [DealStats]
dss ]
      FloorWith DealStats
ds DealStats
f -> DealStats -> DealStats -> DealStats
FloorWith (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds) (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
f)
      CapWith DealStats
ds DealStats
c -> DealStats -> DealStats -> DealStats
CapWith (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds) (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
c)
      Round DealStats
ds RoundingBy Rational
rb -> DealStats -> RoundingBy Rational -> DealStats
Round (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds) RoundingBy Rational
rb
      Sum [DealStats]
dss -> [DealStats] -> DealStats
Sum ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds | DealStats
ds <- [DealStats]
dss ]
      DivideRatio DealStats
ds1 DealStats
ds2 -> DealStats -> DealStats -> DealStats
DivideRatio (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds1) (TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds2)
      AvgRatio [DealStats]
ss -> [DealStats] -> DealStats
AvgRatio ([DealStats] -> DealStats) -> [DealStats] -> DealStats
forall a b. (a -> b) -> a -> b
$ [ TestDeal a -> Date -> Date -> DealStats -> DealStats
forall a.
Asset a =>
TestDeal a -> Date -> Date -> DealStats -> DealStats
patchDatesToStats TestDeal a
t Date
d1 Date
d2 DealStats
ds | DealStats
ds <- [DealStats]
ss ]
      DealStats
x -> DealStats
x

      
-- ^ map from Pool Source to Pool CutoffFields in Pool Map
poolSourceToIssuanceField :: PoolSource -> CutoffFields
poolSourceToIssuanceField :: PoolSource -> CutoffFields
poolSourceToIssuanceField PoolSource
CollectedInterest = CutoffFields
HistoryInterest
poolSourceToIssuanceField PoolSource
CollectedPrincipal = CutoffFields
HistoryPrincipal
poolSourceToIssuanceField PoolSource
CollectedRecoveries = CutoffFields
HistoryRecoveries
poolSourceToIssuanceField PoolSource
CollectedPrepayment = CutoffFields
HistoryPrepayment
poolSourceToIssuanceField PoolSource
CollectedPrepaymentPenalty = CutoffFields
HistoryPrepaymentPentalty
poolSourceToIssuanceField PoolSource
CollectedRental = CutoffFields
HistoryRental
poolSourceToIssuanceField PoolSource
CollectedFeePaid = CutoffFields
HistoryFeePaid
poolSourceToIssuanceField PoolSource
CollectedCash = CutoffFields
HistoryCash
poolSourceToIssuanceField PoolSource
NewLosses = CutoffFields
HistoryLoss
poolSourceToIssuanceField PoolSource
NewDefaults = CutoffFields
HistoryDefaults
poolSourceToIssuanceField PoolSource
NewDelinquencies = CutoffFields
HistoryDelinquency
poolSourceToIssuanceField PoolSource
a = [Char] -> CutoffFields
forall a. HasCallStack => [Char] -> a
error ([Char]
"Failed to match pool source when mapping to issuance field"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++PoolSource -> [Char]
forall a. Show a => a -> [Char]
show PoolSource
a)



queryCompound :: P.Asset a => TestDeal a -> Date -> DealStats -> Either String Rational 
queryCompound :: forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound t :: TestDeal a
t@TestDeal{accounts :: forall a. TestDeal a -> Map [Char] Account
accounts=Map [Char] Account
accMap, bonds :: forall a. TestDeal a -> Map [Char] Bond
bonds=Map [Char] Bond
bndMap, ledgers :: forall a. TestDeal a -> Maybe (Map [Char] Ledger)
ledgers=Maybe (Map [Char] Ledger)
ledgersM, fees :: forall a. TestDeal a -> Map [Char] Fee
fees=Map [Char] Fee
feeMap, pool :: forall a. TestDeal a -> PoolType a
pool=PoolType a
pt}
              Date
d DealStats
s =
  case DealStats
s of
    Sum [DealStats]
_s -> [Rational] -> Rational
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Rational] -> Rational)
-> Either [Char] [Rational] -> Either [Char] Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Either [Char] Rational] -> Either [Char] [Rational]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [ TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
__s | DealStats
__s <- [DealStats]
_s]
    Substract [DealStats]
dss -> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([DealStats] -> DealStats
Subtract [DealStats]
dss)
    Subtract (DealStats
ds:[DealStats]
dss) -> 
      do
        Rational
a <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
ds 
        Rational
bs <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([DealStats] -> DealStats
Sum [DealStats]
dss) 
        Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Rational
a Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
- Rational
bs
    Avg [DealStats]
dss ->  (Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/ (Int -> Rational
forall a. Real a => a -> Rational
toRational ([DealStats] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [DealStats]
dss))) (Rational -> Rational)
-> Either [Char] Rational -> Either [Char] Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Rational] -> Rational
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Rational] -> Rational)
-> Either [Char] [Rational] -> Either [Char] Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Either [Char] Rational] -> Either [Char] [Rational]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> Either [Char] Rational)
-> [DealStats] -> [Either [Char] Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DealStats]
dss )) 
    Max [DealStats]
ss -> [Either [Char] Rational] -> Either [Char] Rational
forall a. Ord a => [a] -> a
maximum' [ TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
s | DealStats
s <- [DealStats]
ss ]
    Min [DealStats]
ss -> [Either [Char] Rational] -> Either [Char] Rational
forall a. Ord a => [a] -> a
minimum' [ TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
s | DealStats
s <- [DealStats]
ss ]
    Divide DealStats
ds1 DealStats
ds2 -> if (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
ds2) Either [Char] Rational -> Either [Char] Rational -> Bool
forall a. Eq a => a -> a -> Bool
== Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right Rational
0 then 
                        [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Can not divide zero on ds: "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
ds2
                      else
                        (Rational -> Rational -> Rational)
-> Either [Char] Rational
-> Either [Char] Rational
-> Either [Char] Rational
forall a b c.
(a -> b -> c)
-> Either [Char] a -> Either [Char] b -> Either [Char] c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
(/) (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
ds1) (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
ds2)
    Factor DealStats
s Rational
f -> (Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
* Rational
f) (Rational -> Rational)
-> Either [Char] Rational -> Either [Char] Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
s
    FloorAndCap DealStats
floor DealStats
cap DealStats
s -> Either [Char] Rational
-> Either [Char] Rational -> Either [Char] Rational
forall a. Ord a => a -> a -> a
max (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
floor) (Either [Char] Rational -> Either [Char] Rational)
-> Either [Char] Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Either [Char] Rational
-> Either [Char] Rational -> Either [Char] Rational
forall a. Ord a => a -> a -> a
min (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
cap) (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
s)
    Multiply [DealStats]
ss -> [Rational] -> Rational
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
product ([Rational] -> Rational)
-> Either [Char] [Rational] -> Either [Char] Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Either [Char] Rational] -> Either [Char] [Rational]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [ TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
_s | DealStats
_s <- [DealStats]
ss]
    FloorWith DealStats
s DealStats
floor -> (Rational -> Rational -> Rational)
-> Either [Char] Rational
-> Either [Char] Rational
-> Either [Char] Rational
forall a b c.
(a -> b -> c)
-> Either [Char] a -> Either [Char] b -> Either [Char] c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 Rational -> Rational -> Rational
forall a. Ord a => a -> a -> a
max (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
s) (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
floor)
    FloorWithZero DealStats
s -> Rational -> Rational -> Rational
forall a. Ord a => a -> a -> a
max Rational
0 (Rational -> Rational)
-> Either [Char] Rational -> Either [Char] Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
s
    Excess (DealStats
s1:[DealStats]
ss) -> do 
                        Rational
q1 <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
s1 
                        Rational
q2 <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([DealStats] -> DealStats
Sum [DealStats]
ss) -- `debug` ("Excess"++show (queryCompound t s1)++"ss"++show ( queryCompound t (Sum ss)))
                        Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Rational -> Rational
forall a. Ord a => a -> a -> a
max Rational
0 (Rational
q1 Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
-Rational
q2))
    CapWith DealStats
s DealStats
cap -> Either [Char] Rational
-> Either [Char] Rational -> Either [Char] Rational
forall a. Ord a => a -> a -> a
min (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
s) (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
cap)
    Abs DealStats
s -> Rational -> Rational
forall a. Num a => a -> a
abs (Rational -> Rational)
-> Either [Char] Rational -> Either [Char] Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
s
    Round DealStats
ds RoundingBy Rational
rb -> do 
                      Rational
q <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
ds
                      Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ RoundingBy Rational -> Rational -> Rational
forall a.
(Num a, Fractional a, RealFrac a) =>
RoundingBy a -> a -> a
roundingBy RoundingBy Rational
rb Rational
q
    DivideRatio DealStats
s1 DealStats
s2 -> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats -> DealStats
Divide DealStats
s1 DealStats
s2)
    AvgRatio [DealStats]
ss -> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([DealStats] -> DealStats
Avg [DealStats]
ss)
    Constant Rational
v -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right Rational
v
    -- rate query
    DealStats
BondFactor -> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats -> DealStats
Divide DealStats
CurrentBondBalance  DealStats
OriginalBondBalance) 
    BondFactorOf [Char]
bn -> 
      TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats -> DealStats
Divide ([[Char]] -> DealStats
CurrentBondBalanceOf [[Char]
bn]) ([[Char]] -> DealStats
OriginalBondBalanceOf [[Char]
bn])) 
    PoolFactor Maybe [PoolId]
mPns -> 
      TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats -> DealStats
Divide (Maybe [PoolId] -> DealStats
CurrentPoolBalance Maybe [PoolId]
mPns) (Maybe [PoolId] -> DealStats
OriginalPoolBalance Maybe [PoolId]
mPns))
    FutureCurrentPoolFactor Date
asOfDay Maybe [PoolId]
mPns -> 
      TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats -> DealStats
Divide (Maybe [PoolId] -> DealStats
FutureCurrentPoolBalance Maybe [PoolId]
mPns) (Maybe [PoolId] -> DealStats
OriginalPoolBalance Maybe [PoolId]
mPns))
    CumulativePoolDefaultedRate Maybe [PoolId]
mPns -> 
      TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats -> DealStats
Divide ([PoolSource] -> Maybe [PoolId] -> DealStats
PoolCumCollection [PoolSource
NewDefaults] Maybe [PoolId]
mPns) (Maybe [PoolId] -> DealStats
OriginalPoolBalance Maybe [PoolId]
mPns))
    CumulativeNetLossRatio Maybe [PoolId]
mPns -> 
      TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats -> DealStats
Divide (Maybe [PoolId] -> DealStats
CumulativeNetLoss Maybe [PoolId]
mPns) (Maybe [PoolId] -> DealStats
OriginalPoolBalance Maybe [PoolId]
mPns))
    CumulativePoolDefaultedRateTill Int
idx Maybe [PoolId]
mPns ->
      TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats -> DealStats
Divide (Int -> [PoolSource] -> Maybe [PoolId] -> DealStats
PoolCumCollectionTill Int
idx [PoolSource
NewDefaults] Maybe [PoolId]
mPns) (Maybe [PoolId] -> DealStats
OriginalPoolBalance Maybe [PoolId]
mPns))
    
    BondRate [Char]
bn -> 
      case [Char] -> Map [Char] Bond -> Maybe Bond
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup [Char]
bn (TestDeal a -> Map [Char] Bond
forall a. TestDeal a -> Map [Char] Bond
bonds TestDeal a
t) of 
        Just b :: Bond
b@(L.Bond {}) -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (IRate -> Rational) -> IRate -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IRate -> Rational
forall a. Real a => a -> Rational
toRational (IRate -> Either [Char] Rational)
-> IRate -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Bond -> IRate
forall lb. Liable lb => lb -> IRate
L.getCurRate Bond
b 
        Just b :: Bond
b@(L.MultiIntBond {}) -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (IRate -> Rational) -> IRate -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IRate -> Rational
forall a. Real a => a -> Rational
toRational (IRate -> Either [Char] Rational)
-> IRate -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Bond -> IRate
forall lb. Liable lb => lb -> IRate
L.getCurRate Bond
b 
        Just b :: Bond
b@(L.BondGroup Map [Char] Bond
bSubMap Maybe BondType
_) -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (IRate -> Rational) -> IRate -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IRate -> Rational
forall a. Real a => a -> Rational
toRational (IRate -> Either [Char] Rational)
-> IRate -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Bond -> IRate
forall lb. Liable lb => lb -> IRate
L.getCurRate Bond
b  
        Maybe Bond
Nothing -> 
          case TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]
bn] of 
            [Bond
b] -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ IRate -> Rational
forall a. Real a => a -> Rational
toRational (IRate -> Rational) -> IRate -> Rational
forall a b. (a -> b) -> a -> b
$ Bond -> IRate
L.bndRate Bond
b

    BondWaRate [[Char]]
bns ->
      do 
        [Rational]
rs <- [Either [Char] Rational] -> Either [Char] [Rational]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA ([Either [Char] Rational] -> Either [Char] [Rational])
-> [Either [Char] Rational] -> Either [Char] [Rational]
forall a b. (a -> b) -> a -> b
$ (\[Char]
bn -> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([Char] -> DealStats
BondRate [Char]
bn)) ([Char] -> Either [Char] Rational)
-> [[Char]] -> [Either [Char] Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[Char]]
bns
        [Rational]
ws <- [Either [Char] Rational] -> Either [Char] [Rational]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA ([Either [Char] Rational] -> Either [Char] [Rational])
-> [Either [Char] Rational] -> Either [Char] [Rational]
forall a b. (a -> b) -> a -> b
$ (\[Char]
bn -> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([[Char]] -> DealStats
CurrentBondBalanceOf [[Char]
bn])) ([Char] -> Either [Char] Rational)
-> [[Char]] -> [Either [Char] Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[Char]]
bns
        Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Rational] -> [Rational] -> Rational
weightedBy (Rational -> Rational
forall a. Fractional a => Rational -> a
fromRational (Rational -> Rational) -> [Rational] -> [Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Rational]
ws) [Rational]
rs

    PoolWaRate Maybe PoolId
Nothing -> 
      let 
        latestCfs :: [Maybe TsRow]
latestCfs = (Maybe TsRow -> Bool) -> [Maybe TsRow] -> [Maybe TsRow]
forall a. (a -> Bool) -> [a] -> [a]
filter Maybe TsRow -> Bool
forall a. Maybe a -> Bool
isJust ([Maybe TsRow] -> [Maybe TsRow]) -> [Maybe TsRow] -> [Maybe TsRow]
forall a b. (a -> b) -> a -> b
$ Map PoolId (Maybe TsRow) -> [Maybe TsRow]
forall k a. Map k a -> [a]
Map.elems (Map PoolId (Maybe TsRow) -> [Maybe TsRow])
-> Map PoolId (Maybe TsRow) -> [Maybe TsRow]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
getLatestCollectFrame TestDeal a
t Maybe [PoolId]
forall a. Maybe a
Nothing
        rates :: [Rational]
rates = IRate -> Rational
forall a. Real a => a -> Rational
toRational (IRate -> Rational)
-> (Maybe TsRow -> IRate) -> Maybe TsRow -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IRate -> (TsRow -> IRate) -> Maybe TsRow -> IRate
forall b a. b -> (a -> b) -> Maybe a -> b
maybe IRate
0.0 TsRow -> IRate
CF.mflowRate (Maybe TsRow -> Rational) -> [Maybe TsRow] -> [Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Maybe TsRow]
latestCfs
        bals :: [Balance]
bals = Balance -> (TsRow -> Balance) -> Maybe TsRow -> Balance
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Balance
0.0 (Getting Balance TsRow Balance -> TsRow -> Balance
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Balance TsRow Balance
Lens' TsRow Balance
CF.tsRowBalance)  (Maybe TsRow -> Balance) -> [Maybe TsRow] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Maybe TsRow]
latestCfs
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Rational] -> [Rational] -> Rational
weightedBy (Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Rational) -> [Balance] -> [Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Balance]
bals) [Rational]
rates

    PoolWaRate (Just PoolId
pName) -> 
      let 
        latestCfs :: [Maybe TsRow]
latestCfs = (Maybe TsRow -> Bool) -> [Maybe TsRow] -> [Maybe TsRow]
forall a. (a -> Bool) -> [a] -> [a]
filter Maybe TsRow -> Bool
forall a. Maybe a -> Bool
isJust ([Maybe TsRow] -> [Maybe TsRow]) -> [Maybe TsRow] -> [Maybe TsRow]
forall a b. (a -> b) -> a -> b
$ Map PoolId (Maybe TsRow) -> [Maybe TsRow]
forall k a. Map k a -> [a]
Map.elems (Map PoolId (Maybe TsRow) -> [Maybe TsRow])
-> Map PoolId (Maybe TsRow) -> [Maybe TsRow]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
getLatestCollectFrame TestDeal a
t ([PoolId] -> Maybe [PoolId]
forall a. a -> Maybe a
Just [PoolId
pName])
        rates :: [Rational]
rates = IRate -> Rational
forall a. Real a => a -> Rational
toRational (IRate -> Rational)
-> (Maybe TsRow -> IRate) -> Maybe TsRow -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IRate -> (TsRow -> IRate) -> Maybe TsRow -> IRate
forall b a. b -> (a -> b) -> Maybe a -> b
maybe IRate
0.0 TsRow -> IRate
CF.mflowRate (Maybe TsRow -> Rational) -> [Maybe TsRow] -> [Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Maybe TsRow]
latestCfs
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Rational] -> Rational
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Rational]
rates

    --TODO need to use projected current balance instead of current balance 
    PoolWaSpread Maybe [PoolId]
mPns -> 
      let 
        assets :: Map PoolId [a]
assets = TestDeal a -> Maybe [PoolId] -> Map PoolId [a]
forall a. TestDeal a -> Maybe [PoolId] -> Map PoolId [a]
getAllAsset TestDeal a
t Maybe [PoolId]
mPns
        bals :: [Balance]
bals = a -> Balance
forall a. Asset a => a -> Balance
P.getCurrentBal (a -> Balance) -> [a] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[a]] -> [a]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (Map PoolId [a] -> [[a]]
forall k a. Map k a -> [a]
Map.elems Map PoolId [a]
assets)
        spreads :: [IRate]
spreads = (OriginalInfo -> IRate) -> [OriginalInfo] -> [IRate]
forall a b. (a -> b) -> [a] -> [b]
map 
                    (\case 
                        AB.MortgageOriginalInfo { originRate :: OriginalInfo -> RateType
AB.originRate = RateType
r } -> IRate -> Maybe IRate -> IRate
forall a. a -> Maybe a -> a
fromMaybe IRate
0.0 (Maybe IRate -> IRate) -> Maybe IRate -> IRate
forall a b. (a -> b) -> a -> b
$ RateType -> Maybe IRate
IR._getSpread RateType
r
                        AB.LoanOriginalInfo { originRate :: OriginalInfo -> RateType
AB.originRate = RateType
r } -> IRate -> Maybe IRate -> IRate
forall a. a -> Maybe a -> a
fromMaybe IRate
0.0 (Maybe IRate -> IRate) -> Maybe IRate -> IRate
forall a b. (a -> b) -> a -> b
$ RateType -> Maybe IRate
IR._getSpread RateType
r
                        OriginalInfo
_ -> IRate
0.0)
                    (a -> OriginalInfo
forall a. Asset a => a -> OriginalInfo
P.getOriginInfo (a -> OriginalInfo) -> [a] -> [OriginalInfo]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[a]] -> [a]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (Map PoolId [a] -> [[a]]
forall k a. Map k a -> [a]
Map.elems Map PoolId [a]
assets))
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Rational] -> [Rational] -> Rational
weightedBy (Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Rational) -> [Balance] -> [Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Balance]
bals) (IRate -> Rational
forall a. Real a => a -> Rational
toRational (IRate -> Rational) -> [IRate] -> [Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [IRate]
spreads)

    DealStatRate DealStatFields
s -> 
      case TestDeal a
-> (BalDealStatMap, RDealStatMap, BDealStatMap, IDealStatMap)
forall a.
TestDeal a
-> (BalDealStatMap, RDealStatMap, BDealStatMap, IDealStatMap)
stats TestDeal a
t of 
        (BalDealStatMap
_,RDealStatMap
m,BDealStatMap
_,IDealStatMap
_) -> case DealStatFields -> RDealStatMap -> Maybe Rational
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup DealStatFields
s RDealStatMap
m of
                      Just Rational
v -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Rational -> Rational) -> Rational -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Rational
forall a. Real a => a -> Rational
toRational (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Rational
v
                      Maybe Rational
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to rate deal stat of -> "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStatFields -> [Char]
forall a. Show a => a -> [Char]
show DealStatFields
s


    -- int query
    FutureCurrentPoolBorrowerNum Date
_d Maybe [PoolId]
mPns ->
      let 
        poolCfs :: [Maybe TsRow]
poolCfs = Map PoolId (Maybe TsRow) -> [Maybe TsRow]
forall k a. Map k a -> [a]
Map.elems (Map PoolId (Maybe TsRow) -> [Maybe TsRow])
-> Map PoolId (Maybe TsRow) -> [Maybe TsRow]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
getLatestCollectFrame TestDeal a
t Maybe [PoolId]
mPns
        poolBn :: [Int]
poolBn =  Int -> (TsRow -> Int) -> Maybe TsRow -> Int
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Int
0 (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
0 (Maybe Int -> Int) -> (TsRow -> Maybe Int) -> TsRow -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TsRow -> Maybe Int
CF.mflowBorrowerNum) (Maybe TsRow -> Int) -> [Maybe TsRow] -> [Int]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Maybe TsRow]
poolCfs
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Int -> Rational) -> Int -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Rational
forall a. Real a => a -> Rational
toRational (Int -> Either [Char] Rational) -> Int -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Int] -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Int]
poolBn

    CurrentPoolBorrowerNum Maybe [PoolId]
mPns ->
      let 
        assetM :: [a]
assetM = [[a]] -> [a]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[a]] -> [a]) -> [[a]] -> [a]
forall a b. (a -> b) -> a -> b
$ Map PoolId [a] -> [[a]]
forall k a. Map k a -> [a]
Map.elems (Map PoolId [a] -> [[a]]) -> Map PoolId [a] -> [[a]]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Maybe [PoolId] -> Map PoolId [a]
forall a. TestDeal a -> Maybe [PoolId] -> Map PoolId [a]
getAllAsset TestDeal a
t Maybe [PoolId]
mPns
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Int -> Rational) -> Int -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Rational
forall a. Real a => a -> Rational
toRational (Int -> Either [Char] Rational) -> Int -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Int] -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Int] -> Int) -> [Int] -> Int
forall a b. (a -> b) -> a -> b
$ a -> Int
forall a. Asset a => a -> Int
P.getBorrowerNum (a -> Int) -> [a] -> [Int]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [a]
assetM 

    MonthsTillMaturity [Char]
bn -> 
      do 
        (L.OriginalInfo Balance
_ Date
_ Rational
_ Maybe Date
mm) <- (Bond -> OriginalInfo)
-> [Char]
-> [Char]
-> Map [Char] Bond
-> Either [Char] OriginalInfo
forall k a b.
Ord k =>
(a -> b) -> [Char] -> k -> Map k a -> Either [Char] b
lookupAndApply Bond -> OriginalInfo
L.bndOriginInfo [Char]
"Get Months till maturity" [Char]
bn Map [Char] Bond
bndMap 
        case Maybe Date
mm of
          Maybe Date
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"There is maturity date for bond " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
bn
          Just Date
md -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Integer -> Rational) -> Integer -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Rational
forall a. Real a => a -> Rational
toRational (Integer -> Either [Char] Rational)
-> Integer -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ CalendarDiffDays -> Integer
T.cdMonths (CalendarDiffDays -> Integer) -> CalendarDiffDays -> Integer
forall a b. (a -> b) -> a -> b
$ Date -> Date -> CalendarDiffDays
T.diffGregorianDurationClip Date
md Date
d

    DealStats
ProjCollectPeriodNum -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Int -> Rational) -> Int -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Rational
forall a. Real a => a -> Rational
toRational (Int -> Either [Char] Rational) -> Int -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Int] -> Int
forall a. Ord a => [a] -> a
maximum' ([Int] -> Int) -> [Int] -> Int
forall a b. (a -> b) -> a -> b
$ Map PoolId Int -> [Int]
forall k a. Map k a -> [a]
Map.elems (Map PoolId Int -> [Int]) -> Map PoolId Int -> [Int]
forall a b. (a -> b) -> a -> b
$ (CashFlowFrame -> Int)
-> Map PoolId CashFlowFrame -> Map PoolId Int
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map CashFlowFrame -> Int
CF.sizeCashFlowFrame (Map PoolId CashFlowFrame -> Map PoolId Int)
-> Map PoolId CashFlowFrame -> Map PoolId Int
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Maybe [PoolId] -> Map PoolId CashFlowFrame
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId CashFlowFrame
getAllCollectedFrame TestDeal a
t Maybe [PoolId]
forall a. Maybe a
Nothing

    DealStatInt DealStatFields
s -> 
      case TestDeal a
-> (BalDealStatMap, RDealStatMap, BDealStatMap, IDealStatMap)
forall a.
TestDeal a
-> (BalDealStatMap, RDealStatMap, BDealStatMap, IDealStatMap)
stats TestDeal a
t of 
        (BalDealStatMap
_,RDealStatMap
_,BDealStatMap
_,IDealStatMap
m) -> case DealStatFields -> IDealStatMap -> Maybe Int
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup DealStatFields
s IDealStatMap
m of
                      Just Int
v -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Int -> Rational) -> Int -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Rational
forall a. Real a => a -> Rational
toRational (Int -> Either [Char] Rational) -> Int -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Int
v
                      Maybe Int
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to query int deal stat of -> "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStatFields -> [Char]
forall a. Show a => a -> [Char]
show DealStatFields
s [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" in map"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ IDealStatMap -> [Char]
forall a. Show a => a -> [Char]
show IDealStatMap
m


    ReserveBalance [[Char]]
ans -> 
      do 
        [Either [Char] Balance]
accBal <- (Account -> Either [Char] Balance)
-> [Char]
-> [[Char]]
-> Map [Char] Account
-> Either [Char] [Either [Char] Balance]
forall k a b.
Ord k =>
(a -> b) -> [Char] -> [k] -> Map k a -> Either [Char] [b]
lookupAndApplies (TestDeal a -> Date -> Account -> Either [Char] Balance
forall a.
Asset a =>
TestDeal a -> Date -> Account -> Either [Char] Balance
calcTargetAmount TestDeal a
t Date
d) ([Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Cal Reserve Balance") [[Char]]
ans Map [Char] Account
accMap
        [Balance]
vs <- [Either [Char] Balance] -> Either [Char] [Balance]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [Either [Char] Balance]
accBal
        Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance -> Rational
forall a. Real a => a -> Rational
toRational ([Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Balance]
vs)


    ReserveExcessAt Date
_d [[Char]]
ans ->
      do 
        Rational
q1 <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([[Char]] -> DealStats
AccBalance [[Char]]
ans)
        Rational
q2 <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([[Char]] -> DealStats
ReserveBalance [[Char]]
ans)
        Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Rational -> Rational -> Rational
forall a. Ord a => a -> a -> a
max Rational
0 (Rational
q1 Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
- Rational
q2)

    ReserveGapAt Date
_d [[Char]]
ans ->
      do 
        Rational
q1 <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([[Char]] -> DealStats
AccBalance [[Char]]
ans)
        Rational
q2 <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([[Char]] -> DealStats
ReserveBalance [[Char]]
ans)
        Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Rational -> Rational -> Rational
forall a. Ord a => a -> a -> a
max Rational
0 (Rational
q2 Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
- Rational
q1)

    DealStats
CurrentBondBalance -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ (Bond -> Balance -> Balance)
-> Balance -> Map [Char] Bond -> Balance
forall a b k. (a -> b -> b) -> b -> Map k a -> b
Map.foldr (\Bond
x Balance
acc -> Bond -> Balance
forall lb. Liable lb => lb -> Balance
getCurBalance Bond
x Balance -> Balance -> Balance
forall a. Num a => a -> a -> a
+ Balance
acc) Balance
0.0 Map [Char] Bond
bndMap
    
    DealStats
OriginalBondBalance -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ (Bond -> Balance -> Balance)
-> Balance -> Map [Char] Bond -> Balance
forall a b k. (a -> b -> b) -> b -> Map k a -> b
Map.foldr (\Bond
x Balance
acc -> Bond -> Balance
forall lb. Liable lb => lb -> Balance
getOriginBalance Bond
x Balance -> Balance -> Balance
forall a. Num a => a -> a -> a
+ Balance
acc) Balance
0.0 Map [Char] Bond
bndMap
    
    BondDuePrin [[Char]]
bnds -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Bond -> Balance
L.bndDuePrin (Bond -> Balance) -> [Bond] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bnds
    
    OriginalBondBalanceOf [[Char]]
bnds -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Bond -> Balance
forall lb. Liable lb => lb -> Balance
getOriginBalance (Bond -> Balance) -> [Bond] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bnds

    CurrentBondBalanceOf [[Char]]
bns -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Bond -> Balance
forall lb. Liable lb => lb -> Balance
getCurBalance (Bond -> Balance) -> [Bond] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bns

    BondTotalFunding [[Char]]
bnds -> 
      Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Bond -> Balance
L.totalFundedBalance (Bond -> Balance) -> [Bond] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bnds

    CurrentPoolBalance Maybe [PoolId]
mPns ->
      let
        assetM :: [a]
assetM = [[a]] -> [a]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[a]] -> [a]) -> [[a]] -> [a]
forall a b. (a -> b) -> a -> b
$ Map PoolId [a] -> [[a]]
forall k a. Map k a -> [a]
Map.elems (Map PoolId [a] -> [[a]]) -> Map PoolId [a] -> [[a]]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Maybe [PoolId] -> Map PoolId [a]
forall a. TestDeal a -> Maybe [PoolId] -> Map PoolId [a]
getAllAsset TestDeal a
t Maybe [PoolId]
mPns
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ a -> Balance
forall a. Asset a => a -> Balance
P.getCurrentBal (a -> Balance) -> [a] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [a]
assetM 
    
    DealStats
CurrentPoolDefaultedBalance ->
      Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ 
        (Balance -> a -> Balance) -> Balance -> [a] -> Balance
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Balance
acc a
x -> Balance
acc Balance -> Balance -> Balance
forall a. Num a => a -> a -> a
+ a -> Balance
forall a. Asset a => a -> Balance
P.getCurrentBal a
x)
              Balance
0.0 ([a] -> Balance) -> [a] -> Balance
forall a b. (a -> b) -> a -> b
$
              (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter a -> Bool
forall a. Asset a => a -> Bool
P.isDefaulted (TestDeal a -> [a]
forall a. Asset a => TestDeal a -> [a]
getAllAssetList TestDeal a
t)

    DealIssuanceBalance Maybe [PoolId]
mPns -> 
      Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ 
        [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Balance -> CutoffFields -> Map CutoffFields Balance -> Balance
forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault Balance
0.0 CutoffFields
IssuanceBalance (Map CutoffFields Balance -> Balance)
-> [Map CutoffFields Balance] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map PoolId (Map CutoffFields Balance) -> [Map CutoffFields Balance]
forall k a. Map k a -> [a]
Map.elems (TestDeal a
-> Maybe [PoolId] -> Map PoolId (Map CutoffFields Balance)
forall a.
Asset a =>
TestDeal a
-> Maybe [PoolId] -> Map PoolId (Map CutoffFields Balance)
getIssuanceStats TestDeal a
t Maybe [PoolId]
mPns)

    OriginalPoolBalance Maybe [PoolId]
mPns -> 
      let 
        statsConsol :: Map CutoffFields Balance
statsConsol = TestDeal a -> Maybe [PoolId] -> Map CutoffFields Balance
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map CutoffFields Balance
getIssuanceStatsConsol TestDeal a
t Maybe [PoolId]
mPns 
      in 
        case CutoffFields -> Map CutoffFields Balance -> Maybe Balance
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup CutoffFields
IssuanceBalance Map CutoffFields Balance
statsConsol of 
          Just Balance
v -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance
v
          Maybe Balance
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No issuance balance found in the pool, pls specify it in the pool stats map `issuanceStat`"
    
    UnderlyingBondBalance Maybe [[Char]]
mBndNames -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Not implemented for underlying bond balance"

    DealStats
AllAccBalance -> 
      Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ (Account -> Balance) -> [Account] -> [Balance]
forall a b. (a -> b) -> [a] -> [b]
map Account -> Balance
A.accBalance ([Account] -> [Balance]) -> [Account] -> [Balance]
forall a b. (a -> b) -> a -> b
$ Map [Char] Account -> [Account]
forall k a. Map k a -> [a]
Map.elems Map [Char] Account
accMap 
    
    AccBalance [[Char]]
ans -> 
      do 
        [Balance]
accBals <- (Account -> Balance)
-> [Char]
-> [[Char]]
-> Map [Char] Account
-> Either [Char] [Balance]
forall k a b.
Ord k =>
(a -> b) -> [Char] -> [k] -> Map k a -> Either [Char] [b]
lookupAndApplies Account -> Balance
A.accBalance [Char]
"AccBalance" [[Char]]
ans Map [Char] Account
accMap
        Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ (Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Rational)
-> ([Balance] -> Balance) -> [Balance] -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum) [Balance]
accBals

    -- ^ negatave -> credit balance , postive -> debit balance
    LedgerBalance [[Char]]
ans ->
      case Maybe (Map [Char] Ledger)
ledgersM of 
        Maybe (Map [Char] Ledger)
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No ledgers were modeled , failed to find ledger:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[[Char]] -> [Char]
forall a. Show a => a -> [Char]
show [[Char]]
ans )
        Just Map [Char] Ledger
ledgersM -> 
          do 
            [Balance]
lgBals <- (Ledger -> Balance)
-> [Char]
-> [[Char]]
-> Map [Char] Ledger
-> Either [Char] [Balance]
forall k a b.
Ord k =>
(a -> b) -> [Char] -> [k] -> Map k a -> Either [Char] [b]
lookupAndApplies Ledger -> Balance
LD.ledgBalance [Char]
"Ledger Balance" [[Char]]
ans Map [Char] Ledger
ledgersM
            Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ (Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Rational)
-> ([Balance] -> Balance) -> [Balance] -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum) [Balance]
lgBals
    
    LedgerBalanceBy BookDirection
dr [[Char]]
ans ->
      case Maybe (Map [Char] Ledger)
ledgersM of 
        Maybe (Map [Char] Ledger)
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No ledgers were modeled , failed to find ledger:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[[Char]] -> [Char]
forall a. Show a => a -> [Char]
show [[Char]]
ans )
        Just Map [Char] Ledger
ledgersM ->
          do 
            Map [Char] Ledger
lgdsM <- [Char]
-> [[Char]]
-> Map [Char] Ledger
-> Either [Char] (Map [Char] Ledger)
forall k a.
(Show k, Ord k) =>
[Char] -> [k] -> Map k a -> Either [Char] (Map k a)
selectInMap [Char]
"Look up ledgers" [[Char]]
ans Map [Char] Ledger
ledgersM
            let ldgL :: [Ledger]
ldgL = Map [Char] Ledger -> [Ledger]
forall k a. Map k a -> [a]
Map.elems Map [Char] Ledger
lgdsM
            let bs :: BookDirection -> [Ledger]
bs BookDirection
Credit = (Ledger -> Bool) -> [Ledger] -> [Ledger]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Ledger
x -> Ledger -> Balance
LD.ledgBalance Ledger
x Balance -> Balance -> Bool
forall a. Ord a => a -> a -> Bool
< Balance
0) [Ledger]
ldgL
            let bs :: BookDirection -> [Ledger]
bs BookDirection
Debit = (Ledger -> Bool) -> [Ledger] -> [Ledger]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Ledger
x -> Ledger -> Balance
LD.ledgBalance Ledger
x Balance -> Balance -> Bool
forall a. Ord a => a -> a -> Bool
>= Balance
0) [Ledger]
ldgL
            Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Rational) -> Balance -> Rational
forall a b. (a -> b) -> a -> b
$ Balance -> Balance
forall a. Num a => a -> a
abs (Balance -> Balance) -> Balance -> Balance
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Ledger -> Balance
LD.ledgBalance (Ledger -> Balance) -> [Ledger] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> BookDirection -> [Ledger]
bs BookDirection
dr

    FutureCurrentPoolBalance Maybe [PoolId]
mPns ->
      case (Maybe [PoolId]
mPns,PoolType a
pt) of 
        (Maybe [PoolId]
Nothing, MultiPool Map PoolId (Pool a)
pm ) -> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (Maybe [PoolId] -> DealStats
FutureCurrentPoolBalance ([PoolId] -> Maybe [PoolId]
forall a. a -> Maybe a
Just ([PoolId] -> Maybe [PoolId]) -> [PoolId] -> Maybe [PoolId]
forall a b. (a -> b) -> a -> b
$ Map PoolId (Pool a) -> [PoolId]
forall k a. Map k a -> [k]
Map.keys Map PoolId (Pool a)
pm))
        (Just [PoolId]
pids, MultiPool Map PoolId (Pool a)
pm) -> 
          if Set PoolId -> Set PoolId -> Bool
forall a. Ord a => Set a -> Set a -> Bool
S.isSubsetOf  ([PoolId] -> Set PoolId
forall a. Ord a => [a] -> Set a
S.fromList [PoolId]
pids) ([PoolId] -> Set PoolId
forall a. Ord a => [a] -> Set a
S.fromList (Map PoolId (Pool a) -> [PoolId]
forall k a. Map k a -> [k]
Map.keys Map PoolId (Pool a)
pm)) then 
            let 
              selectedPools :: [Pool a]
selectedPools = Map PoolId (Pool a) -> [Pool a]
forall k a. Map k a -> [a]
Map.elems (Map PoolId (Pool a) -> [Pool a])
-> Map PoolId (Pool a) -> [Pool a]
forall a b. (a -> b) -> a -> b
$ (PoolId -> Pool a -> Bool)
-> Map PoolId (Pool a) -> Map PoolId (Pool a)
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey (\PoolId
k Pool a
_ -> PoolId -> Set PoolId -> Bool
forall a. Ord a => a -> Set a -> Bool
S.member PoolId
k ([PoolId] -> Set PoolId
forall a. Ord a => [a] -> Set a
S.fromList [PoolId]
pids)) Map PoolId (Pool a)
pm
            in 
              do 
                [Balance]
currentBals <- [Either [Char] Balance] -> Either [Char] [Balance]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA ([Either [Char] Balance] -> Either [Char] [Balance])
-> [Either [Char] Balance] -> Either [Char] [Balance]
forall a b. (a -> b) -> a -> b
$ (Pool a -> CutoffFields -> Either [Char] Balance
forall a. Pool a -> CutoffFields -> Either [Char] Balance
`Pl.getIssuanceField` CutoffFields
RuntimeCurrentPoolBalance) (Pool a -> Either [Char] Balance)
-> [Pool a] -> [Either [Char] Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Pool a]
selectedPools
                Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Rational) -> Balance -> Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Balance]
currentBals
          else 
            [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to find pool balance" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [PoolId] -> [Char]
forall a. Show a => a -> [Char]
show [PoolId]
pids [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" from deal "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [PoolId] -> [Char]
forall a. Show a => a -> [Char]
show (Map PoolId (Pool a) -> [PoolId]
forall k a. Map k a -> [k]
Map.keys Map PoolId (Pool a)
pm)
        (Maybe [PoolId], PoolType a)
_ -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to find pool" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Maybe [PoolId] -> [Char]
forall a. Show a => a -> [Char]
show Maybe [PoolId]
mPns [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
","[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ PoolType a -> [Char]
forall a. Show a => a -> [Char]
show PoolType a
pt

--     FutureCurrentSchedulePoolBalance mPns ->
--       let 
--         scheduleFlowM = Map.elems $ view dealScheduledCashflow t
--       in 
--         Right . toRational $ sum $ ((view CF.tsRowBalance) . head . view CF.cashflowTxn) <$> scheduleFlowM
--     
--     FutureCurrentSchedulePoolBegBalance mPns ->
--       let 
--         scheduleFlowM = Map.elems $ view dealScheduledCashflow t
--       in 
--         Right . toRational $ sum $ (CF.mflowBegBalance . head . view CF.cashflowTxn) <$> scheduleFlowM
    
    FutureCurrentPoolBegBalance Maybe [PoolId]
mPns ->
      let 
        ltc :: Map PoolId (Maybe TsRow)
ltc = TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
getLatestCollectFrame TestDeal a
t Maybe [PoolId]
mPns
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Map PoolId Balance -> Balance
forall a. Num a => Map PoolId a -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum (Map PoolId Balance -> Balance) -> Map PoolId Balance -> Balance
forall a b. (a -> b) -> a -> b
$ Balance -> (TsRow -> Balance) -> Maybe TsRow -> Balance
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Balance
0 TsRow -> Balance
CF.mflowBegBalance (Maybe TsRow -> Balance)
-> Map PoolId (Maybe TsRow) -> Map PoolId Balance
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map PoolId (Maybe TsRow)
ltc 

    PoolCollectionHistory PoolSource
incomeType Date
fromDay Date
asOfDay Maybe [PoolId]
mPns ->
      Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Balance]
fieldAmts
        where
          mTxns :: [[TsRow]]
mTxns = Map PoolId [TsRow] -> [[TsRow]]
forall k a. Map k a -> [a]
Map.elems (Map PoolId [TsRow] -> [[TsRow]])
-> Map PoolId [TsRow] -> [[TsRow]]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Maybe [PoolId] -> Map PoolId [TsRow]
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId [TsRow]
getAllCollectedTxns TestDeal a
t Maybe [PoolId]
mPns
          subflow :: [TsRow]
subflow = RangeType -> Date -> Date -> [TsRow] -> [TsRow]
forall ts.
TimeSeries ts =>
RangeType -> Date -> Date -> [ts] -> [ts]
sliceBy RangeType
EI Date
fromDay Date
asOfDay ([TsRow] -> [TsRow]) -> [TsRow] -> [TsRow]
forall a b. (a -> b) -> a -> b
$ [[TsRow]] -> [TsRow]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[TsRow]]
mTxns
          fieldAmts :: [Balance]
fieldAmts = (TsRow -> Balance) -> [TsRow] -> [Balance]
forall a b. (a -> b) -> [a] -> [b]
map (TsRow -> PoolSource -> Balance
`CF.lookupSource` PoolSource
incomeType) [TsRow]
subflow  

    CumulativePoolDefaultedBalance Maybe [PoolId]
mPns ->
      let
        latestCollect :: Map PoolId (Maybe TsRow)
latestCollect = TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
getLatestCollectFrame TestDeal a
t Maybe [PoolId]
mPns
        futureDefaults :: Balance
futureDefaults = [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Map PoolId Balance -> [Balance]
forall k a. Map k a -> [a]
Map.elems (Map PoolId Balance -> [Balance])
-> Map PoolId Balance -> [Balance]
forall a b. (a -> b) -> a -> b
$ (Maybe TsRow -> Balance)
-> Map PoolId (Maybe TsRow) -> Map PoolId Balance
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (Balance -> (TsRow -> Balance) -> Maybe TsRow -> Balance
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Balance
0 (Balance -> Maybe Balance -> Balance
forall a. a -> Maybe a -> a
fromMaybe Balance
0 (Maybe Balance -> Balance)
-> (TsRow -> Maybe Balance) -> TsRow -> Balance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TsRow -> Maybe Balance
CF.tsCumDefaultBal )) (Map PoolId (Maybe TsRow) -> Map PoolId Balance)
-> Map PoolId (Maybe TsRow) -> Map PoolId Balance
forall a b. (a -> b) -> a -> b
$ Map PoolId (Maybe TsRow)
latestCollect 
      in
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance
futureDefaults -- `debug` ("future Defaults at"++ show futureDefaults ++ show latestCollect)

    CumulativePoolRecoveriesBalance Maybe [PoolId]
mPns ->
      let
        latestCollect :: Map PoolId (Maybe TsRow)
latestCollect = TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
getLatestCollectFrame TestDeal a
t Maybe [PoolId]
mPns
        futureRecoveries :: Balance
futureRecoveries = [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Map PoolId Balance -> [Balance]
forall k a. Map k a -> [a]
Map.elems (Map PoolId Balance -> [Balance])
-> Map PoolId Balance -> [Balance]
forall a b. (a -> b) -> a -> b
$ (Maybe TsRow -> Balance)
-> Map PoolId (Maybe TsRow) -> Map PoolId Balance
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (Balance -> (TsRow -> Balance) -> Maybe TsRow -> Balance
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Balance
0 (Balance -> Maybe Balance -> Balance
forall a. a -> Maybe a -> a
fromMaybe Balance
0 (Maybe Balance -> Balance)
-> (TsRow -> Maybe Balance) -> TsRow -> Balance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TsRow -> Maybe Balance
CF.tsCumRecoveriesBal)) (Map PoolId (Maybe TsRow) -> Map PoolId Balance)
-> Map PoolId (Maybe TsRow) -> Map PoolId Balance
forall a b. (a -> b) -> a -> b
$ Map PoolId (Maybe TsRow)
latestCollect 
      in
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance
futureRecoveries
    
    CumulativeNetLoss Maybe [PoolId]
mPns ->
      (Rational -> Rational -> Rational)
-> Either [Char] Rational
-> Either [Char] Rational
-> Either [Char] Rational
forall a b c.
(a -> b -> c)
-> Either [Char] a -> Either [Char] b -> Either [Char] c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 
        (-)
        (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (Maybe [PoolId] -> DealStats
CumulativePoolDefaultedBalance Maybe [PoolId]
mPns))
        (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (Maybe [PoolId] -> DealStats
CumulativePoolRecoveriesBalance Maybe [PoolId]
mPns))
    
    PoolCumCollection [PoolSource]
ps Maybe [PoolId]
mPns ->
      let 
        collectedTxns :: [TsRow]
collectedTxns = [[TsRow]] -> [TsRow]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[TsRow]] -> [TsRow])
-> (Map PoolId [TsRow] -> [[TsRow]])
-> Map PoolId [TsRow]
-> [TsRow]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map PoolId [TsRow] -> [[TsRow]]
forall k a. Map k a -> [a]
Map.elems (Map PoolId [TsRow] -> [TsRow]) -> Map PoolId [TsRow] -> [TsRow]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Maybe [PoolId] -> Map PoolId [TsRow]
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId [TsRow]
getAllCollectedTxns TestDeal a
t Maybe [PoolId]
mPns
        futureVals :: Balance
futureVals = [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ (TsRow -> PoolSource -> Balance
CF.lookupSource (TsRow -> PoolSource -> Balance)
-> [TsRow] -> [PoolSource -> Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TsRow]
collectedTxns) [PoolSource -> Balance] -> [PoolSource] -> [Balance]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [PoolSource]
ps
        
        poolStats :: [Map CutoffFields Balance]
poolStats = Map PoolId (Map CutoffFields Balance) -> [Map CutoffFields Balance]
forall k a. Map k a -> [a]
Map.elems (Map PoolId (Map CutoffFields Balance)
 -> [Map CutoffFields Balance])
-> Map PoolId (Map CutoffFields Balance)
-> [Map CutoffFields Balance]
forall a b. (a -> b) -> a -> b
$ TestDeal a
-> Maybe [PoolId] -> Map PoolId (Map CutoffFields Balance)
forall a.
Asset a =>
TestDeal a
-> Maybe [PoolId] -> Map PoolId (Map CutoffFields Balance)
getIssuanceStats TestDeal a
t Maybe [PoolId]
mPns
        historyVals :: Balance
historyVals = [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ (Balance -> CutoffFields -> Map CutoffFields Balance -> Balance
forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault Balance
0.0 (CutoffFields -> Map CutoffFields Balance -> Balance)
-> (PoolSource -> CutoffFields)
-> PoolSource
-> Map CutoffFields Balance
-> Balance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PoolSource -> CutoffFields
poolSourceToIssuanceField (PoolSource -> Map CutoffFields Balance -> Balance)
-> [PoolSource] -> [Map CutoffFields Balance -> Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [PoolSource]
ps) [Map CutoffFields Balance -> Balance]
-> [Map CutoffFields Balance] -> [Balance]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Map CutoffFields Balance]
poolStats
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance
futureVals Balance -> Balance -> Balance
forall a. Num a => a -> a -> a
+ Balance
historyVals
    
    PoolCumCollectionTill Int
idx [PoolSource]
ps Maybe [PoolId]
mPns -> 
      let 
        txnMap :: Map PoolId [TsRow]
txnMap = ([TsRow] -> [TsRow]) -> Map PoolId [TsRow] -> Map PoolId [TsRow]
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (Int -> [TsRow] -> [TsRow]
forall a. Int -> [a] -> [a]
dropLastN (Int -> Int
forall a. Num a => a -> a
negate Int
idx)) (Map PoolId [TsRow] -> Map PoolId [TsRow])
-> Map PoolId [TsRow] -> Map PoolId [TsRow]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Maybe [PoolId] -> Map PoolId [TsRow]
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId [TsRow]
getAllCollectedTxns TestDeal a
t Maybe [PoolId]
mPns 
        txnList :: [TsRow]
txnList = [[TsRow]] -> [TsRow]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[TsRow]] -> [TsRow]) -> [[TsRow]] -> [TsRow]
forall a b. (a -> b) -> a -> b
$ Map PoolId [TsRow] -> [[TsRow]]
forall k a. Map k a -> [a]
Map.elems Map PoolId [TsRow]
txnMap
        lookupList :: [PoolSource -> Balance]
lookupList = TsRow -> PoolSource -> Balance
CF.lookupSource (TsRow -> PoolSource -> Balance)
-> [TsRow] -> [PoolSource -> Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TsRow]
txnList
        futureVals :: Balance
futureVals = [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ [PoolSource -> Balance]
lookupList [PoolSource -> Balance] -> [PoolSource] -> [Balance]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [PoolSource]
ps
        sumMap :: Map CutoffFields Balance
sumMap = TestDeal a -> Maybe [PoolId] -> Map CutoffFields Balance
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map CutoffFields Balance
getIssuanceStatsConsol TestDeal a
t Maybe [PoolId]
mPns
        historyVals :: Balance
historyVals = [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Balance -> CutoffFields -> Map CutoffFields Balance -> Balance
forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault Balance
0 (CutoffFields -> Map CutoffFields Balance -> Balance)
-> (PoolSource -> CutoffFields)
-> PoolSource
-> Map CutoffFields Balance
-> Balance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PoolSource -> CutoffFields
poolSourceToIssuanceField (PoolSource -> Map CutoffFields Balance -> Balance)
-> [PoolSource] -> [Map CutoffFields Balance -> Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [PoolSource]
ps [Map CutoffFields Balance -> Balance]
-> [Map CutoffFields Balance] -> [Balance]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Map CutoffFields Balance
sumMap]
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance
futureVals Balance -> Balance -> Balance
forall a. Num a => a -> a -> a
+ Balance
historyVals

    PoolCurCollection [PoolSource]
ps Maybe [PoolId]
mPns ->
      let 
        pCf :: Map PoolId (Maybe TsRow)
pCf = TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId (Maybe TsRow)
getLatestCollectFrame TestDeal a
t Maybe [PoolId]
mPns -- `debug` ("mPns"++ show mPns)
        lastRows :: Map PoolId Balance
lastRows = (Maybe TsRow -> Balance)
-> Map PoolId (Maybe TsRow) -> Map PoolId Balance
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (Balance -> (TsRow -> Balance) -> Maybe TsRow -> Balance
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Balance
0 (\TsRow
r -> [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum (TsRow -> PoolSource -> Balance
CF.lookupSource TsRow
r (PoolSource -> Balance) -> [PoolSource] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [PoolSource]
ps))) Map PoolId (Maybe TsRow)
pCf -- `debug` ("Latest collect frame"++ show pCf)
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Map PoolId Balance -> [Balance]
forall k a. Map k a -> [a]
Map.elems Map PoolId Balance
lastRows -- `debug   ` ("lst row found"++ show lastRows)

    PoolCollectionStats Int
idx [PoolSource]
ps Maybe [PoolId]
mPns -> 
      let 
        pCollectedTxns :: Map PoolId [TsRow]
pCollectedTxns = TestDeal a -> Maybe [PoolId] -> Map PoolId [TsRow]
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId [TsRow]
getAllCollectedTxns TestDeal a
t Maybe [PoolId]
mPns 
        pStat :: Map PoolId (Maybe TsRow)
pStat = ([TsRow] -> Maybe TsRow)
-> Map PoolId [TsRow] -> Map PoolId (Maybe TsRow)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map
                  (\[TsRow]
x -> 
                    let
                      lookupIndx :: Int
lookupIndx = [TsRow] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [TsRow]
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
idx Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
                    in
                      if (( Int
lookupIndx Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= [TsRow] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [TsRow]
x ) Bool -> Bool -> Bool
||  (Int
lookupIndx Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<Int
0)) then 
                        Maybe TsRow
forall a. Maybe a
Nothing
                      else
                        TsRow -> Maybe TsRow
forall a. a -> Maybe a
Just ([TsRow]
x[TsRow] -> Int -> TsRow
forall a. HasCallStack => [a] -> Int -> a
!!Int
lookupIndx))
                  Map PoolId [TsRow]
pCollectedTxns -- `debug` ("date"++show d++"Pool collection: "++ show pCollectedTxns)
      in
        do
          Map PoolId Rational
curPoolBalM <- Map PoolId (Either [Char] Rational)
-> Either [Char] (Map PoolId Rational)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a.
Applicative f =>
Map PoolId (f a) -> f (Map PoolId a)
sequenceA (Map PoolId (Either [Char] Rational)
 -> Either [Char] (Map PoolId Rational))
-> Map PoolId (Either [Char] Rational)
-> Either [Char] (Map PoolId Rational)
forall a b. (a -> b) -> a -> b
$
                           (PoolId -> Maybe TsRow -> Either [Char] Rational)
-> Map PoolId (Maybe TsRow) -> Map PoolId (Either [Char] Rational)
forall k a b. (k -> a -> b) -> Map k a -> Map k b
Map.mapWithKey
                             (\PoolId
k Maybe TsRow
v -> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (Maybe [PoolId] -> DealStats
FutureCurrentPoolBalance ([PoolId] -> Maybe [PoolId]
forall a. a -> Maybe a
Just [PoolId
k]))) 
                             Map PoolId (Maybe TsRow)
pStat -- `debug` ("date"++show d++"Pool stats collection: "++ show pStat)
          let poolStat :: Map PoolId Balance
poolStat = (PoolId -> Maybe TsRow -> Balance)
-> Map PoolId (Maybe TsRow) -> Map PoolId Balance
forall k a b. (k -> a -> b) -> Map k a -> Map k b
Map.mapWithKey
                           (\PoolId
k Maybe TsRow
v -> 
                              case Maybe TsRow
v of
                                Just TsRow
_v -> [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ TsRow -> PoolSource -> Balance
CF.lookupSource TsRow
_v (PoolSource -> Balance) -> [PoolSource] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [PoolSource]
ps
                                Maybe TsRow
Nothing -> [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Balance -> Maybe TsRow -> PoolSource -> Balance
CF.lookupSourceM (Rational -> Balance
forall a. Fractional a => Rational -> a
fromRational (Map PoolId Rational
curPoolBalM Map PoolId Rational -> PoolId -> Rational
forall k a. Ord k => Map k a -> k -> a
Map.! PoolId
k)) Maybe TsRow
forall a. Maybe a
Nothing (PoolSource -> Balance) -> [PoolSource] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [PoolSource]
ps)
                           Map PoolId (Maybe TsRow)
pStat  -- `debug` ("date"++show d++"query pool current pool stat 2" ++ show pStat )
          Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Rational] -> Rational
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Rational] -> Rational) -> [Rational] -> Rational
forall a b. (a -> b) -> a -> b
$ Map PoolId Rational -> [Rational]
forall k a. Map k a -> [a]
Map.elems (Map PoolId Rational -> [Rational])
-> Map PoolId Rational -> [Rational]
forall a b. (a -> b) -> a -> b
$ Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Rational) -> Map PoolId Balance -> Map PoolId Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map PoolId Balance
poolStat -- `debug` ("query pool current stats"++ show poolStat)

    FuturePoolScheduleCfPv Date
asOfDay PricingMethod
pm Maybe [PoolId]
mPns -> 
      let 
        Map PoolId CashFlowFrame
pScheduleFlow::(Map.Map PoolId CF.CashFlowFrame) = case PoolType a
pt of
			  MultiPool Map PoolId (Pool a)
poolMap -> (Pool a -> CashFlowFrame)
-> Map PoolId (Pool a) -> Map PoolId CashFlowFrame
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (\Pool a
p -> Getting CashFlowFrame (Pool a) CashFlowFrame
-> Pool a -> CashFlowFrame
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((Maybe PoolCashflow -> Const CashFlowFrame (Maybe PoolCashflow))
-> Pool a -> Const CashFlowFrame (Pool a)
forall a. Asset a => Lens' (Pool a) (Maybe PoolCashflow)
Lens' (Pool a) (Maybe PoolCashflow)
Pl.poolFutureScheduleCf ((Maybe PoolCashflow -> Const CashFlowFrame (Maybe PoolCashflow))
 -> Pool a -> Const CashFlowFrame (Pool a))
-> ((CashFlowFrame -> Const CashFlowFrame CashFlowFrame)
    -> Maybe PoolCashflow -> Const CashFlowFrame (Maybe PoolCashflow))
-> Getting CashFlowFrame (Pool a) CashFlowFrame
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PoolCashflow -> Const CashFlowFrame PoolCashflow)
-> Maybe PoolCashflow -> Const CashFlowFrame (Maybe PoolCashflow)
forall a b (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p a (f b) -> p (Maybe a) (f (Maybe b))
_Just ((PoolCashflow -> Const CashFlowFrame PoolCashflow)
 -> Maybe PoolCashflow -> Const CashFlowFrame (Maybe PoolCashflow))
-> ((CashFlowFrame -> Const CashFlowFrame CashFlowFrame)
    -> PoolCashflow -> Const CashFlowFrame PoolCashflow)
-> (CashFlowFrame -> Const CashFlowFrame CashFlowFrame)
-> Maybe PoolCashflow
-> Const CashFlowFrame (Maybe PoolCashflow)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CashFlowFrame -> Const CashFlowFrame CashFlowFrame)
-> PoolCashflow -> Const CashFlowFrame PoolCashflow
forall s t a b. Field1 s t a b => Lens s t a b
Lens PoolCashflow PoolCashflow CashFlowFrame CashFlowFrame
_1) Pool a
p) Map PoolId (Pool a)
poolMap
			  -- ResecDeal dealMap -> Map.map (view uDealFutureScheduleCf) dealMap
        Map PoolId [TsRow]
pCfTxns::(Map.Map PoolId [CF.TsRow]) = (CashFlowFrame -> [TsRow])
-> Map PoolId CashFlowFrame -> Map PoolId [TsRow]
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (Getting [TsRow] CashFlowFrame [TsRow] -> CashFlowFrame -> [TsRow]
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting [TsRow] CashFlowFrame [TsRow]
Lens' CashFlowFrame [TsRow]
CF.cashflowTxn) (Map PoolId CashFlowFrame -> Map PoolId [TsRow])
-> Map PoolId CashFlowFrame -> Map PoolId [TsRow]
forall a b. (a -> b) -> a -> b
$
                    case Maybe [PoolId]
mPns of 
                      Maybe [PoolId]
Nothing -> Map PoolId CashFlowFrame
pScheduleFlow
                      Just [PoolId]
pIds -> (PoolId -> CashFlowFrame -> Bool)
-> Map PoolId CashFlowFrame -> Map PoolId CashFlowFrame
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey (\PoolId
k CashFlowFrame
_ -> PoolId -> Set PoolId -> Bool
forall a. Ord a => a -> Set a -> Bool
S.member PoolId
k ([PoolId] -> Set PoolId
forall a. Ord a => [a] -> Set a
S.fromList [PoolId]
pIds)) Map PoolId CashFlowFrame
pScheduleFlow
        txns :: [TsRow]
txns = CutoffType -> DateDirection -> Date -> [TsRow] -> [TsRow]
forall ts.
TimeSeries ts =>
CutoffType -> DateDirection -> Date -> [ts] -> [ts]
cutBy CutoffType
Exc DateDirection
Future Date
asOfDay ([TsRow] -> [TsRow]) -> [TsRow] -> [TsRow]
forall a b. (a -> b) -> a -> b
$ [[TsRow]] -> [TsRow]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[TsRow]] -> [TsRow]) -> [[TsRow]] -> [TsRow]
forall a b. (a -> b) -> a -> b
$ Map PoolId [TsRow] -> [[TsRow]]
forall k a. Map k a -> [a]
Map.elems Map PoolId [TsRow]
pCfTxns
        txnsCfs :: [Balance]
txnsCfs = TsRow -> Balance
CF.tsTotalCash (TsRow -> Balance) -> [TsRow] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TsRow]
txns -- `debug` ("schedule cf as of "++ show asOfDay ++ ">>" ++ show txns)
        txnsDs :: [Date]
txnsDs = TsRow -> Date
forall ts. TimeSeries ts => ts -> Date
getDate (TsRow -> Date) -> [TsRow] -> [Date]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TsRow]
txns
        txnsRates :: [IRate]
txnsRates = TsRow -> IRate
CF.mflowRate (TsRow -> IRate) -> [TsRow] -> [IRate]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TsRow]
txns
      in
        do 
          Rational
scheduleBal <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (Maybe [PoolId] -> DealStats
FutureCurrentSchedulePoolBegBalance Maybe [PoolId]
mPns)
          Rational
curBal <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (Maybe [PoolId] -> DealStats
FutureCurrentPoolBalance Maybe [PoolId]
mPns) 
          let factor :: Rational
factor = case Rational
scheduleBal of
                         Rational
0.00 -> Rational
0  
                         Rational
_ -> Rational
curBal Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/ Rational
scheduleBal -- `debug` ("cur Bal"++show curBal ++">> sheduleBal"++ show scheduleBal)
          let cfForPv :: [Balance]
cfForPv = (Balance -> Rational -> Balance
`mulBR` Rational
factor) (Balance -> Balance) -> [Balance] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Balance]
txnsCfs -- `debug` (">>> factor"++ show factor)
          let pvs :: [Balance]
pvs = case PricingMethod
pm of
                      PvRate IRate
r -> (Date -> Balance -> Balance) -> (Date, Balance) -> Balance
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (IRate -> Date -> Date -> Balance -> Balance
A.pv2 IRate
r Date
asOfDay) ((Date, Balance) -> Balance) -> [(Date, Balance)] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Date] -> [Balance] -> [(Date, Balance)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Date]
txnsDs [Balance]
cfForPv
                      -- _ -> Left $ "Date:"++ show asOfDay ++ "Failed to use pricing method on pool" ++ show pm ++"on pool id"++ show mPns
          Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Rational) -> Balance -> Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Balance]
pvs

    BondsIntPaidAt Date
d [[Char]]
bns ->
       let
          stmts :: [Maybe Statement]
stmts = (Bond -> Maybe Statement) -> [Bond] -> [Maybe Statement]
forall a b. (a -> b) -> [a] -> [b]
map Bond -> Maybe Statement
L.bndStmt ([Bond] -> [Maybe Statement]) -> [Bond] -> [Maybe Statement]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bns
          ex :: Maybe Statement -> Balance
ex Maybe Statement
s = case Maybe Statement
s of
                   Maybe Statement
Nothing -> Balance
0
                   Just (Statement DList Txn
txns) 
                     -> [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ (Txn -> Balance) -> [Txn] -> [Balance]
forall a b. (a -> b) -> [a] -> [b]
map Txn -> Balance
getTxnAmt ([Txn] -> [Balance]) -> [Txn] -> [Balance]
forall a b. (a -> b) -> a -> b
$
                          (Txn -> Bool) -> [Txn] -> [Txn]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Txn
y -> case Txn -> TxnComment
getTxnComment Txn
y of 
                                          (PayInt [[Char]]
_ ) -> Bool
True
                                          TxnComment
_ -> Bool
False)   ([Txn] -> [Txn]) -> [Txn] -> [Txn]
forall a b. (a -> b) -> a -> b
$
                          (Txn -> Bool) -> [Txn] -> [Txn]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Txn
x -> Date
d Date -> Date -> Bool
forall a. Eq a => a -> a -> Bool
== Txn -> Date
forall ts. TimeSeries ts => ts -> Date
getDate Txn
x) (DList Txn -> [Txn]
forall a. DList a -> [a]
DL.toList DList Txn
txns)
       in
          Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ (Maybe Statement -> Balance) -> [Maybe Statement] -> [Balance]
forall a b. (a -> b) -> [a] -> [b]
map Maybe Statement -> Balance
ex [Maybe Statement]
stmts

    BondsPrinPaidAt Date
d [[Char]]
bns ->
       let
          stmts :: [Maybe Statement]
stmts = (Bond -> Maybe Statement) -> [Bond] -> [Maybe Statement]
forall a b. (a -> b) -> [a] -> [b]
map Bond -> Maybe Statement
L.bndStmt ([Bond] -> [Maybe Statement]) -> [Bond] -> [Maybe Statement]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bns
          ex :: Maybe Statement -> Balance
ex Maybe Statement
s = case Maybe Statement
s of
                   Maybe Statement
Nothing -> Balance
0
                   Just (Statement DList Txn
txns) 
                     -> [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ (Txn -> Balance) -> [Txn] -> [Balance]
forall a b. (a -> b) -> [a] -> [b]
map Txn -> Balance
getTxnAmt ([Txn] -> [Balance]) -> [Txn] -> [Balance]
forall a b. (a -> b) -> a -> b
$
                          (Txn -> Bool) -> [Txn] -> [Txn]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Txn
y -> case Txn -> TxnComment
getTxnComment Txn
y of 
                                          (PayPrin [[Char]]
_ ) -> Bool
True
                                          TxnComment
_ -> Bool
False)   ([Txn] -> [Txn]) -> [Txn] -> [Txn]
forall a b. (a -> b) -> a -> b
$
                          (Txn -> Bool) -> [Txn] -> [Txn]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Txn
x -> Date
d Date -> Date -> Bool
forall a. Eq a => a -> a -> Bool
== Txn -> Date
forall ts. TimeSeries ts => ts -> Date
getDate Txn
x) (DList Txn -> [Txn]
forall a. DList a -> [a]
DL.toList DList Txn
txns)
       in
          Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ (Maybe Statement -> Balance) -> [Maybe Statement] -> [Balance]
forall a b. (a -> b) -> [a] -> [b]
map Maybe Statement -> Balance
ex [Maybe Statement]
stmts
    
    FeeTxnAmtBy Date
d [[Char]]
fns Maybe TxnComment
mCmt -> 
      let 
        fees :: [Fee]
fees = (Map [Char] Fee
feeMap Map [Char] Fee -> [Char] -> Fee
forall k a. Ord k => Map k a -> k -> a
Map.!) ([Char] -> Fee) -> [[Char]] -> [Fee]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[Char]]
fns -- Map.elems $ getFeeByName t (Just fns)
      in  
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$
          case Maybe TxnComment
mCmt of 
            Just TxnComment
cmt -> [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Fee -> Date -> TxnComment -> Balance
forall a. QueryByComment a => a -> Date -> TxnComment -> Balance
queryTxnAmtAsOf Fee
fee Date
d TxnComment
cmt | Fee
fee <- [Fee]
fees ]
            Maybe TxnComment
Nothing -> 
              let 
                _txn :: [Txn]
_txn = [[Txn]] -> [Txn]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ (DList Txn -> [Txn]
forall a. DList a -> [a]
DL.toList (DList Txn -> [Txn])
-> (Maybe Statement -> DList Txn) -> Maybe Statement -> [Txn]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Maybe Statement -> DList Txn
getTxns)(Fee -> Maybe Statement
F.feeStmt Fee
fee) | Fee
fee <- [Fee]
fees ]
              in 
                [Txn] -> Balance
sumTxn ([Txn] -> Balance) -> [Txn] -> Balance
forall a b. (a -> b) -> a -> b
$ CutoffType -> DateDirection -> Date -> [Txn] -> [Txn]
forall ts.
TimeSeries ts =>
CutoffType -> DateDirection -> Date -> [ts] -> [ts]
cutBy CutoffType
Inc DateDirection
Past Date
d [Txn]
_txn 
    
    FeePaidAmt [[Char]]
fns -> 
      let 
        fees :: [Fee]
fees = (Map [Char] Fee
feeMap Map [Char] Fee -> [Char] -> Fee
forall k a. Ord k => Map k a -> k -> a
Map.!) ([Char] -> Fee) -> [[Char]] -> [Fee]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[Char]]
fns
        feeTxns :: [Txn]
feeTxns = [[Txn]] -> [Txn]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ (DList Txn -> [Txn]
forall a. DList a -> [a]
DL.toList (DList Txn -> [Txn])
-> (Maybe Statement -> DList Txn) -> Maybe Statement -> [Txn]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Maybe Statement -> DList Txn
getTxns) (Fee -> Maybe Statement
F.feeStmt Fee
fee) | Fee
fee <- [Fee]
fees ]
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Txn] -> Balance
sumTxn [Txn]
feeTxns
    
    BondTxnAmtBy Date
d [[Char]]
bns Maybe TxnComment
mCmt -> 
      let 
        bnds :: [Bond]
bnds = TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bns
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$
          case Maybe TxnComment
mCmt of
            Just TxnComment
cmt -> [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Bond -> Date -> TxnComment -> Balance
forall a. QueryByComment a => a -> Date -> TxnComment -> Balance
queryTxnAmtAsOf Bond
bnd Date
d TxnComment
cmt | Bond
bnd <- [Bond]
bnds ]
            Maybe TxnComment
Nothing ->
              let 
                _txn :: [Txn]
_txn = [[Txn]] -> [Txn]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ (DList Txn -> [Txn]
forall a. DList a -> [a]
DL.toList (DList Txn -> [Txn])
-> (Maybe Statement -> DList Txn) -> Maybe Statement -> [Txn]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Statement -> DList Txn
getTxns) (Bond -> Maybe Statement
L.bndStmt Bond
bnd) | Bond
bnd <- [Bond]
bnds ]
              in 
                [Txn] -> Balance
sumTxn ([Txn] -> Balance) -> [Txn] -> Balance
forall a b. (a -> b) -> a -> b
$ CutoffType -> DateDirection -> Date -> [Txn] -> [Txn]
forall ts.
TimeSeries ts =>
CutoffType -> DateDirection -> Date -> [ts] -> [ts]
cutBy CutoffType
Inc DateDirection
Past Date
d [Txn]
_txn

    AccTxnAmtBy Date
d [[Char]]
ans Maybe TxnComment
mCmt -> 
      let 
        accs :: [Account]
accs = (Map [Char] Account
accMap Map [Char] Account -> [Char] -> Account
forall k a. Ord k => Map k a -> k -> a
Map.!) ([Char] -> Account) -> [[Char]] -> [Account]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[Char]]
ans
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$
          case Maybe TxnComment
mCmt of
            Just TxnComment
cmt -> [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Account -> Date -> TxnComment -> Balance
forall a. QueryByComment a => a -> Date -> TxnComment -> Balance
queryTxnAmtAsOf Account
acc Date
d TxnComment
cmt | Account
acc <- [Account]
accs ]
            Maybe TxnComment
Nothing ->
              let 
                _txn :: [Txn]
_txn = [[Txn]] -> [Txn]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ (DList Txn -> [Txn]
forall a. DList a -> [a]
DL.toList (DList Txn -> [Txn])
-> (Maybe Statement -> DList Txn) -> Maybe Statement -> [Txn]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Statement -> DList Txn
getTxns) (Account -> Maybe Statement
A.accStmt Account
acc) | Account
acc <- [Account]
accs ]
              in 
                [Txn] -> Balance
sumTxn ([Txn] -> Balance) -> [Txn] -> Balance
forall a b. (a -> b) -> a -> b
$ CutoffType -> DateDirection -> Date -> [Txn] -> [Txn]
forall ts.
TimeSeries ts =>
CutoffType -> DateDirection -> Date -> [ts] -> [ts]
cutBy CutoffType
Inc DateDirection
Past Date
d [Txn]
_txn 

    LedgerTxnAmt [[Char]]
lns Maybe TxnComment
mCmt ->
      case Maybe (Map [Char] Ledger)
ledgersM of 
        Maybe (Map [Char] Ledger)
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ ([Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No ledgers were modeled , failed to find ledger:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[[Char]] -> [Char]
forall a. Show a => a -> [Char]
show [[Char]]
lns )
        Just Map [Char] Ledger
ledgerm ->
          let 
            lgs :: [Ledger]
lgs = (Map [Char] Ledger
ledgerm Map [Char] Ledger -> [Char] -> Ledger
forall k a. Ord k => Map k a -> k -> a
Map.!) ([Char] -> Ledger) -> [[Char]] -> [Ledger]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[Char]]
lns
          in
            case Maybe TxnComment
mCmt of
              Just TxnComment
cmt -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Ledger -> TxnComment -> Balance
forall a. QueryByComment a => a -> TxnComment -> Balance
queryTxnAmt Ledger
lg TxnComment
cmt | Ledger
lg <- [Ledger]
lgs ]
              Maybe TxnComment
Nothing -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Ledger -> Balance
LD.ledgBalance Ledger
lg | Ledger
lg <- [Ledger]
lgs ]

    BondBalanceGapAt Date
d [Char]
bName -> 
      do 
        Rational
tbal <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([[Char]] -> DealStats
BondBalanceTarget [[Char]
bName])
        Rational
cbal <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([[Char]] -> DealStats
CurrentBondBalanceOf [[Char]
bName])
        Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Rational -> Rational -> Rational
forall a. Ord a => a -> a -> a
max Rational
0 (Rational -> Rational) -> Rational -> Rational
forall a b. (a -> b) -> a -> b
$ Rational
cbal Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
- Rational
tbal  -- `debug` (show d ++">"++ "tbal"++show tbal++"cbal"++show cbal)

    BondBalanceTarget [[Char]]
bNames ->
      do
        [Bond]
bnds <- Map [Char] Bond -> [[Char]] -> Either [Char] [Bond]
findBondByNames Map [Char] Bond
bndMap [[Char]]
bNames
        [Balance]
targets <- [Either [Char] Balance] -> Either [Char] [Balance]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA ([Either [Char] Balance] -> Either [Char] [Balance])
-> [Either [Char] Balance] -> Either [Char] [Balance]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> Date -> Bond -> Either [Char] Balance
forall a.
Asset a =>
TestDeal a -> Date -> Bond -> Either [Char] Balance
calcBondTargetBalance TestDeal a
t Date
d (Bond -> Either [Char] Balance)
-> [Bond] -> [Either [Char] Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Bond]
bnds
        Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Rational) -> Balance -> Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Balance]
targets

    FeesPaidAt Date
d [[Char]]
fns ->
      let
        fSubMap :: Map [Char] Fee
fSubMap = TestDeal a -> Maybe [[Char]] -> Map [Char] Fee
forall a. SPV a => a -> Maybe [[Char]] -> Map [Char] Fee
getFeeByName TestDeal a
t ([[Char]] -> Maybe [[Char]]
forall a. a -> Maybe a
Just [[Char]]
fns)
        stmts :: [Maybe Statement]
stmts = (Fee -> Maybe Statement) -> [Fee] -> [Maybe Statement]
forall a b. (a -> b) -> [a] -> [b]
map Fee -> Maybe Statement
F.feeStmt ([Fee] -> [Maybe Statement]) -> [Fee] -> [Maybe Statement]
forall a b. (a -> b) -> a -> b
$ Map [Char] Fee -> [Fee]
forall k a. Map k a -> [a]
Map.elems Map [Char] Fee
fSubMap
        ex :: Maybe Statement -> Balance
ex Maybe Statement
s = case Maybe Statement
s of
                  Maybe Statement
Nothing -> Balance
0
                  Just (Statement DList Txn
txns) -> [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Txn -> Balance
getTxnAmt (Txn -> Balance) -> [Txn] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Txn -> Bool) -> [Txn] -> [Txn]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Txn
x ->  Date
d Date -> Date -> Bool
forall a. Eq a => a -> a -> Bool
== Txn -> Date
forall ts. TimeSeries ts => ts -> Date
getDate Txn
x) (DList Txn -> [Txn]
forall a. DList a -> [a]
DL.toList DList Txn
txns)
      in
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ (Maybe Statement -> Balance) -> [Maybe Statement] -> [Balance]
forall a b. (a -> b) -> [a] -> [b]
map Maybe Statement -> Balance
ex [Maybe Statement]
stmts

    -- ^ get total int due for bonds
    CurrentDueBondInt [[Char]]
bns -> 
      Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Bond -> Balance
forall lb. Liable lb => lb -> Balance
L.getDueInt (Bond -> Balance) -> [Bond] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bns  

    -- ^ get total int over int due for bonds
    CurrentDueBondIntOverInt [[Char]]
bns -> 
      Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Bond -> Balance
forall lb. Liable lb => lb -> Balance
L.getDueIntOverInt (Bond -> Balance) -> [Bond] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bns  

    -- ^ get total due (due int + int over int due) for bonds
    CurrentDueBondIntTotal [[Char]]
bns -> 
      [Rational] -> Rational
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Rational] -> Rational)
-> Either [Char] [Rational] -> Either [Char] Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Either [Char] Rational] -> Either [Char] [Rational]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> Either [Char] Rational)
-> [DealStats] -> [Either [Char] Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[[Char]] -> DealStats
CurrentDueBondInt [[Char]]
bns,[[Char]] -> DealStats
CurrentDueBondIntOverInt [[Char]]
bns])

    CurrentDueBondIntAt Int
idx [[Char]]
bns -> 
      let 
        bs :: [Bond]
bs = (Bond -> Bool) -> [Bond] -> [Bond]
forall a. (a -> Bool) -> [a] -> [a]
filter (APrism
  Bond
  Bond
  ([Char], BondType, OriginalInfo, [InterestInfo], Maybe [StepUp],
   Balance, [IRate], Balance, [Balance], [Balance], Maybe Date,
   Maybe [Date], Maybe Date, Maybe Statement)
  ([Char], BondType, OriginalInfo, [InterestInfo], Maybe [StepUp],
   Balance, [IRate], Balance, [Balance], [Balance], Maybe Date,
   Maybe [Date], Maybe Date, Maybe Statement)
-> Bond -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is APrism
  Bond
  Bond
  ([Char], BondType, OriginalInfo, [InterestInfo], Maybe [StepUp],
   Balance, [IRate], Balance, [Balance], [Balance], Maybe Date,
   Maybe [Date], Maybe Date, Maybe Statement)
  ([Char], BondType, OriginalInfo, [InterestInfo], Maybe [StepUp],
   Balance, [IRate], Balance, [Balance], [Balance], Maybe Date,
   Maybe [Date], Maybe Date, Maybe Statement)
Prism'
  Bond
  ([Char], BondType, OriginalInfo, [InterestInfo], Maybe [StepUp],
   Balance, [IRate], Balance, [Balance], [Balance], Maybe Date,
   Maybe [Date], Maybe Date, Maybe Statement)
L._MultiIntBond) ([Bond] -> [Bond]) -> [Bond] -> [Bond]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bns
        mDueInts :: Maybe [Balance]
mDueInts = [Maybe Balance] -> Maybe [Balance]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA ([Maybe Balance] -> Maybe [Balance])
-> [Maybe Balance] -> Maybe [Balance]
forall a b. (a -> b) -> a -> b
$ (\[Balance]
x -> [Balance]
x [Balance]
-> Getting (First Balance) [Balance] Balance -> Maybe Balance
forall s a. s -> Getting (First a) s a -> Maybe a
^? Index [Balance] -> Traversal' [Balance] (IxValue [Balance])
forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix Int
Index [Balance]
idx) ([Balance] -> Maybe Balance) -> [[Balance]] -> [Maybe Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Bond -> [Balance]
L.bndDueInts (Bond -> [Balance]) -> [Bond] -> [[Balance]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Bond]
bs)
      in 
        case Maybe [Balance]
mDueInts of 
          Maybe [Balance]
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to find due int at index for bonds"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
forall a. Show a => a -> [Char]
show [[Char]]
bns [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"with Index:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
idx [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" but bonds has "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [[Balance]] -> [Char]
forall a. Show a => a -> [Char]
show (Bond -> [Balance]
L.bndDueInts (Bond -> [Balance]) -> [Bond] -> [[Balance]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Bond]
bs)
          Just [Balance]
dueInts -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Balance]
dueInts 

    CurrentDueBondIntOverIntAt Int
idx [[Char]]
bns -> 
      let 
        bs :: [Bond]
bs = (Bond -> Bool) -> [Bond] -> [Bond]
forall a. (a -> Bool) -> [a] -> [a]
filter (APrism
  Bond
  Bond
  ([Char], BondType, OriginalInfo, [InterestInfo], Maybe [StepUp],
   Balance, [IRate], Balance, [Balance], [Balance], Maybe Date,
   Maybe [Date], Maybe Date, Maybe Statement)
  ([Char], BondType, OriginalInfo, [InterestInfo], Maybe [StepUp],
   Balance, [IRate], Balance, [Balance], [Balance], Maybe Date,
   Maybe [Date], Maybe Date, Maybe Statement)
-> Bond -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is APrism
  Bond
  Bond
  ([Char], BondType, OriginalInfo, [InterestInfo], Maybe [StepUp],
   Balance, [IRate], Balance, [Balance], [Balance], Maybe Date,
   Maybe [Date], Maybe Date, Maybe Statement)
  ([Char], BondType, OriginalInfo, [InterestInfo], Maybe [StepUp],
   Balance, [IRate], Balance, [Balance], [Balance], Maybe Date,
   Maybe [Date], Maybe Date, Maybe Statement)
Prism'
  Bond
  ([Char], BondType, OriginalInfo, [InterestInfo], Maybe [StepUp],
   Balance, [IRate], Balance, [Balance], [Balance], Maybe Date,
   Maybe [Date], Maybe Date, Maybe Statement)
L._MultiIntBond) ([Bond] -> [Bond]) -> [Bond] -> [Bond]
forall a b. (a -> b) -> a -> b
$ TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bns
        mDueInts :: Maybe [Balance]
mDueInts = [Maybe Balance] -> Maybe [Balance]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA ([Maybe Balance] -> Maybe [Balance])
-> [Maybe Balance] -> Maybe [Balance]
forall a b. (a -> b) -> a -> b
$ (\[Balance]
x -> [Balance]
x [Balance]
-> Getting (First Balance) [Balance] Balance -> Maybe Balance
forall s a. s -> Getting (First a) s a -> Maybe a
^?  Index [Balance] -> Traversal' [Balance] (IxValue [Balance])
forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix Int
Index [Balance]
idx) ([Balance] -> Maybe Balance) -> [[Balance]] -> [Maybe Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Bond -> [Balance]
L.bndDueIntOverInts (Bond -> [Balance]) -> [Bond] -> [[Balance]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Bond]
bs)
      in 
        case Maybe [Balance]
mDueInts of 
          Maybe [Balance]
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to find due int over int at index for bonds"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
forall a. Show a => a -> [Char]
show [[Char]]
bns [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"with Index:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
idx [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" but bonds has "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [[Balance]] -> [Char]
forall a. Show a => a -> [Char]
show (Bond -> [Balance]
L.bndDueIntOverInts (Bond -> [Balance]) -> [Bond] -> [[Balance]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Bond]
bs)
          Just [Balance]
dueInts -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ [Balance]
dueInts

    CurrentDueBondIntTotalAt Int
idx [[Char]]
bns -> 
      [Rational] -> Rational
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Rational] -> Rational)
-> Either [Char] [Rational] -> Either [Char] Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Either [Char] Rational] -> Either [Char] [Rational]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> Either [Char] Rational)
-> [DealStats] -> [Either [Char] Rational]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Int -> [[Char]] -> DealStats
CurrentDueBondIntAt Int
idx [[Char]]
bns,Int -> [[Char]] -> DealStats
CurrentDueBondIntOverIntAt Int
idx [[Char]]
bns])

    CurrentDueFee [[Char]]
fns -> 
      do 
        [Balance]
vs <- (Fee -> Balance)
-> [Char] -> [[Char]] -> Map [Char] Fee -> Either [Char] [Balance]
forall k a b.
Ord k =>
(a -> b) -> [Char] -> [k] -> Map k a -> Either [Char] [b]
lookupAndApplies Fee -> Balance
F.feeDue [Char]
"Get Current Due Fee" [[Char]]
fns Map [Char] Fee
feeMap
        Rational -> Either [Char] Rational
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance -> Rational
forall a. Real a => a -> Rational
toRational ([Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Balance]
vs)

    LiqCredit [[Char]]
lqNames -> 
      case TestDeal a -> Maybe (Map [Char] LiqFacility)
forall a. TestDeal a -> Maybe (Map [Char] LiqFacility)
liqProvider TestDeal a
t of
        Maybe (Map [Char] LiqFacility)
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No Liquidation Provider modeled when looking for " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
s
        Just Map [Char] LiqFacility
liqProviderM -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$
                               [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ [ Balance -> Maybe Balance -> Balance
forall a. a -> Maybe a -> a
fromMaybe Balance
0 (LiqFacility -> Maybe Balance
CE.liqCredit LiqFacility
liq) | ([Char]
k,LiqFacility
liq) <- Map [Char] LiqFacility -> [([Char], LiqFacility)]
forall k a. Map k a -> [(k, a)]
Map.assocs Map [Char] LiqFacility
liqProviderM
                                     , [Char] -> Set [Char] -> Bool
forall a. Ord a => a -> Set a -> Bool
S.member [Char]
k ([[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
S.fromList [[Char]]
lqNames) ]

    LiqBalance [[Char]]
lqNames -> 
      case TestDeal a -> Maybe (Map [Char] LiqFacility)
forall a. TestDeal a -> Maybe (Map [Char] LiqFacility)
liqProvider TestDeal a
t of
        Maybe (Map [Char] LiqFacility)
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No Liquidation Provider modeled when looking for " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
s
        Just Map [Char] LiqFacility
liqProviderM -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$
                               [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ [ LiqFacility -> Balance
CE.liqBalance LiqFacility
liq | ([Char]
k,LiqFacility
liq) <- Map [Char] LiqFacility -> [([Char], LiqFacility)]
forall k a. Map k a -> [(k, a)]
Map.assocs Map [Char] LiqFacility
liqProviderM
                                     , [Char] -> Set [Char] -> Bool
forall a. Ord a => a -> Set a -> Bool
S.member [Char]
k ([[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
S.fromList [[Char]]
lqNames) ]

    RateCapNet [Char]
rcName -> case TestDeal a -> Maybe (Map [Char] RateCap)
forall a. TestDeal a -> Maybe (Map [Char] RateCap)
rateCap TestDeal a
t of
                           Maybe (Map [Char] RateCap)
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No Rate Cap modeled when looking for " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
s
                           Just Map [Char] RateCap
rm -> case [Char] -> Map [Char] RateCap -> Maybe RateCap
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup [Char]
rcName Map [Char] RateCap
rm of
                                        Maybe RateCap
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No Rate Cap modeled when looking for " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
s
                                        Just RateCap
rc -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ RateCap -> Balance
H.rcNetCash RateCap
rc
    
    RateSwapNet [Char]
rsName -> case TestDeal a -> Maybe (Map [Char] RateCap)
forall a. TestDeal a -> Maybe (Map [Char] RateCap)
rateCap TestDeal a
t of
                           Maybe (Map [Char] RateCap)
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No Rate Swap modeled when looking for " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
s
                           Just Map [Char] RateCap
rm -> case [Char] -> Map [Char] RateCap -> Maybe RateCap
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup [Char]
rsName Map [Char] RateCap
rm of
                                        Maybe RateCap
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No Rate Swap modeled when looking for " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
s
                                        Just RateCap
rc -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ RateCap -> Balance
H.rcNetCash RateCap
rc

    WeightedAvgCurrentBondBalance Date
d1 Date
d2 [[Char]]
bns ->
      Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ 
        (Bond -> Balance -> Balance)
-> Balance -> Map [Char] Bond -> Balance
forall a b k. (a -> b -> b) -> b -> Map k a -> b
Map.foldr (\Bond
v Balance
a-> Balance
a Balance -> Balance -> Balance
forall a. Num a => a -> a -> a
+ (Date -> Date -> Bond -> Balance
L.weightAverageBalance Date
d1 Date
d2 Bond
v)) 
                  Balance
0.0 
                  (TestDeal a -> Maybe [[Char]] -> Map [Char] Bond
forall a. SPV a => a -> Maybe [[Char]] -> Map [Char] Bond
getBondsByName TestDeal a
t ([[Char]] -> Maybe [[Char]]
forall a. a -> Maybe a
Just [[Char]]
bns))

    WeightedAvgCurrentPoolBalance Date
d1 Date
d2 Maybe [PoolId]
mPns ->
      let 
        Map PoolId [TsRow]
txnsByPool::(Map.Map PoolId [CF.TsRow]) = TestDeal a -> Maybe [PoolId] -> Map PoolId [TsRow]
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map PoolId [TsRow]
getAllCollectedTxns TestDeal a
t Maybe [PoolId]
mPns
        Map PoolId Balance
waBalByPool::(Map.Map PoolId Balance) = ([TsRow] -> Balance) -> Map PoolId [TsRow] -> Map PoolId Balance
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (Date -> Date -> [TsRow] -> Balance
CF.mflowWeightAverageBalance Date
d1 Date
d2) Map PoolId [TsRow]
txnsByPool
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ Map PoolId Balance -> [Balance]
forall k a. Map k a -> [a]
Map.elems Map PoolId Balance
waBalByPool

    WeightedAvgOriginalBondBalance Date
d1 Date
d2 [[Char]]
bns ->
      let 
        bnds :: [Bond]
bnds = TestDeal a -> [[Char]] -> [Bond]
forall a. Asset a => TestDeal a -> [[Char]] -> [Bond]
viewDealBondsByNames TestDeal a
t [[Char]]
bns
        oBals :: [Balance]
oBals = Bond -> Balance
forall lb. Liable lb => lb -> Balance
getOriginBalance (Bond -> Balance) -> [Bond] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Bond]
bnds
        bgDates :: [Date]
bgDates = OriginalInfo -> Date
L.originDate (OriginalInfo -> Date) -> (Bond -> OriginalInfo) -> Bond -> Date
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bond -> OriginalInfo
L.bndOriginInfo (Bond -> Date) -> [Bond] -> [Date]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Bond]
bnds -- `debug` ("bals"++show oBals++">>"++ show d1++"-"++show d2)
      in 
        Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ 
          [Balance] -> Balance
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Balance] -> Balance) -> [Balance] -> Balance
forall a b. (a -> b) -> a -> b
$ (\(Balance
b,Date
sd) -> Balance -> Rational -> Balance
mulBR Balance
b (DayCount -> Date -> Date -> Rational
yearCountFraction DayCount
DC_ACT_365F (Date -> Date -> Date
forall a. Ord a => a -> a -> a
max Date
d1 Date
sd) Date
d2)) ((Balance, Date) -> Balance) -> [(Balance, Date)] -> [Balance]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Balance] -> [Date] -> [(Balance, Date)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Balance]
oBals [Date]
bgDates) -- `debug` ("bgDates"++show bgDates)

    WeightedAvgOriginalPoolBalance Date
d1 Date
d2 Maybe [PoolId]
mPns ->
      Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$
          Balance -> Rational -> Balance
mulBR
          (Balance -> CutoffFields -> Map CutoffFields Balance -> Balance
forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault Balance
0.0 CutoffFields
IssuanceBalance (TestDeal a -> Maybe [PoolId] -> Map CutoffFields Balance
forall a.
Asset a =>
TestDeal a -> Maybe [PoolId] -> Map CutoffFields Balance
getIssuanceStatsConsol TestDeal a
t Maybe [PoolId]
mPns))
          (DayCount -> Date -> Date -> Rational
yearCountFraction DayCount
DC_ACT_365F Date
d1 Date
d2)

    -- Analytics query 
    AmountRequiredForTargetIRR Double
irr [Char]
bondName ->
      case TestDeal a -> Bool -> [Char] -> Maybe Bond
forall a. Asset a => TestDeal a -> Bool -> [Char] -> Maybe Bond
getBondByName TestDeal a
t Bool
True [Char]
bondName of
        Maybe Bond
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Failed to find bond by name"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
bondName
        Just Bond
bnd ->
          let 
            ([Date]
ds,[Balance]
vs) = Bond -> ([Date], [Balance])
L.bondCashflow Bond
bnd
            valid :: b -> Either [Char] b
valid b
_vs = case ([Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and ((Balance -> Balance -> Bool
forall a. Ord a => a -> a -> Bool
>Balance
0) (Balance -> Bool) -> [Balance] -> [Bool]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Balance]
vs)) of
                          Bool
True -> [Char] -> Either [Char] b
forall a b. a -> Either a b
Left ([Char] -> Either [Char] b) -> [Char] -> Either [Char] b
forall a b. (a -> b) -> a -> b
$ [Char]
"all cashflows are positive"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Balance] -> [Char]
forall a. Show a => a -> [Char]
show [Balance]
vs
                          Bool
_ -> b -> Either [Char] b
forall a b. b -> Either a b
Right b
_vs
            oDate :: Date
oDate = OriginalInfo -> Date
L.originDate (OriginalInfo -> Date) -> OriginalInfo -> Date
forall a b. (a -> b) -> a -> b
$ Bond -> OriginalInfo
L.bndOriginInfo Bond
bnd
          in
            do
              [Balance]
validVs <- [Balance] -> Either [Char] [Balance]
forall a. a -> Either [Char] a
valid [Balance]
vs
              case Double -> [Date] -> [Balance] -> Date -> Maybe Balance
A.calcRequiredAmtForIrrAtDate Double
irr [Date]
ds [Balance]
vs Date
d of 
                Maybe Balance
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Failed to get the required amount for target IRR: "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
bondName[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" Rate:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Double -> [Char]
forall a. Show a => a -> [Char]
show Double
irr
                Just Balance
amt -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ 
                              if Date
oDate Date -> Date -> Bool
forall a. Ord a => a -> a -> Bool
<= Date
d then
                                Balance -> Rational
forall a. Real a => a -> Rational
toRational Balance
amt
                              else
                                Rational
0.0

    CustomData [Char]
s Date
d ->
        case TestDeal a -> Maybe (Map [Char] CustomDataType)
forall a. TestDeal a -> Maybe (Map [Char] CustomDataType)
custom TestDeal a
t of 
          Maybe (Map [Char] CustomDataType)
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"No Custom data to query" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s
          Just Map [Char] CustomDataType
mCustom ->
              case [Char] -> Map [Char] CustomDataType -> Maybe CustomDataType
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup [Char]
s Map [Char] CustomDataType
mCustom of 
                Just (CustomConstant Rational
v) -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Rational -> Rational) -> Rational -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Rational
forall a. Real a => a -> Rational
toRational (Rational -> Either [Char] Rational)
-> Rational -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Rational
v 
                Just (CustomCurve PlannedAmorSchedule
cv) -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ PlannedAmorSchedule -> Date -> Balance
getValOnByDate PlannedAmorSchedule
cv Date
d
                Just (CustomDS DealStats
ds) -> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (Date -> DealStats -> DealStats
patchDateToStats Date
d DealStats
ds )
                Maybe CustomDataType
_ -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Unsupported custom data found for key " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s

    DealStatBalance DealStatFields
s -> 
      case TestDeal a
-> (BalDealStatMap, RDealStatMap, BDealStatMap, IDealStatMap)
forall a.
TestDeal a
-> (BalDealStatMap, RDealStatMap, BDealStatMap, IDealStatMap)
stats TestDeal a
t of 
        (BalDealStatMap
m,RDealStatMap
_,BDealStatMap
_,IDealStatMap
_) -> case DealStatFields -> BalDealStatMap -> Maybe Balance
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup DealStatFields
s BalDealStatMap
m of
                      Just Balance
v -> Rational -> Either [Char] Rational
forall a b. b -> Either a b
Right (Rational -> Either [Char] Rational)
-> (Balance -> Rational) -> Balance -> Either [Char] Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Balance -> Rational
forall a. Real a => a -> Rational
toRational (Balance -> Either [Char] Rational)
-> Balance -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ Balance
v
                      Maybe Balance
Nothing -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Rational)
-> [Char] -> Either [Char] Rational
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to query balance deal stat  of -> "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStatFields -> [Char]
forall a. Show a => a -> [Char]
show DealStatFields
s

    DealStats
_ -> [Char] -> Either [Char] Rational
forall a b. a -> Either a b
Left ([Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to query balance formula of -> "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
s)
    



queryDealBool :: P.Asset a => TestDeal a -> DealStats -> Date -> Either String Bool
queryDealBool :: forall a.
Asset a =>
TestDeal a -> DealStats -> Date -> Either [Char] Bool
queryDealBool t :: TestDeal a
t@TestDeal{triggers :: forall a. TestDeal a -> Maybe (Map DealCycle (Map [Char] Trigger))
triggers= Maybe (Map DealCycle (Map [Char] Trigger))
trgs,bonds :: forall a. TestDeal a -> Map [Char] Bond
bonds = Map [Char] Bond
bndMap,fees :: forall a. TestDeal a -> Map [Char] Fee
fees= Map [Char] Fee
feeMap
                        , liqProvider :: forall a. TestDeal a -> Maybe (Map [Char] LiqFacility)
liqProvider = Maybe (Map [Char] LiqFacility)
liqProviderMap, rateSwap :: forall a. TestDeal a -> Maybe (Map [Char] RateSwap)
rateSwap = Maybe (Map [Char] RateSwap)
rateCapMap }
              DealStats
ds
              Date
d = 
  case DealStats
ds of 
    TriggersStatus DealCycle
dealcycle [Char]
tName -> 
      case Maybe (Map DealCycle (Map [Char] Trigger))
trgs of 
        Just Map DealCycle (Map [Char] Trigger)
_trgsM -> case DealCycle
-> Map DealCycle (Map [Char] Trigger) -> Maybe (Map [Char] Trigger)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup DealCycle
dealcycle Map DealCycle (Map [Char] Trigger)
_trgsM of 
                         Maybe (Map [Char] Trigger)
Nothing -> [Char] -> Either [Char] Bool
forall a b. a -> Either a b
Left ([Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"no trigger cycle for this deal" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealCycle -> [Char]
forall a. Show a => a -> [Char]
show DealCycle
dealcycle)
                         Just Map [Char] Trigger
triggerMatCycle -> 
                           case [Char] -> Map [Char] Trigger -> Maybe Trigger
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup [Char]
tName Map [Char] Trigger
triggerMatCycle of 
                             Maybe Trigger
Nothing -> [Char] -> Either [Char] Bool
forall a b. a -> Either a b
Left ([Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"no trigger for this deal" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
tName [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" in cycle " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Map [Char] Trigger -> [Char]
forall a. Show a => a -> [Char]
show Map [Char] Trigger
triggerMatCycle)
                             Just Trigger
trigger -> Bool -> Either [Char] Bool
forall a b. b -> Either a b
Right (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Trigger -> Bool
Trg.trgStatus Trigger
trigger 
        Maybe (Map DealCycle (Map [Char] Trigger))
Nothing -> [Char] -> Either [Char] Bool
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Bool) -> [Char] -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"no trigger for this deal"
    
    IsMostSenior [Char]
bn [[Char]]
bns ->
      do 
        Bool
bn1 <- (Bond -> Bool)
-> [Char] -> [Char] -> Map [Char] Bond -> Either [Char] Bool
forall k a b.
Ord k =>
(a -> b) -> [Char] -> k -> Map k a -> Either [Char] b
lookupAndApply Bond -> Bool
forall lb. Liable lb => lb -> Bool
isPaidOff [Char]
"Is Most Senior" [Char]
bn Map [Char] Bond
bndMap
        [Bool]
bns1 <- (Bond -> Bool)
-> [Char] -> [[Char]] -> Map [Char] Bond -> Either [Char] [Bool]
forall k a b.
Ord k =>
(a -> b) -> [Char] -> [k] -> Map k a -> Either [Char] [b]
lookupAndApplies Bond -> Bool
forall lb. Liable lb => lb -> Bool
isPaidOff [Char]
"Is Most Senior" [[Char]]
bns Map [Char] Bond
bndMap
        Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$
          case (Bool
bn1, [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [Bool]
bns1) of
            (Bool
False,Bool
True) -> Bool
True
            (Bool, Bool)
_ -> Bool
False

    IsPaidOff [[Char]]
bns -> 
      do 
        [Bool]
vs <- (Bond -> Bool)
-> [Char] -> [[Char]] -> Map [Char] Bond -> Either [Char] [Bool]
forall k a b.
Ord k =>
(a -> b) -> [Char] -> [k] -> Map k a -> Either [Char] [b]
lookupAndApplies Bond -> Bool
forall lb. Liable lb => lb -> Bool
isPaidOff [Char]
"Is Paid Off" [[Char]]
bns Map [Char] Bond
bndMap 
        Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [Bool]
vs -- `debug` ("bond paid off?"++ show vs)

    IsOutstanding [[Char]]
bns -> 
      do 
        [Bool]
vs <- (Bond -> Bool)
-> [Char] -> [[Char]] -> Map [Char] Bond -> Either [Char] [Bool]
forall k a b.
Ord k =>
(a -> b) -> [Char] -> [k] -> Map k a -> Either [Char] [b]
lookupAndApplies (Bool -> Bool
not (Bool -> Bool) -> (Bond -> Bool) -> Bond -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bond -> Bool
forall lb. Liable lb => lb -> Bool
isPaidOff) [Char]
"Is Outstanding" [[Char]]
bns Map [Char] Bond
bndMap
        Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [Bool]
vs 

    IsFeePaidOff [[Char]]
fns ->
      do 
        [Bool]
vs <- (Fee -> Bool)
-> [Char] -> [[Char]] -> Map [Char] Fee -> Either [Char] [Bool]
forall k a b.
Ord k =>
(a -> b) -> [Char] -> [k] -> Map k a -> Either [Char] [b]
lookupAndApplies Fee -> Bool
forall lb. Liable lb => lb -> Bool
isPaidOff [Char]
"Is Fee Paid Off" [[Char]]
fns Map [Char] Fee
feeMap
        Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [Bool]
vs
    
    IsLiqSupportPaidOff [[Char]]
lqNames ->
      do 
        [Bool]
lqs <- (LiqFacility -> Bool)
-> [Char]
-> [[Char]]
-> Map [Char] LiqFacility
-> Either [Char] [Bool]
forall k a b.
Ord k =>
(a -> b) -> [Char] -> [k] -> Map k a -> Either [Char] [b]
lookupAndApplies LiqFacility -> Bool
forall lb. Liable lb => lb -> Bool
isPaidOff [Char]
"Is Liq Support Paid Off" [[Char]]
lqNames (Map [Char] LiqFacility
-> Maybe (Map [Char] LiqFacility) -> Map [Char] LiqFacility
forall a. a -> Maybe a -> a
fromMaybe Map [Char] LiqFacility
forall k a. Map k a
Map.empty Maybe (Map [Char] LiqFacility)
liqProviderMap)
        Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [Bool]
lqs

    IsRateSwapPaidOff [[Char]]
rsNames ->
      do 
        [Bool]
rps <- (RateSwap -> Bool)
-> [Char]
-> [[Char]]
-> Map [Char] RateSwap
-> Either [Char] [Bool]
forall k a b.
Ord k =>
(a -> b) -> [Char] -> [k] -> Map k a -> Either [Char] [b]
lookupAndApplies RateSwap -> Bool
forall lb. Liable lb => lb -> Bool
isPaidOff [Char]
"Is Swap Paid Off" [[Char]]
rsNames (Map [Char] RateSwap
-> Maybe (Map [Char] RateSwap) -> Map [Char] RateSwap
forall a. a -> Maybe a -> a
fromMaybe Map [Char] RateSwap
forall k a. Map k a
Map.empty Maybe (Map [Char] RateSwap)
rateCapMap)
        Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [Bool]
rps
    
    TestRate DealStats
ds Cmp
cmp IRate
_r -> do
                            Rational
testRate <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
ds
                            let r :: Rational
r = Rational -> Rational
forall a. Real a => a -> Rational
toRational Rational
r
                            Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ case Cmp
cmp of 
                                       Cmp
G ->  Rational
testRate Rational -> Rational -> Bool
forall a. Ord a => a -> a -> Bool
> Rational
r
                                       Cmp
GE -> Rational
testRate Rational -> Rational -> Bool
forall a. Ord a => a -> a -> Bool
>= Rational
r
                                       Cmp
L ->  Rational
testRate Rational -> Rational -> Bool
forall a. Ord a => a -> a -> Bool
< Rational
r
                                       Cmp
LE -> Rational
testRate Rational -> Rational -> Bool
forall a. Ord a => a -> a -> Bool
<= Rational
r
                                       Cmp
E ->  Rational
testRate Rational -> Rational -> Bool
forall a. Eq a => a -> a -> Bool
== Rational
r
    
    HasPassedMaturity [[Char]]
bns -> do 
                               Map [Char] Bond
bMap <- [Char]
-> [[Char]] -> Map [Char] Bond -> Either [Char] (Map [Char] Bond)
forall k a.
(Show k, Ord k) =>
[Char] -> [k] -> Map k a -> Either [Char] (Map k a)
selectInMap [Char]
"Bond Pass Maturity" [[Char]]
bns Map [Char] Bond
bndMap
                               let oustandingBnds :: Map [Char] Bond
oustandingBnds = (Bond -> Bool) -> Map [Char] Bond -> Map [Char] Bond
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Bool -> Bool
not (Bool -> Bool) -> (Bond -> Bool) -> Bond -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bond -> Bool
forall lb. Liable lb => lb -> Bool
isPaidOff) Map [Char] Bond
bMap
                               Map [Char] Rational
ms <- Map [Char] (Either [Char] Rational)
-> Either [Char] (Map [Char] Rational)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a.
Applicative f =>
Map [Char] (f a) -> f (Map [Char] a)
sequenceA (Map [Char] (Either [Char] Rational)
 -> Either [Char] (Map [Char] Rational))
-> Map [Char] (Either [Char] Rational)
-> Either [Char] (Map [Char] Rational)
forall a b. (a -> b) -> a -> b
$ (\[Char]
bn -> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d ([Char] -> DealStats
MonthsTillMaturity [Char]
bn)) ([Char] -> Either [Char] Rational)
-> (Bond -> [Char]) -> Bond -> Either [Char] Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bond -> [Char]
L.bndName (Bond -> Either [Char] Rational)
-> Map [Char] Bond -> Map [Char] (Either [Char] Rational)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map [Char] Bond
oustandingBnds
                               Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ (Rational -> Bool) -> Map [Char] Rational -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Rational -> Rational -> Bool
forall a. Ord a => a -> a -> Bool
<= Rational
0) Map [Char] Rational
ms

    IsDealStatus DealStatus
st -> Bool -> Either [Char] Bool
forall a b. b -> Either a b
Right (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ TestDeal a -> DealStatus
forall a. TestDeal a -> DealStatus
status TestDeal a
t DealStatus -> DealStatus -> Bool
forall a. Eq a => a -> a -> Bool
== DealStatus
st


    DealStatBool DealStatFields
s -> 
      case TestDeal a
-> (BalDealStatMap, RDealStatMap, BDealStatMap, IDealStatMap)
forall a.
TestDeal a
-> (BalDealStatMap, RDealStatMap, BDealStatMap, IDealStatMap)
stats TestDeal a
t of 
        (BalDealStatMap
_,RDealStatMap
_,BDealStatMap
m,IDealStatMap
_) -> case DealStatFields -> BDealStatMap -> Maybe Bool
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup DealStatFields
s BDealStatMap
m of
                      Just Bool
v -> Bool -> Either [Char] Bool
forall a b. b -> Either a b
Right Bool
v
                      Maybe Bool
Nothing -> [Char] -> Either [Char] Bool
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Bool) -> [Char] -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to query bool deal stat of -> "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStatFields -> [Char]
forall a. Show a => a -> [Char]
show DealStatFields
s



    TestNot DealStats
ds -> do Bool -> Bool
not (Bool -> Bool) -> Either [Char] Bool -> Either [Char] Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> DealStats -> Date -> Either [Char] Bool
forall a.
Asset a =>
TestDeal a -> DealStats -> Date -> Either [Char] Bool
queryDealBool TestDeal a
t DealStats
ds Date
d)
    -- TestAny b dss -> b `elem` [ queryDealBool t ds d | ds <- dss ]
    TestAny Bool
b [DealStats]
dss -> (DealStats -> Either [Char] Bool)
-> [DealStats] -> Either [Char] Bool
forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
anyM (\ DealStats
x -> (Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
b) (Bool -> Bool) -> Either [Char] Bool -> Either [Char] Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> DealStats -> Date -> Either [Char] Bool
forall a.
Asset a =>
TestDeal a -> DealStats -> Date -> Either [Char] Bool
queryDealBool TestDeal a
t DealStats
x Date
d ) [DealStats]
dss
    TestAll Bool
b [DealStats]
dss -> (DealStats -> Either [Char] Bool)
-> [DealStats] -> Either [Char] Bool
forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
allM (\ DealStats
x -> (Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
b) (Bool -> Bool) -> Either [Char] Bool -> Either [Char] Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> DealStats -> Date -> Either [Char] Bool
forall a.
Asset a =>
TestDeal a -> DealStats -> Date -> Either [Char] Bool
queryDealBool TestDeal a
t DealStats
x Date
d ) [DealStats]
dss

    DealStats
_ -> [Char] -> Either [Char] Bool
forall a b. a -> Either a b
Left ([Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to query bool type formula"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
ds)

-- ^ test a condition with a deal and a date
testPre :: P.Asset a => Date -> TestDeal a -> Pre -> Either String Bool
testPre :: forall a.
Asset a =>
Date -> TestDeal a -> Pre -> Either [Char] Bool
testPre Date
d TestDeal a
t Pre
p =
  case Pre
p of
    Types.All [Pre]
pds -> (Pre -> Either [Char] Bool) -> [Pre] -> Either [Char] Bool
forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
allM (Date -> TestDeal a -> Pre -> Either [Char] Bool
forall a.
Asset a =>
Date -> TestDeal a -> Pre -> Either [Char] Bool
testPre Date
d TestDeal a
t) [Pre]
pds 
    -- Types.Any pds -> return $ any (testPre d t) pds 
    Types.Any [Pre]
pds -> (Pre -> Either [Char] Bool) -> [Pre] -> Either [Char] Bool
forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
anyM (Date -> TestDeal a -> Pre -> Either [Char] Bool
forall a.
Asset a =>
Date -> TestDeal a -> Pre -> Either [Char] Bool
testPre Date
d TestDeal a
t) [Pre]
pds 
    IfZero DealStats
s -> do 
                  Rational
q <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
s 
                  Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ (Rational -> Integer
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
q) Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0
    
    If Cmp
cmp DealStats
s Balance
amt -> do 
                      Rational
q <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s))
                      Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Cmp -> Rational -> Rational -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp Rational
q (Balance -> Rational
forall a. Real a => a -> Rational
toRational Balance
amt) -- `debug` (show d++"if cmp "++show (queryDeal t (ps s))++"amt"++show amt)
    IfRate Cmp
cmp DealStats
s IRate
amt -> do 
                          Rational
q <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s))
                          Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Cmp -> Rational -> Rational -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp Rational
q (IRate -> Rational
forall a. Real a => a -> Rational
toRational IRate
amt) -- `debug` (show d++"rate"++show (queryDealRate t (ps s))++"amt"++show amt)
    IfInt Cmp
cmp DealStats
s Int
amt -> do 
                         Rational
q <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s))
                         Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Cmp -> Rational -> Rational -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp Rational
q (Int -> Rational
forall a. Real a => a -> Rational
toRational Int
amt)
    
    -- Integer test
    IfIntIn DealStats
s [Int]
iset -> do 
                        Rational
q <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s))
                        Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
q) Int -> [Int] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Int]
iset
    IfIntBetween DealStats
s RangeType
rt Int
i1 Int
i2 ->
      do
        Rational
v <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s)
        case RangeType
rt of 
          RangeType
II -> Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
v) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
i1 Bool -> Bool -> Bool
&& (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
v) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
i2
          RangeType
IE -> Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
v) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
i1 Bool -> Bool -> Bool
&& (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
v) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
i2
          RangeType
EI -> Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
v) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
i1 Bool -> Bool -> Bool
&& (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
v) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
i2
          RangeType
EE -> Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
v) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
i1 Bool -> Bool -> Bool
&& (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
v) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
i2 
    -- IfIntBetween cmp1 s1 cmp2 s2 amt -> toCmp cmp1 (queryDealInt t (ps s1) d) amt && toCmp cmp2 (queryDealInt t (ps s2) d) amt
    IfDate Cmp
cmp Date
_d -> Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Cmp -> Date -> Date -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp Date
d Date
_d
    IfDateBetween RangeType
II Date
d1 Date
d2 -> Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Date
d Date -> Date -> Bool
forall a. Ord a => a -> a -> Bool
>= Date
d1 Bool -> Bool -> Bool
&& (Date
d Date -> Date -> Bool
forall a. Ord a => a -> a -> Bool
<= Date
d2)
    IfDateBetween RangeType
EI Date
d1 Date
d2 -> Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Date
d Date -> Date -> Bool
forall a. Ord a => a -> a -> Bool
> Date
d1 Bool -> Bool -> Bool
&& (Date
d Date -> Date -> Bool
forall a. Ord a => a -> a -> Bool
<= Date
d2)
    IfDateBetween RangeType
IE Date
d1 Date
d2 -> Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Date
d Date -> Date -> Bool
forall a. Ord a => a -> a -> Bool
>= Date
d1 Bool -> Bool -> Bool
&& (Date
d Date -> Date -> Bool
forall a. Ord a => a -> a -> Bool
< Date
d2)
    IfDateBetween RangeType
EE Date
d1 Date
d2 -> Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Date
d Date -> Date -> Bool
forall a. Ord a => a -> a -> Bool
> Date
d1 Bool -> Bool -> Bool
&& (Date
d Date -> Date -> Bool
forall a. Ord a => a -> a -> Bool
< Date
d2)
    IfDateIn [Date]
ds -> Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Date
d Date -> [Date] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Date]
ds

    IfCurve Cmp
cmp DealStats
s PlannedAmorSchedule
_ts -> do 
                           Rational
q <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s))
                           Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ Cmp -> Rational -> Rational -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp Rational
q (PlannedAmorSchedule -> CutoffType -> Date -> Rational
getValByDate PlannedAmorSchedule
_ts CutoffType
Inc Date
d)
    IfRateCurve Cmp
cmp DealStats
s PlannedAmorSchedule
_ts -> do Rational
v <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s))
                                Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ (Cmp -> Rational -> Rational -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp) Rational
v (PlannedAmorSchedule -> CutoffType -> Date -> Rational
getValByDate PlannedAmorSchedule
_ts CutoffType
Inc Date
d)
    IfByPeriodCurve Cmp
cmp DealStats
sVal DealStats
sSelect PerCurve Balance
pc -> 
      do 
        Rational
v <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
sVal)
        Rational
selector <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
sSelect)
        case PerCurve Balance
-> DateDirection -> CutoffType -> Int -> Maybe Balance
forall a.
PerCurve a -> DateDirection -> CutoffType -> Int -> Maybe a
getValFromPerCurve PerCurve Balance
pc DateDirection
Past CutoffType
Inc (Double -> Int
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
round (Double -> Int) -> Double -> Int
forall a b. (a -> b) -> a -> b
$ Rational -> Double
forall a. Fractional a => Rational -> a
fromRational Rational
selector) of 
          Maybe Balance
Nothing -> [Char] -> Either [Char] Bool
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Bool) -> [Char] -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to find value from period curve"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ PerCurve Balance -> [Char]
forall a. Show a => a -> [Char]
show PerCurve Balance
pc
          Just Balance
vFromCurve -> 
            Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ (Cmp -> Balance -> Balance -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp) (Rational -> Balance
forall a. Fractional a => Rational -> a
fromRational Rational
v) Balance
vFromCurve

    IfRateByPeriodCurve Cmp
cmp DealStats
sVal DealStats
sSelect PerCurve Rational
pc -> 
      do 
        Rational
v <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
sVal)
        Rational
selector <- TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
sSelect)
        case PerCurve Rational
-> DateDirection -> CutoffType -> Int -> Maybe Rational
forall a.
PerCurve a -> DateDirection -> CutoffType -> Int -> Maybe a
getValFromPerCurve PerCurve Rational
pc DateDirection
Past CutoffType
Inc (Double -> Int
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
round (Double -> Int) -> Double -> Int
forall a b. (a -> b) -> a -> b
$ Rational -> Double
forall a. Fractional a => Rational -> a
fromRational Rational
selector) of 
          Maybe Rational
Nothing -> [Char] -> Either [Char] Bool
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Bool) -> [Char] -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ [Char]
"Date:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"Failed to find value from period curve"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ PerCurve Rational -> [Char]
forall a. Show a => a -> [Char]
show PerCurve Rational
pc
          Just Rational
vFromCurve -> 
            Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ (Cmp -> Rational -> Rational -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp) (Rational -> Rational
forall a. Fractional a => Rational -> a
fromRational Rational
v) Rational
vFromCurve

    IfBool DealStats
s Bool
True -> TestDeal a -> DealStats -> Date -> Either [Char] Bool
forall a.
Asset a =>
TestDeal a -> DealStats -> Date -> Either [Char] Bool
queryDealBool TestDeal a
t DealStats
s Date
d
    IfBool DealStats
s Bool
False -> do 
                        Bool
q <- (TestDeal a -> DealStats -> Date -> Either [Char] Bool
forall a.
Asset a =>
TestDeal a -> DealStats -> Date -> Either [Char] Bool
queryDealBool TestDeal a
t DealStats
s Date
d)
                        Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
q
    If2 Cmp
cmp DealStats
s1 DealStats
s2 -> do 
                       Rational
q1 <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s1))
                       Rational
q2 <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s2))
                       Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cmp -> Rational -> Rational -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp Rational
q1 Rational
q2)  
    IfRate2 Cmp
cmp DealStats
s1 DealStats
s2 -> do 
                          Rational
q1 <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s1))
                          Rational
q2 <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s2))
                          Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cmp -> Rational -> Rational -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp Rational
q1 Rational
q2)  
    IfInt2 Cmp
cmp DealStats
s1 DealStats
s2 -> do 
                          Rational
q1 <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s1))
                          Rational
q2 <- (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
s2))
                          Bool -> Either [Char] Bool
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cmp -> Rational -> Rational -> Bool
forall {a}. Ord a => Cmp -> a -> a -> Bool
toCmp Cmp
cmp Rational
q1 Rational
q2)  
    IfDealStatus DealStatus
st -> Bool -> Either [Char] Bool
forall a b. b -> Either a b
Right (Bool -> Either [Char] Bool) -> Bool -> Either [Char] Bool
forall a b. (a -> b) -> a -> b
$ TestDeal a -> DealStatus
forall a. TestDeal a -> DealStatus
status TestDeal a
t DealStatus -> DealStatus -> Bool
forall a. Eq a => a -> a -> Bool
== DealStatus
st   --  `debug` ("current date"++show d++">> stutus"++show (status t )++"=="++show st)
    
    Always Bool
b -> Bool -> Either [Char] Bool
forall a b. b -> Either a b
Right Bool
b
    IfNot Pre
_p -> Bool -> Bool
not (Bool -> Bool) -> Either [Char] Bool -> Either [Char] Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Date -> TestDeal a -> Pre -> Either [Char] Bool
forall a.
Asset a =>
Date -> TestDeal a -> Pre -> Either [Char] Bool
testPre Date
d TestDeal a
t Pre
_p
    where 
      toCmp :: Cmp -> a -> a -> Bool
toCmp Cmp
x = case Cmp
x of 
                  Cmp
G -> a -> a -> Bool
forall a. Ord a => a -> a -> Bool
(>)
                  Cmp
GE -> a -> a -> Bool
forall a. Ord a => a -> a -> Bool
(>=)
                  Cmp
L -> a -> a -> Bool
forall a. Ord a => a -> a -> Bool
(<)
                  Cmp
LE -> a -> a -> Bool
forall a. Ord a => a -> a -> Bool
(<=)
                  Cmp
E -> a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)
      ps :: DealStats -> DealStats
ps = Date -> DealStats -> DealStats
patchDateToStats Date
d

-- ^ convert a condition to string in a deal context
preToStr :: P.Asset a => TestDeal a -> Date -> Pre -> String
preToStr :: forall a. Asset a => TestDeal a -> Date -> Pre -> [Char]
preToStr TestDeal a
t Date
d Pre
p =
  case Pre
p of 
    (IfZero DealStats
ds) ->  [Char]
"0 == " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds)))
    (If Cmp
cmp DealStats
ds Balance
bal) -> Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds))) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Cmp -> [Char]
forall a. Show a => a -> [Char]
show Cmp
cmp [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Balance -> [Char]
forall a. Show a => a -> [Char]
show Balance
bal
    (IfRate Cmp
cmp DealStats
ds IRate
r) -> Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds))) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Cmp -> [Char]
forall a. Show a => a -> [Char]
show Cmp
cmp [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++IRate -> [Char]
forall a. Show a => a -> [Char]
show IRate
r
    (IfInt Cmp
cmp DealStats
ds Int
r) -> Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds))) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Cmp -> [Char]
forall a. Show a => a -> [Char]
show Cmp
cmp [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Int -> [Char]
forall a. Show a => a -> [Char]
show Int
r
    (IfCurve Cmp
cmp DealStats
ds PlannedAmorSchedule
ts) -> Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds))) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Cmp -> [Char]
forall a. Show a => a -> [Char]
show Cmp
cmp [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (PlannedAmorSchedule -> CutoffType -> Date -> Rational
getValByDate PlannedAmorSchedule
ts CutoffType
Inc Date
d))
    (IfDate Cmp
cmp Date
_d) -> Date -> [Char]
forall a. Show a => a -> [Char]
show Date
d [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Cmp -> [Char]
forall a. Show a => a -> [Char]
show Cmp
cmp [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Date -> [Char]
forall a. Show a => a -> [Char]
show Date
_d
    (IfBool DealStats
ds Bool
b) -> Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d DealStats
ds)) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" == "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Bool -> [Char]
forall a. Show a => a -> [Char]
show Bool
b
    (If2 Cmp
cmp DealStats
ds1 DealStats
ds2) -> Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds1))) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Cmp -> [Char]
forall a. Show a => a -> [Char]
show Cmp
cmp [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds2)))
    (IfRate2 Cmp
cmp DealStats
ds1 DealStats
ds2) -> Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds1))) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Cmp -> [Char]
forall a. Show a => a -> [Char]
show Cmp
cmp [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds2)))
    (IfInt2 Cmp
cmp DealStats
ds1 DealStats
ds2) -> Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds1))) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Cmp -> [Char]
forall a. Show a => a -> [Char]
show Cmp
cmp [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds2)))
    (IfDealStatus DealStatus
st) -> DealStatus -> [Char]
forall a. Show a => a -> [Char]
show (TestDeal a -> DealStatus
forall a. TestDeal a -> DealStatus
status TestDeal a
t) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" == "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStatus -> [Char]
forall a. Show a => a -> [Char]
show DealStatus
st
    (IfByPeriodCurve Cmp
cmp DealStats
ds1 DealStats
ds2 PerCurve Balance
pc) 
      -> let 
            v :: Either [Char] Double
v = (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds1))
          in 
            case (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds2)) of
              Left [Char]
_error -> [Char]
"Failed to read selector for period curve"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
ds2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"Error:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
_error
              Right Double
s -> 
                let
                  c :: Maybe Balance
c = PerCurve Balance
-> DateDirection -> CutoffType -> Int -> Maybe Balance
forall a.
PerCurve a -> DateDirection -> CutoffType -> Int -> Maybe a
getValFromPerCurve PerCurve Balance
pc DateDirection
Past CutoffType
Inc (Double -> Int
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Double
s) 
                in 
                  Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show Either [Char] Double
v [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Cmp -> [Char]
forall a. Show a => a -> [Char]
show Cmp
cmp [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Maybe Balance -> [Char]
forall a. Show a => a -> [Char]
show Maybe Balance
c
    (IfRateByPeriodCurve Cmp
cmp DealStats
ds1 DealStats
ds2 PerCurve Rational
pc) 
      -> let 
            v :: Either [Char] Double
v = (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double)
-> Either [Char] Rational -> Either [Char] Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds1))
          in 
            case TestDeal a -> Date -> DealStats -> Either [Char] Rational
forall a.
Asset a =>
TestDeal a -> Date -> DealStats -> Either [Char] Rational
queryCompound TestDeal a
t Date
d (DealStats -> DealStats
ps DealStats
ds2) of
              Left [Char]
_error -> [Char]
"Failed to read selector for period curve"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DealStats -> [Char]
forall a. Show a => a -> [Char]
show DealStats
ds2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"Error:"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
_error
              Right Rational
s -> 
                let
                  c :: Maybe Rational
c = PerCurve Rational
-> DateDirection -> CutoffType -> Int -> Maybe Rational
forall a.
PerCurve a -> DateDirection -> CutoffType -> Int -> Maybe a
getValFromPerCurve PerCurve Rational
pc DateDirection
Past CutoffType
Inc (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Rational
s) 
                in 
                  Either [Char] Double -> [Char]
forall a. Show a => a -> [Char]
show Either [Char] Double
v [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Cmp -> [Char]
forall a. Show a => a -> [Char]
show Cmp
cmp [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++Maybe Double -> [Char]
forall a. Show a => a -> [Char]
show (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational -> Double) -> Maybe Rational -> Maybe Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Rational
c)
    (Always Bool
b) -> Bool -> [Char]
forall a. Show a => a -> [Char]
show Bool
b
    (IfNot Pre
_p) -> [Char]
"Not "[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ TestDeal a -> Date -> Pre -> [Char]
forall a. Asset a => TestDeal a -> Date -> Pre -> [Char]
preToStr TestDeal a
t Date
d Pre
_p
    (Types.All [Pre]
pds) -> [Char]
"All:["[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"|" ((Pre -> [Char]) -> [Pre] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map (TestDeal a -> Date -> Pre -> [Char]
forall a. Asset a => TestDeal a -> Date -> Pre -> [Char]
preToStr TestDeal a
t Date
d) [Pre]
pds)[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"]"
    (Types.Any [Pre]
pds) -> [Char]
"Any:["[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"|" ((Pre -> [Char]) -> [Pre] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map (TestDeal a -> Date -> Pre -> [Char]
forall a. Asset a => TestDeal a -> Date -> Pre -> [Char]
preToStr TestDeal a
t Date
d) [Pre]
pds)[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
"]"
    Pre
_ -> [Char]
"Failed to read condition"[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Pre -> [Char]
forall a. Show a => a -> [Char]
show Pre
p

  where 
    ps :: DealStats -> DealStats
ps = Date -> DealStats -> DealStats
patchDateToStats Date
d

testPre2 :: P.Asset a => Date -> TestDeal a -> Pre -> (String, Either String Bool)
testPre2 :: forall a.
Asset a =>
Date -> TestDeal a -> Pre -> ([Char], Either [Char] Bool)
testPre2 Date
d TestDeal a
t Pre
p = (TestDeal a -> Date -> Pre -> [Char]
forall a. Asset a => TestDeal a -> Date -> Pre -> [Char]
preToStr TestDeal a
t Date
d Pre
p, Date -> TestDeal a -> Pre -> Either [Char] Bool
forall a.
Asset a =>
Date -> TestDeal a -> Pre -> Either [Char] Bool
testPre Date
d TestDeal a
t Pre
p)