{-# LANGUAGE OverloadedStrings #-}

module Language.Drasil.HTML.Spec (
  printSpec, specToHTML
) where

import qualified Data.Text as T (pack, show)
import Data.Text (Text)

import Language.Drasil (Special (..))
import qualified Language.Drasil.Printing.AST as AST
import Drasil.Data.Formats.HTML (attr, bold_, emphasis_, rawText',
  subscript_, superscript_, HTMLBody(..), span_)
import Language.Drasil.HTML.MathJax (inlineEqn)
import qualified Language.Drasil.TeX.Print as TeX (pExpr, printMath)
import Drasil.Printers.Common

-- | Transforms the Sentences ('Spec's) into Text
printSpec :: AST.Spec -> Text
printSpec :: Spec -> Text
printSpec (AST.S String
s) = String -> Text
T.pack String
s
printSpec (AST.E Expr
e) = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Doc -> String
forall a. Show a => a -> String
show (Doc -> String) -> Doc -> String
forall a b. (a -> b) -> a -> b
$ D -> Doc
TeX.printMath (D -> Doc) -> D -> Doc
forall a b. (a -> b) -> a -> b
$ Expr -> D
TeX.pExpr Expr
e -- TODO: Remove `show` once LaTeX render is using Prettyprinter
printSpec (Spec
a AST.:+: Spec
b) = Spec -> Text
printSpec Spec
a Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Spec -> Text
printSpec Spec
b
printSpec (AST.Sp Special
s) = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Special -> String
specialToString Special
s
printSpec (AST.Ref (AST.Cite2 Spec
n) String
_ Spec
a) = Spec -> Text
printSpec Spec
a Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Spec -> Text
printSpec Spec
n
printSpec (AST.Ref LinkType
_ String
_ Spec
a) = Spec -> Text
printSpec Spec
a
printSpec Spec
AST.EmptyS = Text
""
printSpec (AST.Quote Spec
q) = Text -> Text
forall a. CanTextWrap a => a -> a
dquote (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Spec -> Text
printSpec Spec
q
printSpec (AST.Tooltip Spec
_ Spec
s) = Spec -> Text
printSpec Spec
s

-- | Transforms the Sentences ('Spec's) into HTML (called by 'loToHTML').
specToHTML :: AST.Spec -> [HTMLBody]
-- Non-MathJax
specToHTML :: Spec -> [HTMLBody]
specToHTML (AST.E Expr
e) = [[HTMLBody] -> HTMLBody
emphasis_ (Expr -> [HTMLBody]
exprToHTML Expr
e)]
specToHTML (Spec
a AST.:+: Spec
b) = Spec -> [HTMLBody]
specToHTML Spec
a [HTMLBody] -> [HTMLBody] -> [HTMLBody]
forall a. Semigroup a => a -> a -> a
<> Spec -> [HTMLBody]
specToHTML Spec
b
specToHTML (AST.S String
s) = [Text -> HTMLBody
RawText (String -> Text
T.pack String
s)]
specToHTML (AST.Tooltip Spec
t Spec
s) = [[Attr] -> [HTMLBody] -> HTMLBody
span_ [Text -> Text -> Attr
attr Text
"title" (Spec -> Text
printSpec Spec
t)] (Spec -> [HTMLBody]
specToHTML Spec
s)]
specToHTML (AST.Sp Special
s) = [Text -> HTMLBody
RawText (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Special -> String
specialToString Special
s)]
specToHTML (AST.Ref LinkType
refType String
r Spec
a) = case LinkType
refType of
  LinkType
AST.Internal         -> [HTMLBody
internalRef]
  AST.Cite2 Spec
AST.EmptyS -> [HTMLBody
internalRef]
  AST.Cite2 Spec
n          -> HTMLBody
internalRef HTMLBody -> [HTMLBody] -> [HTMLBody]
forall a. a -> [a] -> [a]
: Spec -> [HTMLBody]
specToHTML Spec
n
  LinkType
AST.External         -> [Text -> [Attr] -> [HTMLBody] -> HTMLBody
Anchor (String -> Text
T.pack String
r) [] (Spec -> [HTMLBody]
specToHTML Spec
a)]
  where
    internalRef :: HTMLBody
internalRef = Text -> [Attr] -> [HTMLBody] -> HTMLBody
Anchor (String -> Text
T.pack (Char
'#' Char -> String -> String
forall a. a -> [a] -> [a]
: String
r)) [] (Spec -> [HTMLBody]
specToHTML Spec
a)
specToHTML Spec
AST.EmptyS = []
specToHTML (AST.Quote Spec
q) = [HTMLBody
"\""] [HTMLBody] -> [HTMLBody] -> [HTMLBody]
forall a. Semigroup a => a -> a -> a
<> Spec -> [HTMLBody]
specToHTML Spec
q [HTMLBody] -> [HTMLBody] -> [HTMLBody]
forall a. Semigroup a => a -> a -> a
<> [HTMLBody
"\""]

-- | Generates expressions in the HTML document (called by multiple functions).
exprToHTML :: AST.Expr -> [HTMLBody]
exprToHTML :: Expr -> [HTMLBody]
exprToHTML (AST.Dbl Double
d) = [Text -> HTMLBody
RawText (Text -> HTMLBody) -> Text -> HTMLBody
forall a b. (a -> b) -> a -> b
$ Double -> Text
forall a. Show a => a -> Text
T.show Double
d]
exprToHTML (AST.Int Integer
i) = [Text -> HTMLBody
RawText (Text -> HTMLBody) -> Text -> HTMLBody
forall a b. (a -> b) -> a -> b
$ Integer -> Text
forall a. Show a => a -> Text
T.show Integer
i]
exprToHTML (AST.Str String
s) = [Text -> HTMLBody
RawText (Text -> HTMLBody) -> Text -> HTMLBody
forall a b. (a -> b) -> a -> b
$ Text -> Text
forall a. CanTextWrap a => a -> a
dquote (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
s]
exprToHTML (AST.Row [Expr]
l) = (Expr -> [HTMLBody]) -> [Expr] -> [HTMLBody]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Expr -> [HTMLBody]
exprToHTML [Expr]
l
exprToHTML (AST.Ident String
s) = [String -> HTMLBody
rawText' String
s]
exprToHTML (AST.Label String
s) = [String -> HTMLBody
rawText' String
s]
exprToHTML (AST.Spec Special
s) = [Text -> HTMLBody
RawText (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Special -> String
specialToString Special
s)]
exprToHTML (AST.Sub Expr
e) = [[HTMLBody] -> HTMLBody
subscript_ (Expr -> [HTMLBody]
exprToHTML Expr
e)]
exprToHTML (AST.Sup Expr
e) = [[HTMLBody] -> HTMLBody
superscript_ (Expr -> [HTMLBody]
exprToHTML Expr
e)]
exprToHTML (AST.Over OverSymb
AST.Hat Expr
s) = Expr -> [HTMLBody]
exprToHTML Expr
s [HTMLBody] -> [HTMLBody] -> [HTMLBody]
forall a. Semigroup a => a -> a -> a
<> [HTMLBody
"̂"]
exprToHTML (AST.MO Ops
o) = [Text -> HTMLBody
RawText (Ops -> Text
pOps Ops
o)]
exprToHTML (AST.Fenced Fence
l Fence
r Expr
e) =
  [Text -> HTMLBody
RawText (OpenClose -> Fence -> Text
fence OpenClose
Open Fence
l)] [HTMLBody] -> [HTMLBody] -> [HTMLBody]
forall a. Semigroup a => a -> a -> a
<> Expr -> [HTMLBody]
exprToHTML Expr
e [HTMLBody] -> [HTMLBody] -> [HTMLBody]
forall a. Semigroup a => a -> a -> a
<> [Text -> HTMLBody
RawText (OpenClose -> Fence -> Text
fence OpenClose
Close Fence
r)]
exprToHTML (AST.Font Fonts
AST.Bold Expr
e) = [[HTMLBody] -> HTMLBody
bold_ (Expr -> [HTMLBody]
exprToHTML Expr
e)]
exprToHTML (AST.Font Fonts
AST.Emph Expr
e) = [[HTMLBody] -> HTMLBody
emphasis_ (Expr -> [HTMLBody]
exprToHTML Expr
e)]
exprToHTML (AST.Spc Spacing
AST.Thin) = [HTMLBody
" "]
-- Uses TeX for MathJax for all other exprs
exprToHTML Expr
e =
  [Text -> HTMLBody
RawText (Text -> HTMLBody) -> Text -> HTMLBody
forall a b. (a -> b) -> a -> b
$ Text -> Text
inlineEqn (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Doc -> String
forall a. Show a => a -> String
show (Doc -> String) -> Doc -> String
forall a b. (a -> b) -> a -> b
$ D -> Doc
TeX.printMath (D -> Doc) -> D -> Doc
forall a b. (a -> b) -> a -> b
$ Expr -> D
TeX.pExpr Expr
e]

-- | Internal: Converts a 'Special' symbol to its String representation.
specialToString :: Special -> String
specialToString :: Special -> String
specialToString Special
Circle = String
"°"

-- | Internal: Referring to 'fence' (for parenthesis and brackets). Either opened or closed.
data OpenClose = Open | Close

-- | Internal: Allows for open/closed variants of parenthesis, curly brackets, absolute value symbols, and normal symbols.
fence :: OpenClose -> AST.Fence -> Text
fence :: OpenClose -> Fence -> Text
fence OpenClose
Open Fence
AST.Paren = Text
"("
fence OpenClose
Close Fence
AST.Paren = Text
")"
fence OpenClose
Open Fence
AST.Curly = Text
"{"
fence OpenClose
Close Fence
AST.Curly = Text
"}"
fence OpenClose
_ Fence
AST.Abs = Text
"|"
fence OpenClose
_ Fence
AST.Norm = Text
"||"

-- | Internal: Converts expression operators into HTML characters (Text format).
pOps :: AST.Ops -> Text
pOps :: Ops -> Text
pOps Ops
AST.IsIn = Text
" ∈ "
pOps Ops
AST.Integer = Text
"ℤ"
pOps Ops
AST.Rational = Text
"ℚ"
pOps Ops
AST.Real = Text
"ℝ"
pOps Ops
AST.Natural = Text
"ℕ"
pOps Ops
AST.Boolean = Text
"𝔹"
pOps Ops
AST.Comma = Text
","
pOps Ops
AST.Prime = Text
"′"
pOps Ops
AST.Log = Text
"log"
pOps Ops
AST.Ln = Text
"ln"
pOps Ops
AST.Sin = Text
"sin"
pOps Ops
AST.Cos = Text
"cos"
pOps Ops
AST.Tan = Text
"tan"
pOps Ops
AST.Sec = Text
"sec"
pOps Ops
AST.Csc = Text
"csc"
pOps Ops
AST.Cot = Text
"cot"
pOps Ops
AST.Arcsin = Text
"arcsin"
pOps Ops
AST.Arccos = Text
"arccos"
pOps Ops
AST.Arctan = Text
"arctan"
pOps Ops
AST.Not = Text
"¬"
pOps Ops
AST.Dim = Text
"dim"
pOps Ops
AST.Exp = Text
"e"
pOps Ops
AST.Neg = Text
"−"
pOps Ops
AST.Cross = Text
"⨯"
pOps Ops
AST.VAdd = Text
"+"
pOps Ops
AST.VSub = Text
"−"
pOps Ops
AST.Dot = Text
"⋅"
pOps Ops
AST.Scale = Text
" " -- same as Mul
pOps Ops
AST.Eq = Text
" = " -- with spaces?
pOps Ops
AST.NEq = Text
"≠"
pOps Ops
AST.Lt = Text
" < " -- thin spaces make these more readable
pOps Ops
AST.Gt = Text
" > "
pOps Ops
AST.LEq = Text
" ≤ "
pOps Ops
AST.GEq = Text
" ≥ "
pOps Ops
AST.Impl = Text
" ⇒ "
pOps Ops
AST.Iff = Text
" ⇔ "
pOps Ops
AST.Subt = Text
"−"
pOps Ops
AST.And = Text
" ∧ "
pOps Ops
AST.Or = Text
" ∨ "
pOps Ops
AST.Add = Text
"+"
pOps Ops
AST.Mul = Text
" "
pOps Ops
AST.Summ = Text
"∑"
pOps Ops
AST.Inte = Text
"∫"
pOps Ops
AST.Prod = Text
"∏"
pOps Ops
AST.Point = Text
"."
pOps Ops
AST.Perc = Text
"%"
pOps Ops
AST.LArrow = Text
" ← "
pOps Ops
AST.RArrow = Text
" → "
pOps Ops
AST.ForAll = Text
" ∀ "
pOps Ops
AST.Partial = Text
"∂"
pOps Ops
AST.SAdd = Text
" + "
pOps Ops
AST.SRemove = Text
" - "
pOps Ops
AST.SContains = Text
" in "
pOps Ops
AST.SUnion = Text
" and "