module Mud.Thing.Parse where

	import Text.ParserCombinators.Parsec

	import Mud.Thing.Data
	import Mud.Thing.Eval


	-- Parse comment (starting with '#' until end of line).
	comment = do
		position <- getPosition
		char '#'
		comment <- manyTill (noneOf "\n") (char '\n')
		return $ Comment position comment


	-- Parse a reserved word (aka keyword).
	reserved = do
		position <- getPosition
		word <- many1 letter
		if word `elem` reservedWords
			then return $ Reserved position word
			else pzero


	-- Check for a statement separator (semikolon or linebreak).
	separator = do
		position <- getPosition
		character <- try $ oneOf ";\n"
		return $ Separator position character
	

	-- Parse an operator character.
	operator = do
		position <- getPosition
		character <- oneOf "~="
		return $ Operator position character


	-- Parse an identifier, consisting of a sigil and a word of just letters.
	identifier = do
		position <- getPosition
		sigil <- try $ oneOf "%&"
		name <- many1 letter
		return $ Identifier position (sigil : name)
	

	property = do
		position <- getPosition
		try $ char ':'
		name <- many1 letter
		return $ Property position name
	

	call = do
		position <- getPosition
		try $ char '!'
		name <- many1 letter
		return $ Call position name


	-- Parse a normal string enclosed by double quotes.
	-- TODO: Escapes!
	doubleQuotedString = char '"' >> manyTill (noneOf "\"") (char '"')

	
	-- Parse a text block enclosed by "***".
	blockString = string "***" >> manyTill anyChar (string "***")


	-- Just a number.
	number = many1 digit
	

	-- Check for end of file.
	fileEnd = do
		position <- getPosition
		try $ eof
		return $ EOF position


	-- Parse a scalar (normal string, text block or number).
	scalar = do
		position <- getPosition
		content <- (try doubleQuotedString <|> try blockString <|> try number) <?> "scalar"
		return $ Scalar position content
	

	-- Parse a list (zero or more scalars or even more lists).
	list = do
		position <- getPosition

		char '['
		content <- sepBy (scalar <|> list <|> identifier) (many1 space)
		char ']'

		return $ List position content


	-- Parse a single token.
	parseToken = (comment <?> "comment")
		<|> (property <?> "property")
		<|> (call <?> "function call")
		<|> (reserved <?> "keyword")
		<|> (scalar <?> "scalar")
		<|> (identifier <?> "identifier")
		<|> (operator <?> "operator")
		<|> (separator <?> "separator")
		<|> (fileEnd <?> "end of input")
		<|> (list <?> "list")


	-- Parse a single token, or, if the token is the beginning of a block,
	-- return a block token that contains even more tokens.
	block = do
		position <- getPosition
		token <- parseToken

		case token of
			(Reserved _ "do") -> do { blockContent position }
			_                 -> return token

			where
				manyTillDone = do
					skipMany (oneOf " \t\r" <?> "")
					token <- parseToken

					case token of
						(Reserved _ "done") -> return []
						_                   -> do { rest <- manyTillDone; return $ token : rest }

				blockContent position = do
					rest <- manyTillDone
					return $ Block position rest


	-- Main tokenizing function. Loops until EOF and returns all tokens.
	tokenize = do
		skipMany (oneOf " \t\r" <?> "")
		token <- block

		case token of
			(EOF _) -> return [token]
			_       -> tokenizeRest token <|> return [token]

		where
			tokenizeRest token = do
				moreTokens <- tokenize
				return $ token : moreTokens


	-- Load a file and tokenize its content.
	tokenizeFile source = do
		result <- parseFromFile tokenize source
		case (result) of
			Left error   -> do { putStrLn $ "error at " ++ show error; return [] }
			Right tokens -> return $ splitExpression tokens


	-- List of reserved words.
	reservedWords = [ "inherit", "from", "when", "do", "done", "function", "is" ]