{-# 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
-}