-----------------------------------------------------------------------------
-- Copyright 2020, Ideas project team. This file is distributed under the
-- terms of the Apache License 2.0. For more information, see the files
-- "LICENSE.txt" and "NOTICE.txt", which are included in the distribution.
-----------------------------------------------------------------------------
{- Implements symbols for the statistics domain. The only symbols that are
 - re-used are the true and the false symbols from the Logic1 module.
 -}
module Domain.Statistics.Symbols
  ( -- cChoiceSymbol
    cConstSymbol
  , cDataSymbol
  , componentSymbol
  -- , conclusionSymbol
  , derivedSymbol
  , falseSymbol
  , initialSymbol
  , leftSidedSymbol
  , rightSidedSymbol
  -- , sidedSymbol
  , singleSampleSymbol
  , tTestOneSymbol
  , tTestPairedSymbol
  , tTestTwoSymbol
  , rPearsonSymbol
  , anovaSymbol
  , chiSquaredSymbol
  , dependentSymbol, independentSymbol
  -- , testTypeSymbol
  , toOMSymbol
  , trueSymbol
  , twoSampleSymbol
  , twoSidedSymbol
  , zTestSymbol
  , rejectH0Symbol, acceptH0Symbol, dontRejectH0Symbol, rejectH1Symbol
  , acceptH1Symbol, dontRejectH1Symbol
  , toTermBool, fromTermBool
  ) where

import Ideas.Common.Rewriting.Term hiding (trueSymbol, falseSymbol)
import qualified Ideas.Text.OpenMath.Dictionary.Logic1 as L
import Ideas.Common.Id
import qualified Ideas.Text.OpenMath.Symbol as OM

componentSymbol :: Symbol
componentSymbol = newSymbol "stats.component"

-- cChoiceSymbol         -- component data symbol
cConstSymbol          -- component expression symbol, filtered in OM output
 , cDataSymbol        -- component relation symbol, filtered in OM output
-- , conclusionSymbol   -- All of these symbols up to intialSymbol are tied to a
 , derivedSymbol      --  constructor from Domain.Statistics.ComponentSet
 , initialSymbol      --
 , leftSidedSymbol    --
 , rightSidedSymbol   --
-- , sidedSymbol        --
 , singleSampleSymbol --
 , tTestOneSymbol     --
 , tTestPairedSymbol  --
 , tTestTwoSymbol     -- when the step is in the initial set
-- , testTypeSymbol     -- when the step is derived
 , twoSampleSymbol
 , twoSidedSymbol
 , zTestSymbol
 , rPearsonSymbol
 , anovaSymbol
 , chiSquaredSymbol
 , dependentSymbol
 , independentSymbol :: Symbol

cDataSymbol        = newSymbol "stats.cdata"
-- cChoiceSymbol      = newSymbol "stats.cchoice"
cConstSymbol       = newSymbol "stats.cconst"

--testTypeSymbol     = newSymbol "stats.testtype"
--sidedSymbol        = newSymbol "stats.sided"
--conclusionSymbol   = newSymbol "stats.conclusion"

tTestOneSymbol     = newSymbol "stats.ttestone"
tTestTwoSymbol     = newSymbol "stats.ttesttwo"
tTestPairedSymbol  = newSymbol "stats.ttestpaired"
zTestSymbol        = newSymbol "stats.ztest"
rPearsonSymbol     = newSymbol "stats.rpearson"
anovaSymbol        = newSymbol "stats.anova"
chiSquaredSymbol   = newSymbol "stats.chisquared"

twoSidedSymbol     = newSymbol "stats.twosided"
leftSidedSymbol    = newSymbol "stats.leftsided"
rightSidedSymbol   = newSymbol "stats.rightsided"

singleSampleSymbol = newSymbol "stats.singlesample"
twoSampleSymbol    = newSymbol "stats.twosample"

dependentSymbol    = newSymbol "stats.dependent"
independentSymbol  = newSymbol "stats.independent"

initialSymbol      = newSymbol "stats.initial"
derivedSymbol      = newSymbol "stats.derived"

trueSymbol, falseSymbol :: Symbol
trueSymbol         = newSymbol L.trueSymbol
falseSymbol        = newSymbol L.falseSymbol

toOMSymbol :: Symbol -> OM.Symbol
toOMSymbol s = idToSymbol (getId s)

rejectH0Symbol, acceptH0Symbol, dontRejectH0Symbol, rejectH1Symbol,
   acceptH1Symbol, dontRejectH1Symbol :: Symbol
rejectH0Symbol     = newSymbol "stats.rejecth0" 
acceptH0Symbol     = newSymbol "stats.accepth0" 
dontRejectH0Symbol = newSymbol "stats.dontrejecth0" 
rejectH1Symbol     = newSymbol "stats.rejecth1" 
acceptH1Symbol     = newSymbol "stats.accepth1" 
dontRejectH1Symbol = newSymbol "stats.dontrejecth1"

-- Copied from Ideas.Encoding.OpenMathSuppoer
idToSymbol :: Id -> OM.Symbol
idToSymbol a
   | null (qualifiers a) =
        OM.extraSymbol (unqualified a)
   | otherwise =
        OM.makeSymbol (qualification a) (unqualified a)

toTermBool :: Bool -> Term
toTermBool b = symbol s
 where
   s = if b then trueSymbol else falseSymbol

fromTermBool :: Monad m => Term -> m Bool
fromTermBool (TCon s [])
  | s == trueSymbol  = return True
  | s == falseSymbol = return False
fromTermBool _ = fail "Term is not a boolean"