import TokenType.*
import exceptions.*

class Syntax {
    /**
     * Checks and validates whether the code complies with the syntax/grammar rules
     */
    fun check(statements: MutableList<MutableList<Token>>): Boolean {
        statements.forEach { statement ->
            removePadding(statement)
            mergeStrings(statement)
            mergeTokens(statement)
            checkFirst(statement)
            statement.forEach { println("${it.content} ${it.type}") }
            statement.forEachIndexed { j, token ->
                checkBrackets(statement, token)
                checkNext(statement, token, j)
            }
        }
        return true
    }

    /**
     * Removes empty characters from the start and end of statements
     */
    private fun removePadding(statement: MutableList<Token>) {
        while (statement[0].type == Empty)
            statement.removeAt(0)

        while (statement[statement.size - 1].type == Empty)
            statement.removeAt(statement.size - 1)
    }

    /**
     * Merges classified strings to constants
     */
    private fun mergeStrings(statement: MutableList<Token>) {
        var stringing = false
        statement.forEachIndexed { i, token ->
            if (token.type == Classifier)
                stringing = !stringing
            if (stringing || token.type == Classifier) {
                token.type = Constant
                statement[i] = token
            }
        }
    }

    /**
     * Merges tokens by same type
     */
    private fun mergeTokens(statement: MutableList<Token>) {
        var i = 0
        while (statement.size > i + 1) {
            if (statement[i].type == statement[i + 1].type) { // TODO: Differentiate int and string
                statement[i].content = statement[i].content + statement[i + 1].content
                statement.removeAt(i + 1)
                i--
            }
            i++
        }
    }

    /**
     * Specifies which token types are allowed at the beginning of a statement
     */
    private fun checkFirst(statement: MutableList<Token>) {
        val token = statement[0]
        if (token.type !in listOf(Keyword, Function, Variable))
            throw SyntaxError(token.type.toString().toLowerCase(), token.content, token.lineNumber)
    }

    /**
     * Checks whether the count of brackets is equal
     */
    private fun checkBrackets(statement: MutableList<Token>, token: Token) {
        if (statement.count { it.type == OpenedBracket } != statement.count { it.type == ClosedBracket })
            throw SyntaxError("Bracket", "Brackets are not even", token.lineNumber)
    }

    /**
     * Specifies and checks the tokens which are allowed to follow after [token]
     */
    private fun checkNext(statement: MutableList<Token>, token: Token, index: Int) {
        when (token.type) {
            Keyword -> allowNext(statement, index, listOf(OpenedBracket))
            Function -> allowNext(statement, index, listOf(OpenedBracket))
            Constant -> allowNext(statement, index, listOf(Comparison, Arithmetic, Logical, ClosedBracket, StatementEnd))
            Assignment -> allowNext(statement, index, listOf(Constant, Function, Variable))
            Arithmetic -> allowNext(statement, index, listOf(Constant, Function, Variable))
            Comparison -> allowNext(statement, index, listOf(Constant, Function, Variable))
            Logical -> allowNext(statement, index, listOf(Constant, Function, Variable))
            Variable -> allowNext(statement, index, listOf(Assignment, ClosedBracket, Arithmetic, Logical, Comparison))
            Punctuation -> allowNext(statement, index, listOf(Constant))
            OpenedBracket -> allowNext(statement, index, listOf(Constant, Variable, ClosedBracket))
            ClosedBracket -> allowNext(statement, index, listOf(Arithmetic, Comparison, Logical, OpenedBracket, StatementEnd))
            Classifier -> Unit
            Empty -> Unit
            StatementEnd -> Unit
            Skip -> throw LexicalError(token.content)
        }
    }

    /**
     * Throws [SyntaxError] if the next token is not in [allowed]
     */
    private fun allowNext(statement: MutableList<Token>, index: Int, allowed: List<TokenType>) {
        if (statement.size > index + 1 && nextNonEmpty(statement, index).type !in allowed) {
            val token = nextNonEmpty(statement, index)
            throw SyntaxError(token.type.toString().toLowerCase(), token.content, token.lineNumber)
        }
    }
}