import atexit
import getopt
import os
import subprocess
import signal
import sys
import time
import pathlib
import platform

progname = sys.argv[0]

diagnostics = False
quiet = False
verbose = False

port = 80
machine = "eecs-digital-56.mit.edu"
projectdir = "."
of = "obj"

p = False

user = "builder"
outfile = f"{of}/out.bit"
logfile = f"{of}/build.log"

synthrpt = [
    "report_timing",
    "report_timing_summary",
    "report_utilization",
]

placerpt = synthrpt.copy()
placerpt.extend(["report_clock_utilization"])

routerpt = [
    "report_drc",
    "report_power",
    "report_route_status",
    "report_timing",
    "report_timing_summary",
]

usagestr = f"""
{progname}: build SystemVerilog code remotely for 2022 6.205 labs
usage: {progname} [-dqv] [-m machine] [-p projectdir] [-o dir]
options:
	-d: emit additional diagnostics during synthesis/implementation
	-q: quiet: do not generate any vivado logs except for errors.
	-v: be verbose (for debugging stuffs / if you see a bug)
	-m: override the DNS name queried to perform the build. use with care.
	-p: build the project located in projectdir (default is '.')
	-o: set the output products directory (default is {of})
"""


def debuglog(s):
    if verbose:
        print(s)


def usage():
    print(usagestr)
    sys.exit(1)


def getargs():
    global diagnostics
    global quiet
    global machine
    global logfile
    global outfile
    global projectdir
    global of
    global verbose

    try:
        opts, args = getopt.getopt(sys.argv[1:], "dm:o:p:qv")
    except getopt.GetoptError as err:
        print(err)
        usage()

    if args:
        usage()
    for o, v in opts:
        if o == "-d":
            diagnostics = True
        elif o == "-q":
            quiet = True
        elif o == "-m":
            machine = v
        elif o == "-p":
            projectdir = v
        elif o == "-o":
            of = v
        elif o == "-v":
            verbose = True
        else:
            print(f"unrecognized option {o}")
            usage()

    outfile = f"{of}/out.bit"
    logfile = f"{of}/build.log"


def make_posix(path):
    return str(pathlib.Path(path).as_posix())


def regfiles():
    ftt = {}
    debuglog(f"projectdir is {projectdir}")
    for dirpath, subdirs, files in os.walk(projectdir):
        if (
            "src" not in dirpath
            and "xdc" not in dirpath
            and "data" not in dirpath
            and "ip" not in dirpath
        ):
            continue
        if dirpath.startswith("./"):
            dirpath = dirpath[2:]
        for file in files:
            fpath = os.path.join(dirpath, file)
            debuglog(f"considering {fpath}")
            fpath = make_posix(fpath)

            if file.lower().endswith(".v"):
                ftt[fpath] = "source"
            elif file.lower().endswith(".sv"):
                ftt[fpath] = "source"
            elif file.lower().endswith(".vh"):
                ftt[fpath] = "source"
            elif file.lower().endswith(".svh"):
                ftt[fpath] = "source"
            elif file.lower().endswith(".xdc"):
                ftt[fpath] = "xdc"
            elif file.lower().endswith(".mem"):
                ftt[fpath] = "mem"
            elif file.lower().endswith(".xci"):
                ftt[fpath] = "ip"
            elif file.lower().endswith(".prj"):
                ftt[fpath] = "mig"

    debuglog(f"elaborated file list {ftt}")
    return ftt


# messages are newline delineated per lab-bs.1
# utilize this to cheat a little bit
def spqsend(p, msg):
    debuglog(f"writing {len(msg)} bytes over the wire")
    debuglog(f"full message: {msg}")
    p.stdin.write(msg + b"\n")
    p.stdin.flush()


def spsend(p, msg):
    debuglog(f"running {msg}")
    p.stdin.write((msg + "\n").encode())
    p.stdin.flush()


def sprecv(p):
    l = p.stdout.readline().decode()
    debuglog(f"got {l}")
    return l


def xsprecv(p):
    l = sprecv(p)
    if l.startswith("ERR"):
        print("received unexpected server error!")
        print(l)
        sys.exit(1)
    return l


def spstart(xargv):
    debuglog(f"spawning {xargv}")
    p = subprocess.PIPE
    return subprocess.Popen(xargv, stdin=p, stdout=p, stderr=p)


def copyfiles(p, ftt):
    for f, t in ftt.items():
        fsize = os.path.getsize(f)
        with open(f, "rb") as fd:
            spsend(p, f"write {f} {fsize}")
            time.sleep(0.1)  # ?
            spqsend(p, fd.read())
            xsprecv(p)

            spsend(p, f"type {f} {t}")
            xsprecv(p)


# size message returns ... %zu bytes
def readfile(p, file, targetfile):
    spsend(p, f"size {file}")
    size = int(xsprecv(p).split()[-2])
    spsend(p, f"read {file}")

    with open(targetfile, "wb+") as fd:
        fd.write(p.stdout.read(size))

    xsprecv(p)


def build(p):
    cmd = "build"
    if diagnostics:
        cmd += " -d"
    if quiet:
        cmd += " -q"
    cmd += f" obj"

    print(f"Output target will be {outfile}")

    spsend(p, cmd)
    print("Building your code ... (this may take a while, be patient)")
    result = sprecv(p)

    if result.startswith("ERR"):
        print("Something went wrong!")
    else:
        readfile(p, "obj/out.bit", outfile)
        print(f"Build succeeded, output at {outfile}")

    readfile(p, "obj/build.log", logfile)
    print(f"Log file available at {logfile}")

    if diagnostics:
        for rpt in synthrpt:
            readfile(p, f"obj/synthrpt_{rpt}.rpt", f"{of}/synthrpt_{rpt}.rpt")
        for rpt in placerpt:
            readfile(p, f"obj/placerpt_{rpt}.rpt", f"{of}/placerpt_{rpt}.rpt")
        for rpt in routerpt:
            readfile(p, f"obj/routerpt_{rpt}.rpt", f"{of}/routerpt_{rpt}.rpt")
        print(f"Diagnostics available in {of}")


def main():
    global p
    getargs()
    ftt = regfiles()

    if not os.path.isdir(of):
        print(f"output path {of} does not exist! create it or use -o?")
        usage()

    if platform.system() == "Darwin" or platform.system() == "Linux":
        xargv = [
            "ssh",
            "-p",
            f"{port}",
            "-o",
            "StrictHostKeyChecking=no",
            "-o",
            "UserKnownHostsFile=/dev/null",
        ]

    elif platform.system() == "Windows":
        xargv = [
            "ssh",
            "-p",
            f"{port}",
            "-o",
            "StrictHostKeyChecking=no",
            "-o",
            "UserKnownHostsFile=nul",
        ]

    else:
        raise RuntimeError(
            "Your OS is not recognized, unsure of how to format SSH command."
        )

    xargv.append(f"{user}@{machine}")
    p = spstart(xargv)

    spsend(p, "help")
    result = xsprecv(p)
    debuglog(result)

    copyfiles(p, ftt)
    build(p)
    spsend(p, "exit")
    p.wait()


if __name__ == "__main__":
    try:
        main()
    except (Exception, KeyboardInterrupt) as e:
        if p:
            debuglog("killing ssh")
            os.kill(p.pid, signal.SIGINT)
            p.wait()
        raise e