# Copyright 2022 Mattia Giambirtone & All Contributors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

## Peon's main executable

# Our stuff
import frontend/lexer as l
import frontend/parser as p
import frontend/compiler as c
import backend/vm as v
import util/serializer as s
import util/debugger
import util/symbols
import util/fmterr
import config

# Builtins & external libs
import std/strformat
import std/strutils
import std/terminal
import std/parseopt
when debugSerializer:
    import std/times
import std/os

# Thanks art <3
import jale/editor as ed
import jale/templates
import jale/plugin/defaults
import jale/plugin/editor_history
import jale/keycodes
import jale/multiline


# Forward declarations
proc getLineEditor: LineEditor


proc repl =
    styledEcho fgMagenta, "Welcome into the peon REPL!"
    var
        keep = true
        tokens: seq[Token] = @[]
        tree: seq[Declaration] = @[]
        compiled: Chunk = newChunk()
        serialized: Serialized
        tokenizer = newLexer()
        vm = newPeonVM()
        debugger = newDebugger()
        serializer = newSerializer()
        editor = getLineEditor()
        input: string
        current: string
    tokenizer.fillSymbolTable()
    editor.bindEvent(jeQuit):
        stdout.styledWriteLine(fgGreen, "Goodbye!")
        editor.prompt = "=> "
        keep = false
        input = ""
        current = ""
    editor.bindKey("ctrl+a"):
        editor.content.home()
    editor.bindKey("ctrl+e"):
        editor.content.`end`()
    while keep:
        try:
            input = editor.read()
            if input == "#reset":
                compiled = newChunk()
                current = ""
                continue
            elif input == "#show":
                echo current
            elif input == "#clear":
                stdout.write("\x1Bc")
                continue
            else:
                current &= input & "\n"
            if current.len() == 0:
                continue
            tokens = tokenizer.lex(current, "stdin")
            if tokens.len() == 0:
                continue
            when debugLexer:
                styledEcho fgCyan, "Tokenization step:"
                for i, token in tokens:
                    if i == tokens.high():
                        # Who cares about EOF?
                        break
                    styledEcho fgGreen, "\t", $token
                echo ""
            tree = newParser().parse(tokens, "stdin", tokenizer.getLines(), current)
            if tree.len() == 0:
                continue
            when debugParser:
                styledEcho fgCyan, "Parsing step:"
                for node in tree:
                    styledEcho fgGreen, "\t", $node
                echo ""
            compiled = newCompiler(replMode=true).compile(tree, "stdin", tokenizer.getLines(), current)
            when debugCompiler:
                styledEcho fgCyan, "Compilation step:\n"
                debugger.disassembleChunk(compiled, "stdin")
                echo ""

            serialized = serializer.loadBytes(serializer.dumpBytes(compiled, "stdin"))
            when debugSerializer:
                styledEcho fgCyan, "Serialization step: "
                styledEcho fgBlue, "\t- Peon version: ", fgYellow, &"{serialized.version.major}.{serialized.version.minor}.{serialized.version.patch}", fgBlue, " (commit ", fgYellow, serialized.commit[0..8], fgBlue, ") on branch ", fgYellow, serialized.branch
                stdout.styledWriteLine(fgBlue, "\t- Compilation date & time: ", fgYellow, fromUnix(serialized.compileDate).format("d/M/yyyy HH:mm:ss"))
                stdout.styledWrite(fgBlue, &"\t- Constants segment: ")
                if serialized.chunk.consts == compiled.consts:
                    styledEcho fgGreen, "OK"
                else:
                    styledEcho fgRed, "Corrupted"
                stdout.styledWrite(fgBlue, &"\t- Code segment: ")
                if serialized.chunk.code == compiled.code:
                    styledEcho fgGreen, "OK"
                else:
                    styledEcho fgRed, "Corrupted"
                stdout.styledWrite(fgBlue, "\t- Line info segment: ")
                if serialized.chunk.lines == compiled.lines:
                    styledEcho fgGreen, "OK"
                else:
                    styledEcho fgRed, "Corrupted"
                stdout.styledWrite(fgBlue, "\t- CFI segment: ")
                if serialized.chunk.cfi == compiled.cfi:
                    styledEcho fgGreen, "OK"
                else:
                    styledEcho fgRed, "Corrupted"
            vm.run(serialized.chunk)
        except LexingError:
            print(LexingError(getCurrentException()))
        except ParseError:
            print(ParseError(getCurrentException()))
        except CompileError:
            print(CompileError(getCurrentException()))
        except SerializationError:
            print(SerializationError(getCurrentException()))
    quit(0)


proc runFile(f: string, fromString: bool = false, dump: bool = true, breakpoints: seq[uint64] = @[], dis: bool = false,
             warnings: seq[WarningKind] = @[], mismatches: bool = false, mode: CompileMode = Debug) =
    var
        tokens: seq[Token] = @[]
        tree: seq[Declaration] = @[]
        compiled: Chunk
        serialized: Serialized
        tokenizer = newLexer()
        parser = newParser()
        compiler = newCompiler()
        debugger {.used.} = newDebugger()
        serializer = newSerializer()
        vm = newPeonVM()
        input: string
    tokenizer.fillSymbolTable()
    try:
        var f = f
        if not fromString:
            if not f.endsWith(".pn") and not f.endsWith(".pbc"):
                f &= ".pn"
            if dis:
                debugger.disassembleChunk(serializer.loadFile(f).chunk, f)
                return
            input = readFile(f)
        else:
            input = f
            f = "<string>"
        tokens = tokenizer.lex(input, f)
        if tokens.len() == 0:
            return
        when debugLexer:
            styledEcho fgCyan, "Tokenization step:"
            for i, token in tokens:
                if i == tokens.high():
                    # Who cares about EOF?
                    break
                styledEcho fgGreen, "\t", $token
            echo ""
        tree = parser.parse(tokens, f, tokenizer.getLines(), input)
        if tree.len() == 0:
            return
        when debugParser:
            styledEcho fgCyan, "Parsing step:"
            for node in tree:
                styledEcho fgGreen, "\t", $node
            echo ""
        compiled = compiler.compile(tree, f, tokenizer.getLines(), input, disabledWarnings=warnings, showMismatches=mismatches, mode=mode)
        when debugCompiler:
            styledEcho fgCyan, "Compilation step:\n"
            debugger.disassembleChunk(compiled, f)
            echo ""
        var path = splitFile(f).dir
        if path.len() > 0:
            path &= "/"
        path &= splitFile(f).name & ".pbc"
        if dump and not fromString:
            serializer.dumpFile(compiled, f, path)
            serialized = serializer.loadFile(path)
        else:
            serialized = serializer.loadBytes(serializer.dumpBytes(compiled, f))
        when debugSerializer:
            styledEcho fgCyan, "Serialization step: "
            styledEcho fgBlue, "\t- Peon version: ", fgYellow, &"{serialized.version.major}.{serialized.version.minor}.{serialized.version.patch}", fgBlue, " (commit ", fgYellow, serialized.commit[0..8], fgBlue, ") on branch ", fgYellow, serialized.branch
            stdout.styledWriteLine(fgBlue, "\t- Compilation date & time: ", fgYellow, fromUnix(serialized.compileDate).format("d/M/yyyy HH:mm:ss"))
            stdout.styledWrite(fgBlue, &"\t- Constants segment: ")
            if serialized.chunk.consts == compiled.consts:
                styledEcho fgGreen, "OK"
            else:
                styledEcho fgRed, "Corrupted"
            stdout.styledWrite(fgBlue, &"\t- Code segment: ")
            if serialized.chunk.code == compiled.code:
                styledEcho fgGreen, "OK"
            else:
                styledEcho fgRed, "Corrupted"
            stdout.styledWrite(fgBlue, "\t- Line info segment: ")
            if serialized.chunk.lines == compiled.lines:
                styledEcho fgGreen, "OK"
            else:
                styledEcho fgRed, "Corrupted"
            stdout.styledWrite(fgBlue, "\t- CFI segment: ")
            if serialized.chunk.cfi == compiled.cfi:
                styledEcho fgGreen, "OK"
            else:
                styledEcho fgRed, "Corrupted"
        vm.run(serialized.chunk, breakpoints)
    except LexingError:
        print(LexingError(getCurrentException()))
    except ParseError:
        print(ParseError(getCurrentException()))
    except CompileError:
        print(CompileError(getCurrentException()))
    except SerializationError:
        print(SerializationError(getCurrentException()))
    except IOError:
        print(IOError(getCurrentException()[]), f)
    except OSError:
        print(OSError(getCurrentException()[]), f, osLastError())



when isMainModule:
    setControlCHook(proc () {.noconv.} = quit(0))
    var optParser = initOptParser(commandLineParams())
    var file: string = ""
    var fromString: bool = false
    var dump: bool = true
    var warnings: seq[WarningKind] = @[]
    var breaks: seq[uint64] = @[]
    var dis: bool = false
    var mismatches: bool = false
    for kind, key, value in optParser.getopt():
        case kind:
            of cmdArgument:
                file = key
            of cmdLongOption:
                case key:
                    of "help":
                        echo HELP_MESSAGE
                        quit()
                    of "version":
                        echo PEON_VERSION_STRING
                        quit()
                    of "string":
                        file = key
                        fromString = true
                    of "no-dump":
                        dump = false
                    of "warnings":
                        if value.toLowerAscii() in ["yes", "on"]:
                            warnings = @[]
                        elif value.toLowerAscii() in ["no", "off"]:
                            for warning in WarningKind:
                                warnings.add(warning)
                        else:
                            stderr.styledWriteLine(fgRed, styleBright, "Error: ", fgDefault, "invalid value for option 'warnings' (valid options are: yes, on, no, off)")
                            quit()
                    of "showMismatches":
                        mismatches = true
                    of "noWarn":
                        case value:
                            of "unusedVariable":
                                warnings.add(WarningKind.UnusedName)
                            of "unreachableCode":
                                warnings.add(WarningKind.UnreachableCode)
                            of "shadowingOuterScope":
                                warnings.add(WarningKind.ShadowOuterScope)
                            else:
                                stderr.styledWriteLine(fgRed, styleBright, "Error: ", fgDefault, "invalid warning name for option 'warnings'")
                                quit()   
                    of "breakpoints":
                        when not debugVM:
                            stderr.styledWriteLine(fgRed, styleBright, "Error: ", fgDefault, "cannot set breakpoints in release mode")
                            quit()
                        for point in value.strip(chars={' '}).split(","):
                            try:
                                breaks.add(parseBiggestUInt(point))
                            except ValueError:
                                stderr.styledWriteLine(fgRed, styleBright, "Error: ", fgDefault, &"error: invalid breakpoint value '{point}'")
                                quit()
                    of "disassemble":
                        dis = true
                    else:
                        stderr.styledWriteLine(fgRed, styleBright, "Error: ", fgDefault, &"error: unkown option '{key}'")
                        quit()
            of cmdShortOption:
                case key:
                    of "h":
                        echo HELP_MESSAGE
                        quit()
                    of "v":
                        echo PEON_VERSION_STRING
                        quit()
                    of "s":
                        file = key
                        fromString = true
                    of "n":
                        dump = false
                    of "b":
                        when not debugVM:
                            stderr.styledWriteLine(fgRed, styleBright, "Error: ", fgDefault, "cannot set breakpoints in release mode")
                            quit()
                        for point in value.strip(chars={' '}).split(","):
                            try:
                                breaks.add(parseBiggestUInt(point))
                            except ValueError:
                                stderr.styledWriteLine(fgRed, styleBright, "Error: ", fgDefault, &"error: invalid breakpoint value '{point}'")
                                quit()
                    of "d":
                        dis = true
                    else:
                        stderr.styledWriteLine(fgRed, styleBright, "Error: ", fgDefault, &"unkown option '{key}'")
                        quit()
            else:
                echo "usage: peon [options] [filename.pn]"
                quit()
    if file == "":
        repl()
    else:
        runFile(file, fromString, dump, breaks, dis, warnings, mismatches)



proc getLineEditor: LineEditor =
    result = newLineEditor()
    result.prompt = "=> "
    result.populateDefaults()
    let history = result.plugHistory()
    result.bindHistory(history)