{-|

Various options to use when reading journal files.
Similar to CliOptions.inputflags, simplifies the journal-reading functions.

-}
{-# LANGUAGE TemplateHaskell #-}

module Hledger.Read.InputOptions (
-- * Types and helpers for input options
  InputOpts(..)
, HasInputOpts(..)
, definputopts
, forecastPeriod
) where

import Control.Applicative ((<|>))
import Data.Time (Day, addDays)

import Hledger.Data.Types
import Hledger.Data.Journal (journalEndDate)
import Hledger.Data.Dates (nulldate, nulldatespan)
import Hledger.Data.Balancing (BalancingOpts(..), HasBalancingOpts(..), defbalancingopts)
import Hledger.Utils (dbg2, makeHledgerClassyLenses)

data InputOpts = InputOpts {
     -- files_             :: [FilePath]
     InputOpts -> Maybe StorageFormat
mformat_           :: Maybe StorageFormat  -- ^ a file/storage format to try, unless overridden
                                                --   by a filename prefix. Nothing means try all.
    ,InputOpts -> Maybe FilePath
mrules_file_       :: Maybe FilePath       -- ^ a conversion rules file to use (when reading CSV)
    ,InputOpts -> [FilePath]
aliases_           :: [String]             -- ^ account name aliases to apply
    ,InputOpts -> Bool
anon_              :: Bool                 -- ^ do light obfuscation of the data ? Now corresponds to --obfuscate, not the old --anon flag.
    ,InputOpts -> Bool
new_               :: Bool                 -- ^ read only new transactions since this file was last read ?
    ,InputOpts -> Bool
new_save_          :: Bool                 -- ^ save latest new transactions state for next time ?
    ,InputOpts -> FilePath
pivot_             :: String               -- ^ use the given field's value as the account name
    ,InputOpts -> Maybe DateSpan
forecast_          :: Maybe DateSpan       -- ^ span in which to generate forecast transactions
    ,InputOpts -> Bool
posting_account_tags_  :: Bool             -- ^ propagate account tags to postings ?
    ,InputOpts -> Bool
verbose_tags_      :: Bool                 -- ^ add user-visible tags when generating/modifying transactions & postings ?
    ,InputOpts -> DateSpan
reportspan_        :: DateSpan             -- ^ a dirty hack keeping the query dates in InputOpts. This rightfully lives in ReportSpec, but is duplicated here.
    ,InputOpts -> Bool
auto_              :: Bool                 -- ^ generate extra postings according to auto posting rules ?
    ,InputOpts -> Bool
infer_equity_      :: Bool                 -- ^ infer equity conversion postings from costs ?
    ,InputOpts -> Bool
infer_costs_       :: Bool                 -- ^ infer costs from equity conversion postings ? distinct from BalancingOpts{infer_balancing_costs_}
    ,InputOpts -> BalancingOpts
balancingopts_     :: BalancingOpts        -- ^ options for transaction balancing
    ,InputOpts -> Bool
strict_            :: Bool                 -- ^ do extra correctness checks ?
    ,InputOpts -> Bool
_defer             :: Bool                 -- ^ internal flag: postpone checks, because we are processing multiple files ?
    ,InputOpts -> Day
_ioDay             :: Day                  -- ^ today's date, for use with forecast transactions  XXX this duplicates _rsDay, and should eventually be removed when it's not needed anymore.
 } deriving (InputOpts -> InputOpts -> Bool
(InputOpts -> InputOpts -> Bool)
-> (InputOpts -> InputOpts -> Bool) -> Eq InputOpts
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InputOpts -> InputOpts -> Bool
== :: InputOpts -> InputOpts -> Bool
$c/= :: InputOpts -> InputOpts -> Bool
/= :: InputOpts -> InputOpts -> Bool
Eq, Eq InputOpts
Eq InputOpts =>
(InputOpts -> InputOpts -> Ordering)
-> (InputOpts -> InputOpts -> Bool)
-> (InputOpts -> InputOpts -> Bool)
-> (InputOpts -> InputOpts -> Bool)
-> (InputOpts -> InputOpts -> Bool)
-> (InputOpts -> InputOpts -> InputOpts)
-> (InputOpts -> InputOpts -> InputOpts)
-> Ord InputOpts
InputOpts -> InputOpts -> Bool
InputOpts -> InputOpts -> Ordering
InputOpts -> InputOpts -> InputOpts
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InputOpts -> InputOpts -> Ordering
compare :: InputOpts -> InputOpts -> Ordering
$c< :: InputOpts -> InputOpts -> Bool
< :: InputOpts -> InputOpts -> Bool
$c<= :: InputOpts -> InputOpts -> Bool
<= :: InputOpts -> InputOpts -> Bool
$c> :: InputOpts -> InputOpts -> Bool
> :: InputOpts -> InputOpts -> Bool
$c>= :: InputOpts -> InputOpts -> Bool
>= :: InputOpts -> InputOpts -> Bool
$cmax :: InputOpts -> InputOpts -> InputOpts
max :: InputOpts -> InputOpts -> InputOpts
$cmin :: InputOpts -> InputOpts -> InputOpts
min :: InputOpts -> InputOpts -> InputOpts
Ord, Int -> InputOpts -> ShowS
[InputOpts] -> ShowS
InputOpts -> FilePath
(Int -> InputOpts -> ShowS)
-> (InputOpts -> FilePath)
-> ([InputOpts] -> ShowS)
-> Show InputOpts
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InputOpts -> ShowS
showsPrec :: Int -> InputOpts -> ShowS
$cshow :: InputOpts -> FilePath
show :: InputOpts -> FilePath
$cshowList :: [InputOpts] -> ShowS
showList :: [InputOpts] -> ShowS
Show)

definputopts :: InputOpts
definputopts :: InputOpts
definputopts = InputOpts
    { mformat_ :: Maybe StorageFormat
mformat_           = Maybe StorageFormat
forall a. Maybe a
Nothing
    , mrules_file_ :: Maybe FilePath
mrules_file_       = Maybe FilePath
forall a. Maybe a
Nothing
    , aliases_ :: [FilePath]
aliases_           = []
    , anon_ :: Bool
anon_              = Bool
False
    , new_ :: Bool
new_               = Bool
False
    , new_save_ :: Bool
new_save_          = Bool
True
    , pivot_ :: FilePath
pivot_             = FilePath
""
    , forecast_ :: Maybe DateSpan
forecast_          = Maybe DateSpan
forall a. Maybe a
Nothing
    , posting_account_tags_ :: Bool
posting_account_tags_ = Bool
False
    , verbose_tags_ :: Bool
verbose_tags_      = Bool
False
    , reportspan_ :: DateSpan
reportspan_        = DateSpan
nulldatespan
    , auto_ :: Bool
auto_              = Bool
False
    , infer_equity_ :: Bool
infer_equity_      = Bool
False
    , infer_costs_ :: Bool
infer_costs_       = Bool
False
    , balancingopts_ :: BalancingOpts
balancingopts_     = BalancingOpts
defbalancingopts
    , strict_ :: Bool
strict_            = Bool
False
    , _defer :: Bool
_defer             = Bool
False
    , _ioDay :: Day
_ioDay             = Day
nulldate
    }

-- | Get the Maybe the DateSpan to generate forecast options from.
-- This begins on:
-- - the start date supplied to the `--forecast` argument, if present
-- - otherwise, the later of
--   - the report start date if specified with -b/-p/date:
--   - the day after the latest normal (non-periodic) transaction in the journal, if any
-- - otherwise today.
-- It ends on:
-- - the end date supplied to the `--forecast` argument, if present
-- - otherwise the report end date if specified with -e/-p/date:
-- - otherwise 180 days (6 months) from today.
forecastPeriod :: InputOpts -> Journal -> Maybe DateSpan
forecastPeriod :: InputOpts -> Journal -> Maybe DateSpan
forecastPeriod InputOpts
iopts Journal
j = do
    DateSpan Maybe EFDay
requestedStart Maybe EFDay
requestedEnd <- InputOpts -> Maybe DateSpan
forecast_ InputOpts
iopts
    let forecastStart :: Maybe Day
forecastStart = EFDay -> Day
fromEFDay (EFDay -> Day) -> Maybe EFDay -> Maybe Day
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe EFDay
requestedStart Maybe Day -> Maybe Day -> Maybe Day
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Day -> Maybe Day -> Maybe Day
forall a. Ord a => a -> a -> a
max Maybe Day
mjournalend (EFDay -> Day
fromEFDay (EFDay -> Day) -> Maybe EFDay -> Maybe Day
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe EFDay
reportStart) Maybe Day -> Maybe Day -> Maybe Day
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Day -> Maybe Day
forall a. a -> Maybe a
Just (InputOpts -> Day
_ioDay InputOpts
iopts)
        forecastEnd :: Maybe Day
forecastEnd   = EFDay -> Day
fromEFDay (EFDay -> Day) -> Maybe EFDay -> Maybe Day
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe EFDay
requestedEnd Maybe Day -> Maybe Day -> Maybe Day
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> EFDay -> Day
fromEFDay (EFDay -> Day) -> Maybe EFDay -> Maybe Day
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe EFDay
reportEnd Maybe Day -> Maybe Day -> Maybe Day
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Day -> Maybe Day
forall a. a -> Maybe a
Just (Day -> Maybe Day) -> Day -> Maybe Day
forall a b. (a -> b) -> a -> b
$ Integer -> Day -> Day
addDays Integer
180 (Day -> Day) -> Day -> Day
forall a b. (a -> b) -> a -> b
$ InputOpts -> Day
_ioDay InputOpts
iopts)
        mjournalend :: Maybe Day
mjournalend   = FilePath -> Maybe Day -> Maybe Day
forall a. Show a => FilePath -> a -> a
dbg2 FilePath
"journalEndDate" (Maybe Day -> Maybe Day) -> Maybe Day -> Maybe Day
forall a b. (a -> b) -> a -> b
$ Bool -> Journal -> Maybe Day
journalEndDate Bool
False Journal
j  -- ignore secondary dates
        DateSpan Maybe EFDay
reportStart Maybe EFDay
reportEnd = InputOpts -> DateSpan
reportspan_ InputOpts
iopts
    DateSpan -> Maybe DateSpan
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return (DateSpan -> Maybe DateSpan)
-> (DateSpan -> DateSpan) -> DateSpan -> Maybe DateSpan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> DateSpan -> DateSpan
forall a. Show a => FilePath -> a -> a
dbg2 FilePath
"forecastspan" (DateSpan -> Maybe DateSpan) -> DateSpan -> Maybe DateSpan
forall a b. (a -> b) -> a -> b
$ Maybe EFDay -> Maybe EFDay -> DateSpan
DateSpan (Day -> EFDay
Exact (Day -> EFDay) -> Maybe Day -> Maybe EFDay
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Day
forecastStart) (Day -> EFDay
Exact (Day -> EFDay) -> Maybe Day -> Maybe EFDay
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Day
forecastEnd)

-- ** Lenses

makeHledgerClassyLenses ''InputOpts

instance HasBalancingOpts InputOpts where
    balancingOpts :: Lens' InputOpts BalancingOpts
balancingOpts = (BalancingOpts -> f BalancingOpts) -> InputOpts -> f InputOpts
forall c. HasInputOpts c => Lens' c BalancingOpts
Lens' InputOpts BalancingOpts
balancingopts