import argparse
from collections import deque
from antlr4 import *
from milestone_2Lexer import milestone_2Lexer
from milestone_2Listener import milestone_2Listener
from antlr4.error.ErrorListener import *
from antlr4.error.Errors import RecognitionException
from milestone_2Parser import milestone_2Parser
from antlr4.tree.Trees import Trees
from antlr4.Token import CommonToken

class NimSyntaxError(Exception):
    def __init__(self, symbol, line, column, msg):
        self.symbol = symbol
        self.line = line
        self.column = column
        self.msg = "At line %d, column %d: %s" % (line, column, msg)

class NimErrorListener(ErrorListener):
    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
        e = NimSyntaxError(offendingSymbol, line, column, msg)
        raise e
        print(e.msg)

class NimListener(milestone_2Listener):
    def enterCondStmt(self, ctx):
        #print("HELLO?")
        #print(ctx.getText())
        pass

    def enterIfStmt(self, ctx):
        #sprint("IF: %s" % ctx.getText())
        pass

    def enterEveryRule(self, ctx):
        #print("ENTERED RULE MAN")
        pass

class NimLexer(milestone_2Lexer):
    def __init__(self, input, output=None):
        super().__init__(input, output)
        self.token_queue = deque()
        self.indent_stack = [0]
        self.last_token = None

    def insertIndent(self, indent_level):
        indent_token = self.createToken(milestone_2Parser.INDENT, " " * indent_level)
        self.indent_stack.append(indent_level)
        self.token_queue.append(indent_token)

    def insertDedent(self):
        dedent_token = self.createToken(milestone_2Parser.DEDENT, "")
        self.token_queue.append(dedent_token)
        self.indent_stack.pop()

    def insertNewline(self):
        newline_token = self.createToken(milestone_2Parser.NEWLINE, "\r\n")
        self.token_queue.append(newline_token)

    def nextToken(self):
        while not self.token_queue:
            token = super().nextToken()
            if token.type in [self.NEWLINE, self.COMMENT, self.DOCUMENTATION_COMMENTS]:
                print("Token: %s " % get_token_type(token))
                if token.type != self.NEWLINE:
                self.insertNewline()
                indent_level = token.text.count(" ")
                if indent_level > self.indent_stack[-1]:
                    self.insertIndent(indent_level)
                elif indent_level < self.indent_stack[-1]:
                    while self.indent_stack and self.indent_stack[-1] > indent_level:
                        self.insertDedent()
                else:
                    self.token_queue.append(token)
            elif token.type == token.EOF:
                # Encountered EOF, need to dedent all indents
                while self.indent_stack and self.indent_stack[-1] > 0:
                    self.insertDedent()
                self.token_queue.append(token)
            else:
                self.token_queue.append(token)
        return self.token_queue.popleft()

    def createToken(self, type, text):
        stop = self.getCharIndex()-1
        start = stop if text == "" else stop - len(text) + 1
        return CommonToken(
            self._tokenFactorySourcePair,
            type,
            self.DEFAULT_TOKEN_CHANNEL,
            start, stop
        )


def get_token_type(token):
    if token.type == milestone_2Parser.EOF:
        return "EOF"
    return milestone_2Parser.symbolicNames[token.type]


def print_tokens(input_stream):
    input_stream.seek(0)
    lexer = NimLexer(input_stream)
    token_stream = CommonTokenStream(lexer)
    parser = milestone_2Parser(token_stream)
    token = lexer.nextToken()
    while token.type != token.EOF:
        print(get_token_type(token))
        token = lexer.nextToken()

def check_validity(input_stream):
    input_stream.seek(0)
    lexer = NimLexer(input_stream)
    token_stream = CommonTokenStream(lexer)
    parser = milestone_2Parser(token_stream)
    parser.removeErrorListeners()
    parser.addErrorListener(NimErrorListener())
    walker = ParseTreeWalker()
    output = "valid"
    try:
        tree = parser.start()
        walker.walk(NimListener(),tree)
    except Exception as e:
        print("Nim Syntax Error: %s" % e.msg)
        output = "invalid"
    print(output)


def main():
    with open(args.file, "r") as file:
        lines = file.read()
    input_stream = InputStream(lines)
    print_tokens(input_stream)
    check_validity(input_stream)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(add_help=True, description='Sample Commandline')

    parser.add_argument('--file', action="store", help="path of file to take as input", nargs="?", metavar="file")

    args = parser.parse_args()

    main()