{-# LANGUAGE NamedFieldPuns #-}
module Hcompta.CLI.Format.Ledger where

import           Control.Exception (tryJust)
import           Control.Monad (guard)
import qualified Data.Map.Strict as Data.Map
import qualified Data.Text.Lazy as TL
import           System.Environment as Env (getEnv)
import qualified System.IO as IO
import           System.IO.Error (isDoesNotExistError)

import qualified Hcompta.Calc.Balance as Balance
import qualified Hcompta.CLI.Context as Context
import qualified Hcompta.CLI.Write as Write
import qualified Hcompta.Format.Ledger as Ledger
import qualified Hcompta.Format.Ledger.Balance as Ledger.Balance
import qualified Hcompta.Format.Ledger.Journal as Ledger.Journal
import qualified Hcompta.Format.Ledger.Write as Ledger.Write
import qualified Hcompta.Lib.Foldable as Lib.Foldable
import qualified Hcompta.Model.Transaction as Transaction

-- | Return 'FilePath's containing 'Hcompta.Format.Ledger.Journal's:
--
-- * either those given if any,
-- * or the one in LEDGER_FILE environment variable if any,
-- * or the one in LEDGER environment variable if any.
paths :: Context.Context -> [FilePath] -> IO [FilePath]
paths context [] = do
	tryJust (guard . isDoesNotExistError) $ Env.getEnv "LEDGER_FILE"
	>>= \x -> case x of
	 Right ok -> return [ok]
	 Left  _ko -> do
		tryJust (guard . isDoesNotExistError) $ Env.getEnv "LEDGER"
		>>= \xx -> case xx of
		 Right ok -> return [ok]
		 Left  _ko -> Write.fatal context $ concat
			 [ "no ledger file given, please use:"
			 , "\n - either -i FILE parameter,"
			 , "\n - or LEDGER_FILE environment variable."
			 ]
paths _context ps = return ps

equilibre :: Context.Context -> [Ledger.Journal] -> IO ()
equilibre context journals =
	case Lib.Foldable.find Ledger.Balance.equilibre journals of
	 Nothing -> return ()
	 Just ((tr, eq), path) -> do
		with_color <- Write.with_color context IO.stdout
		Write.fatal context $ concat
		 [ "the following transaction is not equilibrated, because:"
		 , case eq of
			 Balance.Equilibre e | not $ Balance.is_equilibrable eq ->
				concat $ Data.Map.elems $ Data.Map.mapWithKey
				 (\unit Balance.Unit_Sum{Balance.amount} -> concat
					[ "\n- unit \""
					, TL.unpack $ Ledger.Write.show with_color $ Ledger.Write.unit unit
					, "\" sums up to the non-null amount: "
					, TL.unpack $ Ledger.Write.show with_color $ Ledger.Write.amount amount
					])
				 e
			 _ -> ""
		 , "\nin ", show $ Transaction.sourcepos tr
		 , concat $ map (\j -> "\nincluded by \"" ++ Ledger.Journal.file j ++ "\"") path
		 , ":\n", TL.unpack $ Ledger.Write.show with_color $
			Ledger.Write.transaction tr
		 ]