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)
            statement.forEach { println("${it.content} ${it.type}") }
            statement.forEachIndexed { j, token ->
                if (statement.count { it.content == "(" } != statement.count { it.content == ")" })
                    throw SyntaxError("Bracket", "Brackets are not even")

                when (token.type) {
                    Keyword -> allowNext(statement, j, listOf(Bracket))
                    Function -> allowNext(statement, j, listOf(Bracket))
                    Constant -> allowNext(statement, j, listOf(Comparison, Arithmetic, Logical, Bracket))
                    Assignment -> allowNext(statement, j, listOf(Constant, Function))
                    Arithmetic -> allowNext(statement, j, listOf(Constant, Function))
                    Comparison -> allowNext(statement, j, listOf(Constant, Function))
                    Logical -> allowNext(statement, j, listOf(Constant, Function))
                    Variable -> allowNext(statement, j, listOf(Assignment, Bracket, Arithmetic, Logical, Comparison))
                    Punctuation -> allowNext(statement, j, listOf(Constant))
                    Bracket -> allowNext(statement, j, listOf(Constant, Keyword, Logical, Assignment, Variable))
                    Classifier -> Unit
                    Empty -> Unit
                    Skip -> throw UnknownType(token.content)
                }
            }
        }
        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++
        }
    }

    /**
     * Throws [SyntaxError] if the next token is not in [allowed]
     */
    private fun allowNext(statement: MutableList<Token>, index: kotlin.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(), token.content)
        }
    }

    /**
     * Finds the next non empty token by [index]
     */
    private fun nextNonEmpty(statement: MutableList<Token>, index: kotlin.Int): Token {
        var i = index + 1
        while (statement[i].type == Empty) i++
        return statement[i]
    }
}