module Language.TCT.Read
 ( module Language.TCT.Read.Tree
 , module Language.TCT.Read.Token
 , module Language.TCT.Read.Cell
 , module Language.TCT.Read
 ) where

import Control.Applicative (Applicative(..))
import Control.Monad (Monad(..))
import Data.Either (Either(..))
import Data.Foldable (Foldable(..))
import Data.Function (($))
import Data.Functor ((<$>))
import Data.Traversable (Traversable(..))
import Data.TreeSeq.Strict (Tree(..), Trees)
import Data.Void (Void)
import System.IO (FilePath)
import qualified Data.Text.Lazy as TL
import qualified Text.Megaparsec as P

import Language.TCT.Debug
import Language.TCT.Tree
import Language.TCT.Cell
import Language.TCT.Read.Cell
import Language.TCT.Read.Tree
import Language.TCT.Read.Token

-- | Parsing is done in two phases:
-- 
-- 1. indentation-sensitive parsing on 'TL.Text'
-- 2. pair-sensitive parsing on some 'NodeText's resulting of 1.
readTrees ::
 FilePath -> TL.Text ->
 Either (P.ParseError (P.Token TL.Text) (P.ErrorFancy Void)) (Trees (Cell Node))
readTrees inp txt = do
	trs <- P.runParser (p_Trees <* P.eof) inp txt
	traverse (go NodeGroup) $ debug0 "readTrees" trs
	where
	go :: Node -> Tree (Cell Node) ->
	 Either (P.ParseError (P.Token TL.Text) (P.ErrorFancy Void))
	        (Tree (Cell Node))
	go parent t@(Tree c@(Cell bn en nod) ts) =
		case nod of
		 NodeLower{} -> Right t
		 NodeText n ->
			case parent of
			 NodeHeader HeaderBar{}   -> Right t
			 NodeHeader HeaderEqual{} -> Right t
			 _ -> do
				toks <- parseTokens <$> parseLexemes inp (Cell bn en n)
				return $
					case toList toks of
					 [tok] -> tok
					 _ -> Tree (Cell bn en NodeGroup) toks
		 _ -> Tree c <$> traverse (go nod) ts