{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
-- | Symantic for 'Journal'.
module Hcompta.LCC.Sym.Journal where

import Data.Function (($), (.))
import qualified Prelude ()
import Data.Typeable (Typeable)

import Hcompta.LCC.IO (PathFile(..))
import Hcompta.LCC.Chart (Chart)
import Hcompta.LCC.Journal (Journal)
import Hcompta.LCC.Posting (Date)
import Hcompta.LCC.Sym.Chart (tyChart)
import Hcompta.LCC.Sym.Date (tyDate)
import Hcompta.LCC.Sym.FileSystem (tyPathFile)
import qualified Hcompta.LCC.Journal as LCC

import Language.Symantic
import Language.Symantic.Lib (a0)

-- * Class 'Sym_Journal'
type instance Sym (Journal sou) = Sym_Journal
class Sym_Journal term where
	journal                :: Journal sou j -> term (Journal sou j)
	journal_file           :: term (Journal sou j) -> term PathFile
	journal_last_read_time :: term (Journal sou j) -> term Date
	journal_chart          :: term (Journal sou j) -> term Chart
	journal_content        :: term (Journal sou j) -> term j
	default journal                :: Sym_Journal (UnT term) => Trans term => Journal sou j -> term (Journal sou j)
	default journal_file           :: Sym_Journal (UnT term) => Trans term => term (Journal sou j) -> term PathFile
	default journal_last_read_time :: Sym_Journal (UnT term) => Trans term => term (Journal sou j) -> term Date
	default journal_chart          :: Sym_Journal (UnT term) => Trans term => term (Journal sou j) -> term Chart
	default journal_content        :: Sym_Journal (UnT term) => Trans term => term (Journal sou j) -> term j
	journal                = trans . journal
	journal_file           = trans1 journal_file
	journal_last_read_time = trans1 journal_last_read_time
	journal_chart          = trans1 journal_chart
	journal_content        = trans1 journal_content

instance Sym_Journal Eval where
	journal                = Eval
	journal_file           = eval1 LCC.journal_file
	journal_last_read_time = eval1 LCC.journal_last_read_time
	journal_chart          = eval1 LCC.journal_chart
	journal_content        = eval1 LCC.journal_content
instance Sym_Journal View where
	journal _              = View $ \_v _p -> "Journal.journal"
	journal_file           = view1 "Journal.file"
	journal_last_read_time = view1 "Journal.last_read_time"
	journal_chart          = view1 "Journal.chart"
	journal_content        = view1 "Journal.content"
instance (Sym_Journal r1, Sym_Journal r2) => Sym_Journal (Dup r1 r2) where
	journal j              = journal j `Dup` journal j
	journal_file           = dup1 @Sym_Journal journal_file
	journal_last_read_time = dup1 @Sym_Journal journal_last_read_time
	journal_chart          = dup1 @Sym_Journal journal_chart
	journal_content        = dup1 @Sym_Journal journal_content
instance (Sym_Journal term, Sym_Lambda term) => Sym_Journal (BetaT term)

instance Typeable sou => NameTyOf (Journal sou) where
	nameTyOf _c = ["Journal"] `Mod` "Journal"
instance FixityOf (Journal sou)
instance Typeable sou => ClassInstancesFor (Journal sou) where
instance TypeInstancesFor (Journal src)

instance Gram_Term_AtomsFor src ss g (Journal sou)
instance (Typeable sou, Source src, SymInj ss (Journal sou)) => ModuleFor src ss (Journal sou) where
	moduleFor = ["Journal"] `moduleWhere`
	 [ "file"           := teJournal_file @sou
	 , "last_read_time" := teJournal_last_read_time @sou
	 , "chart"          := teJournal_chart @sou
	 , "content"        := teJournal_content @sou
	 ]

tyJournal :: forall sou src vs a. Typeable sou => Source src => LenInj vs => Type src vs a -> Type src vs (Journal sou a)
tyJournal a = tyConstLen @(K (Journal sou)) @(Journal sou) (lenVars a) `tyApp` a

teJournal :: forall sou src ss ts a. Typeable sou => Source src => SymInj ss (Journal sou) => Journal sou a -> Term src ss ts '[Proxy a] (() #> Journal sou a)
teJournal j = Term noConstraint (tyJournal a0) $ teSym @(Journal sou) $ journal j

teJournal_file :: forall sou src ss ts a. Typeable sou => Source src => SymInj ss (Journal sou) => Term src ss ts '[Proxy a] (() #> (Journal sou a -> PathFile))
teJournal_file = Term noConstraint (tyJournal a0 ~> tyPathFile) $ teSym @(Journal sou) $ lam1 journal_file

teJournal_last_read_time :: forall sou src ss ts a. Typeable sou => Source src => SymInj ss (Journal sou) => Term src ss ts '[Proxy a] (() #> (Journal sou a -> Date))
teJournal_last_read_time = Term noConstraint (tyJournal a0 ~> tyDate) $ teSym @(Journal sou) $ lam1 journal_last_read_time

teJournal_chart :: forall sou src ss ts a. Typeable sou => Source src => SymInj ss (Journal sou) => Term src ss ts '[Proxy a] (() #> (Journal sou a -> Chart))
teJournal_chart = Term noConstraint (tyJournal a0 ~> tyChart) $ teSym @(Journal sou) $ lam1 journal_chart

teJournal_content :: forall sou src ss ts a. Typeable sou => Source src => SymInj ss (Journal sou) => Term src ss ts '[Proxy a] (() #> (Journal sou a -> a))
teJournal_content = Term noConstraint (tyJournal a0 ~> a0) $ teSym @(Journal sou) $ lam1 journal_content