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

import strformat
import strutils
import nimSHA2
import 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
        fileHash*: string
        peonVer*: tuple[major, minor, patch: int]
        peonBranch*: string
        commitHash*: string
        compileDate*: int
        chunk*: Chunk


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


proc error(self: Serializer, message: string) =
    ## Raises a formatted SerializationError exception
    raise newException(SerializationError,
            &"A fatal error occurred while (de)serializing '{self.filename}' -> {message}")


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


## Basic routines and helpers to convert various objects from and to to their byte representation

proc toBytes(self: Serializer, s: string): seq[byte] =
    for c in s:
        result.add(byte(c))


proc toBytes(self: Serializer, s: int): array[8, uint8] =
    result = cast[array[8, uint8]](s)


proc toBytes(self: Serializer, d: SHA256Digest): seq[byte] =
    for b in d:
        result.add(b)


proc bytesToString(self: Serializer, input: seq[byte]): string =
    for b in input:
        result.add(char(b))


proc extend[T](s: var seq[T], a: openarray[T]) =
    ## Extends s with the elements of a
    for e in a:
        s.add(e)


proc writeHeaders(self: Serializer, stream: var seq[byte], file: string) =
    ## Writes the Peon bytecode headers in-place into a byte stream
    stream.extend(self.toBytes(BYTECODE_MARKER))
    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(self.toBytes(PEON_BRANCH))
    stream.extend(self.toBytes(PEON_COMMIT_HASH))
    stream.extend(self.toBytes(getTime().toUnixFloat().int()))
    stream.extend(self.toBytes(computeSHA256(file)))


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 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(BYTECODE_MARKER)] != self.toBytes(BYTECODE_MARKER):
        self.error("malformed bytecode marker")
    result += len(BYTECODE_MARKER)
    stream = stream[len(BYTECODE_MARKER)..^1]
    serialized.peonVer = (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.peonBranch = self.bytesToString(stream[0..<branchLength])
    stream = stream[branchLength..^1]
    result += int(branchLength)
    serialized.commitHash = self.bytesToString(stream[0..<40]).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
    serialized.fileHash = self.bytesToString(stream[0..<32]).toHex().toLowerAscii()
    result += 32


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 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, file, filename: string): seq[byte] =
    ## Dumps the given bytecode and file to a sequence of bytes and returns it.
    ## The file argument must be the actual file's content and is needed to 
    ## compute its SHA256 hash.
    self.file = file
    self.filename = filename
    self.chunk = chunk
    self.writeHeaders(result, self.file)
    self.writeLineData(result)
    self.writeConstants(result)
    self.writeCode(result)


proc dumpFile*(self: Serializer, chunk: Chunk, file, 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, file, 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.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)