from utils import Colors, init_interpret, ParseFlags
from opcodes import WASM_OP_Code
from section_structs import Code_Section, Func_Body, WASM_Ins, Resizable_Limits, Memory_Section
from execute import *
import datetime as dti
import os
import sys
import signal


# McCabe cyclomatic complexity metric
class Metric():
    def __init__(self, code_section):
        self.code_section = code_section
        self.metric = []
        self.soc = []

    def mccabe(self):
        soc = 0
        Edges = 1
        Nodes = 1
        for funcs in self.code_section.func_bodies:
            for ins in funcs.code:
                soc += 1
                #print(repr(ins.opcodeint))
                if ins.opcodeint == 4 or ins.opcodeint == 5 or ins.opcodeint == 12 \
                    or ins.opcodeint == 13 or ins.opcodeint == 14:
                    Nodes += 2
                    Edges += 4
                elif ins.opcode == 3:
                    Nodes += 2
                    Edges += 3
                else:
                    pass

            self.metric.append(Edges - Nodes + 1)
            self.soc.append(soc)
            soc = 0
            Edges = 1
            Nodes = 1

    def getMcCabe(self):
        return self.metric

    def getSOC(self):
        return self.soc


# handles the debug option --memdump. dumps the contents of linear memories.
def DumpLinearMems(linear_memories, threshold):
    count = int()
    strrep = []
    linmem_cnt = int()
    for lin_mem in linear_memories:
        print('-----------------------------------------')
        print(Colors.blue + Colors.BOLD + 'Linear Memory '+ repr(linmem_cnt)+ ' :' + Colors.ENDC)
        for byte in lin_mem:
            if count >= threshold:
                break
            if count%16 == 0:
                for ch in strrep:
                    # @DEVI-line feed messes the pretty format up
                    if ord(ch) != 10:
                        print(Colors.green + ' ' + ch + Colors.ENDC, end = '')
                    else:
                        pass
                print()
                strrep = []
                print(Colors.cyan + hex(count), ':\t' + Colors.ENDC, end='')
                strrep.append(str(chr(byte)))
                print(Colors.blue + format(byte, '02x') + ' ' + Colors.ENDC, end='')
            else:
                strrep += str(chr(byte))
                print(Colors.blue + format(byte, '02x') + ' ' + Colors.ENDC, end='')
            count += 1
        count = 0
    print()


# handles the debug options --idxspc. dumps the index spaces.
def DumpIndexSpaces(machinestate):
    print('-----------------------------------------')
    print(Colors.green + 'Function Index Space: ' + Colors.ENDC)
    for iter in machinestate.Index_Space_Function:
        print(Colors.blue + repr(iter) + Colors.ENDC)

    print('-----------------------------------------')
    print(Colors.green + 'Globa Index Space: ' + Colors.ENDC)
    for iter in machinestate.Index_Space_Global:
        print(Colors.blue + repr(iter) + Colors.ENDC)

    print('-----------------------------------------')
    print(Colors.green + 'Linear Memory Index Space: ' + Colors.ENDC)
    for iter in machinestate.Index_Space_Linear:
        print(Colors.blue + repr(iter) + Colors.ENDC)

    print('-----------------------------------------')
    print(Colors.green + 'Table Index Space: ' + Colors.ENDC)
    for iter in machinestate.Index_Space_Table:
        print(Colors.blue + repr(iter) + Colors.ENDC)
    print('-----------------------------------------')


# WIP-the Truebit Machine class
class TBMachine():
    def __init__(self):
        # bytearray of size PAGE_SIZE
        self.Linear_Memory = []
        self.Stack_Label = list()
        self.Stack_Label_Height = int()
        self.Stack_Control_Flow = list()
        self.Stack_Call = list()
        self.Stack_Value = list()
        self.Stack_Omni = list()
        self.Vector_Globals = list()
        self.Index_Space_Function = list()
        self.Index_Space_Global = list()
        self.Index_Space_Linear = list()
        self.Index_Space_Table = list()
        self.Index_Space_Locals = list()
        self.Index_Space_Label = list()


# handles the initialization of the WASM machine
class TBInit():
    def __init__(self, module, machinestate):
        self.module = module
        self.machinestate = machinestate

    # a convenience function that runs the methods of the class. all methods
    # can be called separately manually as well.
    def run(self):
        self.InitFuncIndexSpace()
        self.InitGlobalIndexSpace()
        self.InitLinearMemoryIndexSpace()
        self.InitTableIndexSpace()
        self.InitializeLinearMemory()

    def InitFuncIndexSpace(self):
        if self.module.import_section is not None:
            for iter in self.module.import_section.import_entry:
                if iter.kind == 0:
                    name = str()
                    for i in iter.field_str:
                        name += str(chr(i))
                    self.machinestate.Index_Space_Function.append(name)

        if self.module.function_section is not None:
            for iter in self.module.function_section.type_section_index:
                self.machinestate.Index_Space_Function.append(iter)

    def InitGlobalIndexSpace(self):
        if self.module.import_section is not None:
            for iter in self.module.import_section.import_entry:
                if iter.kind == 3:
                    name = str()
                    for i in iter.field_str:
                        name += str(chr(i))
                    self.machinestate.Index_Space_Global.append(name)

        if self.module.global_section is not None:
            for iter in self.module.global_section.global_variables:
                self.machinestate.Index_Space_Global.append(iter.init_expr)

    def InitLinearMemoryIndexSpace(self):
        if self.module.import_section is not None:
            for iter in self.module.import_section.import_entry:
                if iter.kind == 2:
                    name = str()
                    for i in iter.field_str:
                        name += str(chr(i))
                    self.machinestate.Index_Space_Linear.append(name)

        if self.module.memory_section is not None:
            for iter in self.module.memory_section.memory_types:
                self.machinestate.Index_Space_Linear.append(iter.initial)

    def InitTableIndexSpace(self):
        if self.module.import_section is not None:
            for iter in self.module.import_section.import_entry:
                if iter.kind == 1:
                    name = str()
                    for i in iter.field_str:
                        name += str(chr(i))
                    self.machinestate.Index_Space_Table.append(name)

        if self.module.table_section is not None:
            for iter in self.module.table_section.table_types:
                self.machinestate.Index_Space_Table.append(iter.element_type)

    def InitializeLinearMemory(self):
        # @DEVI-we could try to pack the data in the linear memory ourselve to
        # decrease the machinestate size
        if self.module.memory_section is None:
            rsz_limits = Resizable_Limits()
            self.module.memory_section = Memory_Section()
            self.module.memory_section.memory_types = [rsz_limits]
            self.module.memory_section.count = 1
        for iter in self.module.memory_section.memory_types:
            self.machinestate.Linear_Memory.append(bytearray(
                WASM_OP_Code.PAGE_SIZE))
        if self.module.data_section is not None:
            for iter in self.module.data_section.data_segments:
                count = int()
                for byte in iter.data:
                    self.machinestate.Linear_Memory[iter.index][init_interpret(iter.offset) + count] = byte
                    count += 1

    # returns the machinestate
    def getInits(self):
        return(self.machinestate)


# WIP-holds the run-rime data structures for a wasm machine
class RTE():
    def __init__(self):
        Stack_Control_Flow = list()
        Stack_Value = list()
        Vector_Locals = list()
        Current_Position = int()
        Local_Stacks = list()

    def genFuncLocalStack(func_body):
        pass


# palceholder for the class that holds the validation functions
class ModuleValidation():
    def __init__(self, module):
        self.module = module

    def TypeSection(self):
        pass

    def ImportSection(self):
        pass

    def FunctionSection(self):
        pass

    def TableSection(self):
        pass

    def MemorySection(self):
        pass

    def GlobalSection(self):
        pass

    def ExportSection(self):
        pass

    def StartSection(self):
        pass

    def ElementSection(self):
        pass

    def CodeSection(self):
        pass

    def DataSection(self):
        pass

    def TBCustom(self):
        pass

    def ValidateAll(self):
        self.TypeSection()
        self.ImportSection()
        self.FunctionSection()
        self.TableSection()
        self.MemorySection()
        self.GlobalSection()
        self.ExportSection()
        self.StartSection()
        self.ElementSection()
        self.CodeSection()
        self.DataSection()
        self.TBCustom()

        return(True)


# a convinience class that handles the initialization of the wasm machine and
# interpretation of the code.
class VM():
    def __init__(self, modules):
        self.modules = modules
        self.machinestate = TBMachine()
        # @DEVI-FIXME- the first implementation is single-module only
        self.init = TBInit(self.modules[0], self.machinestate)
        self.init.run()
        self.machinestate = self.init.getInits()
        self.start_function = Func_Body()
        self.ins_cache = WASM_Ins()
        self.executewasm = Execute(self.machinestate)
        self.totGas = int()
        self.metric = Metric(modules[0].code_section)
        self.parseflags = None

    def setFlags(self, parseflags):
        self.parseflags = parseflags

    def getState(self):
        return(self.machinestate)

    def initLocalIndexSpace(self, local_count):
        for i in range(0, local_count):
            self.machinestate.Index_Space_Locals.append(0)

    def getStartFunctionIndex(self):
        if self.modules[0].start_section is None:
            if self.parseflags.entry is None:
                raise Exception(Colors.red + "module does not have a start section. no function index was provided with the --entry option.quitting..." + Colors.ENDC)
            else:
                start_index = int(self.parseflags.entry)
        else:
            print(Colors.green + "found start section: " + Colors.ENDC, end = '')
            start_index = self.modules[0].start_section.function_section_index

        print(Colors.blue + Colors.BOLD + "running function at index " + repr(start_index) + Colors.ENDC)
        if (start_index > len(self.modules[0].code_section.func_bodies) - 1):
            raise Exception(Colors.red + "invalid function index: the function index does not exist." + Colors.ENDC)
        return(start_index)

    def getStartFunctionBody(self):
        start_index = self.getStartFunctionIndex()
        if isinstance(start_index, int):
            self.start_function = self.modules[0].code_section.func_bodies[start_index]
        elif isinstance(start_index, str):
            # we have to import the function from another module/library. we
            # assume sys calls are not present.:w
            pass
        else:
            raise Exception(Colors.red + "invalid entry for start function index" + Colors.ENDC)

    def execute(self):
        print(Colors.blue + Colors.BOLD + 'running module with code: ' + Colors.ENDC)
        for ins in self.start_function.code:
            print(Colors.purple + repr(ins.opcode) + ' ' + repr(ins.operands) + Colors.ENDC)
        for ins in self.start_function.code:
            self.executewasm.getInstruction(ins.opcodeint, ins.operands)
            self.executewasm.callExecuteMethod()
            self.getState()

    # pre-execution hook
    def startHook(self):
        if self.parseflags.metric:
            for mem in self.modules[0].memory_section.memory_types:
                self.executewasm.chargeGasMem(mem.initial)

            self.metric.mccabe()
            print(Colors.red + "mccabe: " + repr(self.metric.getMcCabe()) + Colors.ENDC)
            print(Colors.red + "soc: " + repr(self.metric.getSOC()) + Colors.ENDC)

    # post-execution hook
    def endHook(self):
        if self.parseflags.gas:
            self.totGas = self.executewasm.getOPGas()
            print(Colors.red + "total gas cost: " + repr(self.totGas) + Colors.ENDC)
        if self.machinestate.Stack_Omni:
            print(Colors.green + "stack top: " + repr(self.machinestate.Stack_Omni.pop()) + Colors.ENDC)

    # a convinience method
    def run(self):
        self.startHook()
        self.getStartFunctionBody()
        self.initLocalIndexSpace(self.start_function.local_count)
        self.execute()
        self.endHook()


# a wrapper class for VM. it timeouts instructions that take too long to
# execute.
class Judicator():
    def __int__(self, op_time_table, module):
        self.op_time_table = op_time_table
        self.vm = VM(modules)
        self.vm.getStartFunctionBody()

    def overseer():
        # @DEVI- forking introduces a new source of non-determinism
        pid = os.fork()
        # child process
        if pid == 0:
            sys.stdout = open('./jstdout', 'w')
            sys.stderr = open('./jstderr', 'w')
            self.vm.execute()
            sys.exit()
        # parent process
        if pid > 0:
            cpid, status = os.waitpid(pid, 0)
            if status == 0:
                print('overseer child exited successfully.')
            else:
                print('overseer child exited with non-zero.')
        # pid < 0
        else:
            raise Exception(Colors.red + 'could not fork judicator overseer.' + Colors.ENDC)

    def setup(self):
        signal.signal(signal.SIGALRM, self.to_sighandler)

    def set_alarm(t):
        signal.alaram(t)

    def to_sighandler(signum, frame):
        print(Colors.red + "execution time out..." + Colors.ENDC)
        raise Exception(Colors.red + "execution time out" + Colors.ENDC)

    def run(self):
        self.setup()
        self.set_alaram(10)
        self.overseer()