#!/usr/bin/env python3
#------------------------------------------------------------------------------
#
# run_spice_tests.py --
#
#    Run all ngspice tests, assuming an input file "devices.txt" containing,
#    with one entry per line:
#
#    <device_name>  <device_type>  <expected_value>
#
#    where <device_type> is one of:  mosfet, bipolar, capacitor, resistor, or diode.
#
#------------------------------------------------------------------------------

import re
import os
import sys
import subprocess
import multiprocessing

import find_all_devices

from plot_mosfet_iv import make_mosfet_iv_plot
from plot_bipolar_iv import make_bipolar_iv_plot
from plot_bipolar_beta import make_bipolar_beta_plot
from plot_diode_iv import make_diode_iv_plot

#------------------------------------------------------------------------------
# Enumerate capacitors that have additional shield pin connection
#------------------------------------------------------------------------------

four_pin_caps = [
	'sky130_fd_pr__cap_vpp_03p9x03p9_m1m2_shieldl1_floatm3',
	'sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2_shieldpo_floatm3',
	'sky130_fd_pr__cap_vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4',
	'sky130_fd_pr__cap_vpp_06p8x06p1_l1m1m2m3_shieldpom4',
	'sky130_fd_pr__cap_vpp_06p8x06p1_m1m2m3_shieldl1m4',
	'sky130_fd_pr__cap_vpp_08p6x07p8_l1m1m2_shieldpo_floatm3',
	'sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4',
	'sky130_fd_pr__cap_vpp_11p3x11p8_l1m1m2m3m4_shieldm5_nhv',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2_shieldpom3',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldm4',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldpom4',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldm5',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x',
	'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3_shieldl1m5_floatm4',
	'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldl1m5',
	'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldm5',
	'sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2_shieldm3_floatpo',
	'sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2m3m4_shieldpom5',
	'sky130_fd_pr__cap_vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4_r',
	'sky130_fd_pr__cap_vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4_top',
	'sky130_fd_pr__cap_vpp_06p8x06p1_l1m1m2m3_shieldpom4_r',
	'sky130_fd_pr__cap_vpp_06p8x06p1_l1m1m2m3_shieldpom4_top',
	'sky130_fd_pr__cap_vpp_06p8x06p1_l1m1m2m3m4_shieldpo_floatm5',
	'sky130_fd_pr__cap_vpp_06p8x06p1_m1m2m3_shieldl1m4_r',
	'sky130_fd_pr__cap_vpp_06p8x06p1_m1m2m3_shieldl1m4_top',
	'sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4_r',
	'sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4_top',
	'sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3m4_shieldpom5',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2_shieldpom3_r',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldm4_top',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldpom4_top',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldm5_r',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldm5_top',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_m5pullin',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_r',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_top',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x6',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x7',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x8',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x9',
	'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_xtop',
	'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3_shieldl1m5_floatm4_top',
	'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldl1m5_r',
	'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldl1m5_top',
	'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldm5_r'
]

five_pin_fets = [
	'sky130_fd_pr__nfet_20v0_iso',
	'sky130_fd_pr__nfet_20v0_nvt_iso',
	'sky130_fd_pr__nfet_20v0_reverse_iso'
]

#------------------------------------------------------------------------------
# Run ngspice on the indicated input file in the "results" directory.
#------------------------------------------------------------------------------

def runspice(scriptname, resultname, devicename, expectedval):
    print('Running ngspice on ' + scriptname)
    with subprocess.Popen(
            ['ngspice', scriptname],
            stdin= subprocess.DEVNULL,
            stdout = subprocess.PIPE,
            stderr = subprocess.PIPE,
            cwd = 'results',
            universal_newlines = True) as sproc:

        stdout, stderr = sproc.communicate()
        stdout = stdout.splitlines(True)
        stderr = stderr.splitlines(True)

        found = True if resultname == 'none' else False
        valueline = False
        returncode = 0
        reason = 'Success'

        for line in stdout:
            if line.strip('\n').strip() == '':
                continue
            print('Diagnostic:  ngspice output line is "' + line.strip('\n').strip() + '"')
            if valueline:
                try:
                    rvaluestring = line.split('=')[1].strip()
                except:
                    rvaluestring = line.strip('\n').strip()
                if rvaluestring != expectedval:
                    if expectedval == 'none':
                        returncode = rvaluestring
                    else:
                        print('Result error:  Expected "' + resultname + '" with value "' + expectedval + '" but got ' + rvaluestring)
                        reason = 'Expected "' + resultname + '" with value "' + expectedval + '" but got ' + rvaluestring
                        returncode = -1
                valueline = False

            elif resultname != 'none' and resultname in line:
                found = True
                valueline = True

        if stderr:
            errors = False
            messages = []
            for line in stderr:
                if len(line.strip()) > 0:
                    messages.append(line)
                    if 'error' in line.lower():
                        errors = True
            if errors:
                print('Execution error:  Ngspice returned error messages:')
                # Print errors.  Also try to pull the most relevant error message.
                for message in messages:
                    print(message)
                    if 'find model' in message.lower() or 'undefined' in message.lower() or 'unknown' in message.lower() or 'valid model' in message.lower() or 'many parameters' in message.lower() or 'few parameters' in message.lower():
                        reason = message
                if reason == 'Success':
                    for message in messages:
                        if 'error' in message.lower():
                            reason = message
                if reason == 'Success':
                    reason = message[0]
                returncode = -1
            else:
                print('Ngspice warnings:')
                for message in messages:
                    print(message)
        return_code = sproc.wait()
        if return_code != 0:
            print('Execution error:  Ngspice exited with error code ' + str(return_code))
            if reason == 'Success':
                reason = 'Ngspice exited with error code ' + str(return_code)
            return (-2, reason)

    if found:
        return (returncode, reason)
    else:
        print('Result error:  Expected result name ' + resultname + ' but did not receive it.')
        reason = 'Expected result name ' + resultname + ' but did not receive it.'
        return (-1, reason)

#------------------------------------------------------------------------------
# Read ".spice.in" file, replace DEVICENAME string with the device name,
# PDKVERSION with the version (v0.20.1), and CORNER with the simulation
# corner (tt), and write out as ".spice" file in "results" directory.
#------------------------------------------------------------------------------

def genspice(scriptname, devicename, version, corner):
    print('Generating simulation netlist for device ' + devicename)
    with open(scriptname + '.in', 'r') as ifile:
        spicelines = ifile.read().splitlines()

    # Some parameters to pass to the output
    # Default works for low-voltage FET devices

    params = 'W=3.0 L=0.15 M=1'

    if devicename == 'sky130_fd_pr__esd_nfet_01v8':
        params = 'W=20.35 L=0.165 M=1'
    elif devicename == 'sky130_fd_pr__esd_nfet_05v0_nvt':
        params = 'W=10 L=2 M=1'

    includelines = []
    pathtop = '../../libraries/sky130_fd_pr/' + version
    print("Diagnostic:  Running find_all_devices.do_find_all_devices()")
    incfiles = find_all_devices.do_find_all_devices(pathtop, None, devicename, feol=corner)
    for incfile in incfiles:
        if '.lib.spice' in incfile:
            includelines.append('.lib "../' + incfile + '" ' + corner)
        else:
            includelines.append('.include "../' + incfile + '"')

    outlines = []
    for line in spicelines:
        newline = line.replace('INCLUDELINES', '\n'.join(includelines))
        newline = newline.replace('DEVICENAME', devicename)
        newline = newline.replace('PDKVERSION', version)
        newline = newline.replace('CORNER', corner)
        newline = newline.replace('PARAMS', params)
        outlines.append(newline)

    with open('results/' + devicename + '.spice', 'w') as ofile:
        for line in outlines:
            print(line, file=ofile)

#------------------------------------------------------------------------------
# Run a spice simulation (or two) for the device specified in 'line' (obtained
# from the list of devices and expected values).
#------------------------------------------------------------------------------

def do_for_device(line):
    passes = []
    fails = []
    baseline_run = False
    baseline_entries = []
    reasons = {}

    devvals = line.split()

    # Capacitors
    cap1rex = re.compile('sky130_fd_pr__cap_mim.*')
    cap2rex = re.compile('sky130_fd_pr__cap.*')
    # Diodes (as subcircuits)
    diode1rex = re.compile('sky130_fd_pr__esd_rf_diode.*')
    # Diodes (as SPICE primitive devices)
    diode2rex = re.compile('sky130_fd_pr__diode.*')
    # Inductors
    indrex = re.compile('sky130_fd_pr__ind.*')
    # Resistors
    resrex = re.compile('sky130_fd_pr__res.*')
    # MOSFETs (p-type)
    pfet1rex = re.compile('sky130_fd_pr__esd_pfet.*')
    pfet2rex = re.compile('sky130_fd_pr__pfet.*')
    pfet3rex = re.compile('sky130_fd_pr__rf_pfet.*')
    pfet4rex = re.compile('sky130_fd_pr__special_pfet.*')
    # MOSFETs (n-type)
    nfet1rex = re.compile('sky130_fd_pr__esd_nfet.*')
    nfet2rex = re.compile('sky130_fd_pr__nfet.*')
    nfet3rex = re.compile('sky130_fd_pr__rf_nfet.*')
    nfet4rex = re.compile('sky130_fd_pr__special_nfet.*')
    # Bipolars (PNP)
    pnp1rex = re.compile('sky130_fd_pr__pnp.*')
    pnp2rex = re.compile('sky130_fd_pr__rf_pnp.*')
    # Bipolars (NPN)
    npn1rex = re.compile('sky130_fd_pr__rf_npn.*')
    npn2rex = re.compile('sky130_fd_pr__npn.*')

    devicename = devvals[0]

    # NOTE:  When a line in the device list does not have an entry
    # for expected value, then this is a baseline run, and will
    # dump the device name and output measured to a file
    # 'devices_baseline.txt'

    try:
        expectedval = devvals[1]
    except:
        baseline_run = True
    else:
        baseline_run = False

    # Determine the device type from the name
    # (to do:  Pull additional information about the device from the name)
    # (also to do:  separate nmos/pmos testbenches and pnp/npn testbenches)

    if indrex.match(devicename):
        devicetype = 'inductor'
    elif cap1rex.match(devicename):
        devicetype = 'mimcap'
    elif cap2rex.match(devicename):
        if devicename in four_pin_caps:
            devicetype = 'capacitor4pin'
        else:
            devicetype = 'capacitor'
    elif diode1rex.match(devicename):
        devicetype = 'diode'
    elif diode2rex.match(devicename):
        devicetype = 'diode_dev'
    elif nfet1rex.match(devicename):
        devicetype = 'nfet'
    elif nfet2rex.match(devicename):
        devicetype = 'nfet'
    elif nfet3rex.match(devicename):
        devicetype = 'nfet'
    elif nfet4rex.match(devicename):
        devicetype = 'nfet'
    elif pfet1rex.match(devicename):
        devicetype = 'pfet'
    elif pfet2rex.match(devicename):
        devicetype = 'pfet'
    elif pfet3rex.match(devicename):
        devicetype = 'pfet'
    elif pfet4rex.match(devicename):
        devicetype = 'pfet'
    elif pnp1rex.match(devicename):
        devicetype = 'pnp'
    elif pnp2rex.match(devicename):
        devicetype = 'pnp'
    elif npn1rex.match(devicename):
        devicetype = 'npn'
    elif npn2rex.match(devicename):
        devicetype = 'npn'
    elif resrex.match(devicename):
        devicetype = 'resistor'

    if devicetype == 'nfet':
        if devicename in five_pin_fets:
            devicetype = 'nfet5term'

    try:
        print('Diagnostic:  Determined device ' + devicename + ' to be type ' + devicetype)
    except:
        print('Unknown device type for device name ' + devicename + '.  Cannot simulate.')
        reasons[devicename] = 'Unknown device type for device name ' + devicename + '.  Cannot simulate.'
        fails.append(devicename)
        return (passes, fails, baseline_entries, reasons)

    if baseline_run:
        expectedval = 'none'

    if devicetype == 'nfet' or devicetype == 'nfet5term' or devicetype == 'pfet':
        genspice(devicetype + '_vth.spice', devicename, version, corner)
        (result, reason) = runspice(devicename + '.spice', 'threshold voltage', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)
        if result != -2:
            make_mosfet_iv_plot(devicename, version, corner)

    elif devicetype == 'npn' or devicetype == 'pnp':
        genspice(devicetype + '_beta.spice', devicename, version, corner)
        (result, reason) = runspice(devicename + '.spice', 'maximum beta', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)
        if result != -2:
            make_bipolar_iv_plot(devicename, version, corner)
            make_bipolar_beta_plot(devicename, version, corner)

    elif devicetype == 'mimcap':
        genspice('mimcap_test.spice', devicename, version, corner)
        (result, reason) = runspice(devicename + '.spice', 'capacitance', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)

    elif devicetype == 'capacitor':
        genspice('capval_test.spice', devicename, version, corner)
        (result, reason) = runspice(devicename + '.spice', 'capacitance', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)

    elif devicetype == 'capacitor4pin':
        genspice('cap4termval_test.spice', devicename, version, corner)
        (result, reason) = runspice(devicename + '.spice', 'capacitance', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)

    elif devicetype == 'resistor':
        genspice('resval_test.spice', devicename, version, corner)
        (result, reason) = runspice(devicename + '.spice', 'resistance', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)

    elif devicetype == 'inductor':
        genspice('inductor_test.spice', devicename, version, corner)
        (result, reason) = runspice(devicename + '.spice', 'inductance', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)

    elif devicetype == 'diode' or devicetype == 'diode_dev':
        genspice(devicetype + '_vth.spice', devicename, version, corner)
        (result, reason) = runspice(devicename + '.spice', 'threshold voltage', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)
        if result != -2:
            make_diode_iv_plot(devicename, version, corner)

    return (passes, fails, baseline_entries, reasons)

#------------------------------------------------------------------------------
# Main script starts here (no arguments, at least for now)
#------------------------------------------------------------------------------

if __name__ == "__main__":

    if not os.path.exists('results'):
        os.makedirs('results')

    # To do:  Loop through version and corner.  For now, fixed.
    version = 'v0.20.1'
    corner = 'tt'

    # Original method:  List of devices was in file devices.txt.  If an argument
    # is passed to the program, then use it as the list of devices to process.
    # To get the original behavior, use "run_spice_tests.py devices.txt".

    devicelist = []
    if len(sys.argv) > 1:
        with open(sys.argv[1]) as ifile:
            ilines = ifile.read().splitlines()
        for line in ilines:
            if not line.strip().startswith('#'):
                devicelist.append(line.strip())
    else:
        # Prepare list of devices by scanning the model and cell directories.
        pathtop = '../../libraries/sky130_fd_pr/' + version
        (filesdict, subcktdict, includedict, modfilesdict) = find_all_devices.find_everything(pathtop)
        for key in subcktdict:
            devicelist.append(key)

    passes = []
    fails = []
    baseline_entries = []
    reasons = {}

    # Allow ngspice runs to happen in parallel.
    with multiprocessing.Pool() as pool:
        results = []

        for device in devicelist:
            results.append(pool.apply_async(do_for_device, (device,)))

        for r in results:
            (newpasses, newfails, new_baseline_entries, new_reasons) = r.get(timeout=120)

            passes.extend(newpasses)
            fails.extend(newfails)
            baseline_entries.extend(new_baseline_entries)
            reasons.update(new_reasons)

    # Output which devices passed and failed

    print()
    print('Simulation summary:')

    print()
    print('Passing devices:')
    for passing in passes:
        print(passing)

    print()
    print('Failing devices:')
    for failing in fails:
        print(failing)
        print('   Reason: ' + reasons[failing])

    # Output pass / fail summary

    print()
    print('Final results:')
    print('Passes: ' + str(len(passes)))
    print('Fails:  ' + str(len(fails)))

    # Repeat the summary in a file "output.log"

    with open('output.log', 'w') as ofile:
        print('Simulation summary:', file=ofile)

        print('', file=ofile)
        print('Passing devices:', file=ofile)
        for passing in passes:
            print(passing, file=ofile)

        print('', file=ofile)
        print('Failing devices:', file=ofile)
        for failing in fails:
            print(failing, file=ofile)
            print('   Reason: ' + reasons[failing], file=ofile)

        # Output pass / fail summary

        print('', file=ofile)
        print('Final results:', file=ofile)
        print('Passes: ' + str(len(passes)), file=ofile)
        print('Fails:  ' + str(len(fails)), file=ofile)

    # Output baseline values if any were generated

    if len(baseline_entries) > 0:
        with open('baseline_results.txt', 'w') as ofile:
            for entry in baseline_entries:
                print(entry, file=ofile)

    if len(fails) > 0:
        sys.exit(1)
    else:
        sys.exit(0)