{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveDataTypeable #-}
module Hcompta.Chart where

import           Data.Data (Data)
import           Data.Eq (Eq(..))
import           Data.Functor (Functor(..))
import           Data.List (concat)
import           Data.List.NonEmpty (NonEmpty(..))
import qualified Data.Map.Strict as Data.Map
import           Data.Monoid (Monoid(..))
import           Data.Typeable (Typeable)
import           Text.Show (Show(..))
import           Prelude (($))

import           Hcompta.Account (Account)
import qualified Hcompta.Account as Account
import           Hcompta.Lib.TreeMap (TreeMap)
import qualified Hcompta.Lib.TreeMap as TreeMap
import           Hcompta.Tag (Tag)
import qualified Hcompta.Tag as Tag

data Chart =
 Chart
 { chart_accounts :: !(TreeMap Account.Account_Section Tag.Tags)
 , chart_tags     :: !(TreeMap Tag.Section [Account])
 }
 deriving (Data, Eq, Show, Typeable)

instance Monoid Chart where
	mempty =
		Chart
		 { chart_accounts = mempty
		 , chart_tags     = mempty
		 }
	mappend x y =
		Chart
		 { chart_accounts = chart_accounts x `mappend` chart_accounts y
		 , chart_tags     = chart_tags     x `mappend` chart_tags     y
		 }

-- | Return the 'Tag.Tags' associated with
--   the given 'Account.Account_Path'
--   in the given 'Chart'.
account_tags :: Account.Account_Path -> Chart -> Tag.Tags
account_tags acct chart =
	Tag.Tags $ Data.Map.unionsWith mappend $
	fmap Tag.unTags $
	TreeMap.find_along acct $
	chart_accounts chart

-- | Return the 'Account's associated with
--   the given 'Tag'
--   in the given 'Chart'.
tag_accounts :: Tag -> Chart -> [Account]
tag_accounts (p:|ps, value) chart =
	concat $
	TreeMap.find_along (p:|ps `mappend` [value]) $
	chart_tags chart