{-# LANGUAGE GADTs, DataKinds, OverloadedStrings #-}
{-# LANGUAGE StandaloneDeriving, FlexibleContexts #-}

module Events.Spec.Parse
  ( parse
  , ParseError(..)
  , TypeError(..)
  ) where

import Events.Spec.Types
import Events.Spec.Parse.Token
import Events.Spec.Parse.AST

import Text.Megaparsec hiding (parse)
import qualified Text.Megaparsec.Lexer as L

import Data.Text (Text)
import qualified Data.Text as Text

import Data.Text.Lazy as Lazy (Text)
import qualified Data.Text.Lazy as Lazy.Text

import Data.Either (either)
import Data.Typeable (Typeable)

import Control.Monad.Catch (Exception(..), MonadThrow(..))


data TypeError = TypeError
  deriving (Typeable, Show)

instance Exception TypeError


parse :: (MonadIO m, MonadThrow m) => String -> Lazy.Text -> m (Spec m)
parse name = typecheck <=< runParserT' pAST name <=< runParserT' pTokens name
  where
    runParserT' parser name = either throwM return <=< runParserT parser name

typecheck :: MonadThrow m => AST -> m (Spec m)
typecheck = undefined