# 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.
import ../frontend/meta/errors
import ../frontend/meta/bytecode
import ../frontend/compiler
import multibyte
import ../config


import std/strformat
import std/strutils
import std/times


export ast

type
    Serializer* = ref object
        file: string
        filename: string
        chunk: Chunk
    Serialized* = ref object
        ## Wrapper returned by
        ## the Serializer.read*
        ## procedures to store
        ## metadata
        version*: tuple[major, minor, patch: int]
        branch*: string
        commit*: string
        compileDate*: int
        chunk*: Chunk


proc `$`*(self: Serialized): string =
    result = &"Serialized(version={self.version.major}.{self.version.minor}.{self.version.patch}, branch={self.branch}), commitHash={self.commit}, date={self.compileDate}, chunk={self.chunk[]}"


proc error(self: Serializer, message: string) =
    ## Raises a formatted SerializationError exception
    raise SerializationError(msg: message, file: self.filename)


proc newSerializer*(self: Serializer = nil): Serializer =
    new(result)
    if self != nil:
        result = self
    result.file = ""
    result.filename = ""
    result.chunk = nil


proc writeHeaders(self: Serializer, stream: var seq[byte]) =
    ## Writes the Peon bytecode headers in-place into a byte stream
    stream.extend(PeonBytecodeMarker.toBytes())
    stream.add(byte(PEON_VERSION.major))
    stream.add(byte(PEON_VERSION.minor))
    stream.add(byte(PEON_VERSION.patch))
    stream.add(byte(len(PEON_BRANCH)))
    stream.extend(PEON_BRANCH.toBytes())
    stream.extend(PEON_COMMIT_HASH.toBytes())
    stream.extend(getTime().toUnixFloat().int().toBytes())


proc writeLineData(self: Serializer, stream: var seq[byte]) =
    ## Writes line information for debugging 
    ## bytecode instructions
    stream.extend(len(self.chunk.lines).toQuad())
    for b in self.chunk.lines:
        stream.extend(b.toTriple())


proc writeCFIData(self: Serializer, stream: var seq[byte]) =
    ## Writes Call Frame Information for debugging
    ## functions
    stream.extend(len(self.chunk.cfi).toQuad())
    stream.extend(self.chunk.cfi)


proc writeConstants(self: Serializer, stream: var seq[byte]) =
    ## Writes the constants table in-place into the 
    ## given stream
    stream.extend(self.chunk.consts.len().toQuad())
    for constant in self.chunk.consts:
        stream.add(constant)


proc writeCode(self: Serializer, stream: var seq[byte]) =
    ## Writes the bytecode from the given chunk to the 
    ## given source stream
    stream.extend(self.chunk.code.len.toTriple())
    stream.extend(self.chunk.code)


proc readHeaders(self: Serializer, stream: seq[byte], serialized: Serialized): int =
    ## Reads the bytecode headers from a given stream
    ## of bytes
    var stream = stream
    if stream[0..<len(PeonBytecodeMarker)] != PeonBytecodeMarker.toBytes():
        self.error("malformed bytecode marker")
    result += len(PeonBytecodeMarker)
    stream = stream[len(PeonBytecodeMarker)..^1]
    serialized.version = (major: int(stream[0]), minor: int(stream[1]), patch: int(stream[2]))
    stream = stream[3..^1]
    result += 3
    let branchLength = stream[0]
    stream = stream[1..^1]
    result += 1
    serialized.branch = stream[0..<branchLength].fromBytes()
    stream = stream[branchLength..^1]
    result += int(branchLength)
    serialized.commit = stream[0..<40].fromBytes().toLowerAscii()
    stream = stream[40..^1]
    result += 40
    serialized.compileDate = int(fromLong([stream[0], stream[1], stream[2],
            stream[3], stream[4], stream[5], stream[6], stream[7]]))
    stream = stream[8..^1]
    result += 8



proc readLineData(self: Serializer, stream: seq[byte]): int =
    ## Reads line information from a stream
    ## of bytes
    let size = [stream[0], stream[1], stream[2], stream[3]].fromQuad()
    result += 4
    var stream = stream[4..^1]
    for i in countup(0, int(size) - 1):
        self.chunk.lines.add(int([stream[0], stream[1], stream[2]].fromTriple()))
        result +=  3
        stream = stream[3..^1]


proc readCFIData(self: Serializer, stream: seq[byte]): int =
    ## Reads Call Frame Information from a stream
    ## of bytes
    let size = [stream[0], stream[1], stream[2], stream[3]].fromQuad()
    result += 4
    var stream = stream[4..^1]
    for i in countup(0, int(size) - 1):
        self.chunk.cfi.add(stream[i])
        inc(result)


proc readConstants(self: Serializer, stream: seq[byte]): int =
    ## Reads the constant table from the given stream 
    ## of bytes
    let size = [stream[0], stream[1], stream[2], stream[3]].fromQuad()
    result += 4
    var stream = stream[4..^1]
    for i in countup(0, int(size) - 1):
        self.chunk.consts.add(stream[i])
        inc(result)


proc readCode(self: Serializer, stream: seq[byte]): int =
    ## Reads the bytecode from a given stream and writes
    ## it into the given chunk
    let size = [stream[0], stream[1], stream[2]].fromTriple()
    var stream = stream[3..^1]
    for i in countup(0, int(size) - 1):
        self.chunk.code.add(stream[i])
    doAssert len(self.chunk.code) == int(size)
    return int(size)


proc dumpBytes*(self: Serializer, chunk: Chunk, filename: string): seq[byte] =
    ## Dumps the given bytecode and file to a sequence of bytes and returns it.
    self.filename = filename
    self.chunk = chunk
    self.writeHeaders(result)
    self.writeLineData(result)
    self.writeCFIData(result)
    self.writeConstants(result)
    self.writeCode(result)


proc dumpFile*(self: Serializer, chunk: Chunk, filename, dest: string) =
    ## Dumps the result of dumpBytes to a file at dest
    var fp = open(dest, fmWrite)
    defer: fp.close()
    let data = self.dumpBytes(chunk, filename)
    discard fp.writeBytes(data, 0, len(data))


proc loadBytes*(self: Serializer, stream: seq[byte]): Serialized =
    ## Loads the result from dumpBytes to a Serializer object
    ## for use in the VM or for inspection
    discard self.newSerializer()
    new(result)
    result.chunk = newChunk()
    self.chunk = result.chunk
    var stream = stream
    try:
        stream = stream[self.readHeaders(stream, result)..^1]
        stream = stream[self.readLineData(stream)..^1]
        stream = stream[self.readCFIData(stream)..^1]
        stream = stream[self.readConstants(stream)..^1]
        stream = stream[self.readCode(stream)..^1]
    except IndexDefect:
        self.error("truncated bytecode stream")
    except AssertionDefect:
        self.error(&"corrupted bytecode stream: {getCurrentExceptionMsg()}")


proc loadFile*(self: Serializer, src: string): Serialized =
    ## Loads a bytecode file
    var fp = open(src, fmRead)
    defer: fp.close()
    let size = fp.getFileSize()
    var pos = 0'i64
    var data: seq[byte] = newSeqOfCap[byte](size)
    for _ in 0..<size:
        data.add(0)
    while pos < size:
        discard fp.readBytes(data, pos, size)
        pos = fp.getFilePos()
    return self.loadBytes(data)