import TokenType.*
import exceptions.*

class Lexical {
    /**
     * Analyzes the given [source] and returns the tokens divided into an array of statements
     */
    fun analyze(source: String): MutableList<MutableList<Token>> {
        var buffer = ""
        var lineNumber = 1
        var skipStatementEnd = false
        var statementEnd: Boolean
        val statements = mutableListOf<MutableList<Token>>()
        val currentStatement = mutableListOf<Token>()
        for (i in source.indices) {
            if (source[i] == '"') skipStatementEnd = !skipStatementEnd
            if (source[i] == '\n') lineNumber++
            statementEnd = source[i] == ';' && !skipStatementEnd
            buffer += source[i]

            val tokenType = getTokenType(buffer, if (source.length > i + 1) source[i + 1] else ' ')
            if (tokenType != Skip) {
                val newToken = Token()
                newToken.content = buffer
                newToken.type = tokenType
                newToken.lineNumber = lineNumber
                currentStatement.add(newToken)
                buffer = ""
            }
            if (statementEnd) {
                statements.add(currentStatement.toMutableList())
                currentStatement.clear()
                buffer = ""
            }
        }
        return statements
    }

    /**
     * Matches the tokens to a [TokenType]
     */
    private fun getTokenType(token: String, next: Char): TokenType {
        return when {
            token + next in keyword -> Skip
            token in keyword -> Keyword

            token + next in comparison -> Skip
            token in assignment -> Assignment

            token + next in assignment -> Skip
            token in arithmetic -> Arithmetic

            token + next in comparison -> Skip
            token in comparison -> Comparison

            token + next in comparison -> Skip
            token in logical -> Logical

            (token + next).matches(Regex("[a-zA-Z]*")) -> Skip
            token.matches(Regex("[a-zA-Z]*")) && next == '(' -> Function
            token.matches(Regex("[a-zA-Z]*")) -> Variable

            (token + next).matches(Regex("[0-9]*")) -> Skip
            token.matches(Regex("[0-9]*")) -> Constant

            token in emptiness && token.length > 1 -> throw LexicalError(token)
            token in emptiness -> Empty

            token in punctuation -> Punctuation

            token in endOfStatement -> StatementEnd

            token in openedBrackets -> OpenedBracket
            token in closedBrackets -> ClosedBracket

            token in classifier -> Classifier

            else -> Skip
        }
    }

    private val keyword = listOf("if", "elif", "else", "for", "while")
    private val assignment = listOf("=", "+=", "-=", "*=", "/*")
    private val arithmetic = listOf("+", "-", "*", "/", "%")
    private val comparison = listOf("==", "!=", "<", "<=", ">", ">=")
    private val logical = listOf("&&", "||", "!")
    private val punctuation = listOf(",", ":", ".")
    private val endOfStatement = listOf(";")
    private val openedBrackets = listOf("(", "[", "{")
    private val closedBrackets = listOf(")", "]", "}")
    private val classifier = listOf("\"", "'")
    private val emptiness = listOf(" ", "\r", "\t", "\n")
}