{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Hdoc.DTC.Check.Base where

import Data.Default.Class (Default(..))
import Data.Eq (Eq(..))
import Data.IntMap.Strict (IntMap)
import Data.Map.Strict (Map)
import Data.Maybe (Maybe(..))
import Data.Sequence (Seq)
import Data.Traversable (Traversable(..))
import Text.Show (Show)
import qualified Control.Monad.Trans.State as S
import qualified Data.HashMap.Strict as HM
import qualified Data.TreeMap.Strict as TreeMap

import Hdoc.DTC.Document
import Hdoc.DTC.Index
import Hdoc.DTC.Collect
import qualified Hdoc.TCT.Cell as TCT
import qualified Hdoc.XML as XML

-- * Type 'State'
data State = State
 { state_section :: Maybe Section -- RO
 , state_irefs   :: Irefs
 , state_rrefs   :: HM.HashMap Ident [(Maybe Section, Nat1)]
 -- , state_tags    :: AnchorByIdent
 , state_notes   :: NotesBySection
 , state_note    :: Nat1
 , state_errors  :: Errors
 , state_collect :: All
 }
instance Default State where
	def = State
	 { state_section = def
	 , state_irefs   = TreeMap.empty
	 , state_rrefs   = def
	 -- , state_tags    = def
	 , state_notes   = def
	 , state_note    = def
	 , state_errors  = def
	 , state_collect = def
	 }

-- ** Type 'AnchorByIdent'
type AnchorByIdent = HM.HashMap Ident [Anchor]

-- ** Type 'Notes'
type Notes = IntMap [Para]

-- *** Type 'NotesBySection'
type NotesBySection = Map XML.Ancestors Notes

-- * Type 'Errors'
data Errors = Errors
 { errors_tag_unknown                :: HM.HashMap Title  (Seq TCT.Location)
 , errors_tag_ambiguous              :: HM.HashMap Title  (Seq TCT.Location)
 , errors_rref_unknown               :: HM.HashMap Ident  (Seq TCT.Location)
 , errors_reference_ambiguous        :: HM.HashMap Ident  (Seq TCT.Location)
 , errors_judgment_judges_unknown    :: HM.HashMap Ident  (Seq (TCT.Location, XML.Pos))
 , errors_judgment_grades_unknown    :: HM.HashMap Ident  (Seq (TCT.Location, XML.Pos))
 , errors_judgment_grades_duplicated :: HM.HashMap Ident  (Seq (TCT.Location, XML.Pos))
 , errors_judgment_judge_unknown     :: HM.HashMap Name   (Seq (TCT.Location, XML.Pos))
 , errors_judgment_judge_duplicated  :: HM.HashMap Name   (Seq (TCT.Location, XML.Pos))
 , errors_judgment_grade_unknown     :: HM.HashMap Name   (Seq (TCT.Location, XML.Pos))
 , errors_judgment_choice_duplicated :: HM.HashMap Title  (Seq (TCT.Location, XML.Pos))
 } deriving (Eq,Show)
instance Default Errors where
	def = Errors
	 { errors_tag_unknown                = def
	 , errors_tag_ambiguous              = def
	 , errors_rref_unknown               = def
	 , errors_reference_ambiguous        = def
	 , errors_judgment_judges_unknown    = def
	 , errors_judgment_judge_unknown     = def
	 , errors_judgment_judge_duplicated  = def
	 , errors_judgment_grades_unknown    = def
	 , errors_judgment_grades_duplicated = def
	 , errors_judgment_grade_unknown     = def
	 , errors_judgment_choice_duplicated = def
	 }

-- * Class 'Check'
class Check a where
	check :: a -> S.State State a
instance Check a => Check (Maybe a) where
	check = traverse check