#!/usr/bin/env python3
"""Runs test within Qemu and Renode simulators."""
import argparse
import os
import sys
import tempfile

import io
import pexpect


parser = argparse.ArgumentParser(
    description="Run a springbok test on an simulator.")

parser.add_argument('simulator',
                    help='Select a simulator',
                    choices=['renode', 'qemu'])
parser.add_argument('elf',
                    help='Elf to execute on a simulator')
parser.add_argument('--renode-path',
                    help="Path to renode simulator")
parser.add_argument('--qemu-path',
                    help="Path to qemu simulator")
parser.add_argument('--timeout', type=int,
                    help="Timeout for test", default=1000)

class Simulation: # pylint: disable=too-few-public-methods
    """ Base class for simulation """
    def __init__(self, simulator_cmd):
        self.simulator_cmd = simulator_cmd
        self.buffer = io.StringIO()
        self.child = None

    def run(self, timeout=1000):
        """ Run the simulation command and quit the simulation."""
        self.child = pexpect.spawn(self.simulator_cmd, encoding='utf-8')
        self.child.logfile = self.buffer
        self.child.expect("main returned", timeout=timeout)
        self.child.send("\nq\n")
        self.child.expect(pexpect.EOF, timeout=timeout)
        self.child.close()
        self.buffer.seek(0)
        return self.buffer.read()

class QemuSimulation(Simulation): # pylint: disable=too-few-public-methods
    """ Qemu simulation """
    def __init__(self, path, elf):
        self.qemu_simulator_cmd = (
            "%(sim)s -M springbok -nographic -d springbok -device loader,file=%(elf)s")
        self.sim_params = {"sim": path, "elf": elf}
        super().__init__(self.qemu_simulator_cmd % self.sim_params)


class RenodeSimulation(Simulation): # pylint: disable=too-few-public-methods
    """ Renode Simulation """
    def __init__(self, path, elf):
        # TODO(henryherman): Look at using repl platform file.
        renode_script = """
mach create "springbok"
machine LoadPlatformDescriptionFromString "cpu: CPU.SpringbokRiscV32 @ sysbus"
machine LoadPlatformDescriptionFromString "ram_vec_imem: Memory.MappedMemory @ sysbus 0x30000000 {size: 0x00040000}"
machine LoadPlatformDescriptionFromString "ram_vec_dmem: Memory.MappedMemory @ sysbus 0x34000000 {size: 0x00400000}"
sysbus LoadELF @%s
sysbus.cpu PC 0x30000000
sysbus.cpu IsHalted False
start"""
        self.renode_script = renode_script % elf

        self.renode_args = [
            "mono",
            "%s" % path,
            '--disable-xwt',
            ' --console',
            '--plain',
        ]
        self.renode_simulator_cmd = " ".join(self.renode_args)
        super().__init__(self.renode_simulator_cmd)

    def run(self, timeout=120):
        file_desc, script_path = tempfile.mkstemp(suffix=".resc")
        try:
            with os.fdopen(file_desc, 'w') as tmp:
                tmp.write(self.renode_script)
                tmp.flush()
            self.simulator_cmd += " %s" % script_path
            test_output = super().run()
        finally:
            os.remove(script_path)
        return test_output


Simulators = {
    "qemu": QemuSimulation,
    "renode": RenodeSimulation
}

args = parser.parse_args()

simulators_paths = {
    "renode": args.renode_path,
    "qemu": args.qemu_path
}


def main():
    """ Run a test and check for Pass or Fail """
    simulator_path = simulators_paths[args.simulator]
    if simulator_path is None:
        parser.error(
            "Must provide path to simulator %s, use argument --%s-path" % (args.simulator,
                                                                           args.simulator))

    simulator_class = Simulators[args.simulator]
    simulator = simulator_class(simulator_path, args.elf)
    output = simulator.run(timeout=args.timeout)
    print(output)
    if "FAILED" in output:
        sys.exit(1)


if __name__ == "__main__":
    main()