#!/usr/bin/env python3
"""spice_units.py: Converts tuple of (unit, value) into standard unit numeric value."""

import re

# set of metric prefixes and the value needed to multiply by to
# get the "standard" unit for SPICE.  Only standard units will
# be written into the SPICE file, for reasons of universal
# compatibility.

prefixtypes = {
	"T": 1E12,  "tera" : 1E12,
	"G": 1E9,   "giga" : 1E9,
	"M": 1E6,   "mega" : 1E6,   "MEG": 1E6, "meg": 1E6,
	"K": 1E3,   "kilo" : 1E3,   "k":1E3,
	"D": 1E1,   "deca" : 1E1,
	"d": 1E-1,  "deci" : 1E-1,
	"c": 1E-2,  "centi": 1E-2,  "%": 1E-2,
	"m": 1E-3,  "milli": 1E-3,
	"u": 1E-6,  "micro": 1E-6,  "\u00b5": 1E-6, "ppm": 1E-6,
	"n": 1E-9,  "nano" : 1E-9,  "ppb": 1E-9,
	"p": 1E-12, "pico" : 1E-12, "ppt": 1E-12,
	"f": 1E-15, "femto": 1E-15,
	"a": 1E-18, "atto" : 1E-15,
}

# set of known unit types, including some with suffixes, along with a
# keyword that can be used to limit the search if an expected type for
# the value is known.  Keys are used in regular expressions, and so
# may use any regular expression syntax.

unittypes = {
	"[Ff]": "capacitance",
	"[Ff]arad[s]*": "capacitance",
	"\u03a9": "resistance", 
	"[Oo]hm[s]*": "resistance",
	"[Vv]": "voltage",
	"[Vv]olt[s]*": "voltage",
	"[Aa]": "current",
	"[Aa]mp[s]*": "current",
	"[Aa]mpere[s]*": "current",
	"[Ss]": "time",
	"[Ss]econd[s]*": "time",
	"[Hh]": "inductance",
	"[Hh]enry[s]*": "inductance",
	"[Hh]enries": "inductance",
	"[Hh]z": "frequency",
	"[Hh]ertz": "frequency",
	"[Mm]": "distance",
	"[Mm]eter[s]*": "distance",
	"[\u00b0]*[Cc]": "temperature",
	"[\u00b0]*[Cc]elsius": "temperature",
	"[\u00b0]*[Kk]": "temperature",
	"[\u00b0]*[Kk]elvin": "temperature",
	"[Ww]": "power",
	"[Ww]att[s]*": "power",
	"[Vv]-rms": "noise",
	"[Vv]olt[s]*-rms": "noise",
	"'[bohd]": "digital",
	"": "none"
}

# Convert string to either integer or float, with priority on integer
# If argument is not a string, just return the argument.

def numeric(s):
    if isinstance(s, str):
        try:
            return int(s)
        except ValueError:
            return float(s)
    else:
        return s

# Define how to convert SI units to spice values
#
# NOTE: spice_unit_unconvert can act on a tuple of (units, value) where
# value is either a single value or a list of values.  spice_unit_convert
# only acts on a tuple with a single value.  This is because the only large
# vectors are produced by ngspice, and these values need unconverting back
# into the units specified by the datasheet.  Values being converted to
# ngspice units are from the datasheet and are only computed a few at a
# time, so handling vectors is not particularly efficient.

def spice_unit_convert(valuet, restrict=[]):
    """Convert SI units into spice values"""
    # valuet is a tuple of (unit, value), where "value" is numeric
    # and "unit" is a string.  "restrict" may be used to require that
    # the value be of a specific class like "time" or "resistance". 

    # Recursive handling of '/' and multiplicatioon dot in expressions
    if '/' in valuet[0]:
        parts = valuet[0].split('/', 1)
        result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))
        result /= numeric(spice_unit_convert([parts[1], "1.0"], restrict))
        return str(result)

    if '\u22c5' in valuet[0]:	# multiplication dot
        parts = valuet[0].split('\u22c5')
        result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))
        result *= numeric(spice_unit_convert([parts[1], "1.0"], restrict))
        return str(result)

    if '\u00b2' in valuet[0]:	# squared
        part = valuet[0].split('\u00b2')[0]
        result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))
        result *= numeric(spice_unit_unconvert([part, "1.0"], restrict))
        return str(result)

    if valuet[0] == "":		# null case, no units
        return valuet[1]

    for unitrec in unittypes:	# case of no prefix
        if re.match('^' + unitrec + '$', valuet[0]):
            if restrict:
                if unittypes[unitrec] == restrict.lower():
                    return valuet[1]
            else:
                return valuet[1]

    for prerec in prefixtypes:
        for unitrec in unittypes:
            if re.match('^' + prerec + unitrec + '$', valuet[0]):
                if restrict:
                    if unittypes[unitrec] == restrict.lower():
                        newvalue = numeric(valuet[1]) * prefixtypes[prerec]
                        return str(newvalue)
                else:
                    newvalue = numeric(valuet[1]) * prefixtypes[prerec]
                    return str(newvalue)

    # Check for "%", which can apply to anything.
    if valuet[0][0] == '%':
        newvalue = numeric(valuet[1]) * 0.01
        return str(newvalue)
    
    if restrict:
        raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())
    else:
        # raise ValueError('units ' + valuet[0] + ' cannot be parsed')
        # (Assume value is not in SI units and will be passed back as-is)
        return valuet[1]

# Define how to convert spice values back into SI units

def spice_unit_unconvert(valuet, restrict=[]):
    """Convert spice values back into SI units"""
    # valuet is a tuple of (unit, value), where "value" is numeric
    # and "unit" is a string.  "restrict" may be used to require that
    # the value be of a specific class like "time" or "resistance". 

    # Recursive handling of '/' and multiplicatioon dot in expressions
    if '/' in valuet[0]:
        parts = valuet[0].split('/', 1)
        result = spice_unit_unconvert([parts[0], valuet[1]], restrict)
        if isinstance(result, list):
            result = list(item / spice_unit_unconvert([parts[1], 1.0],
			restrict) for item in result)
        else:
            result /= spice_unit_unconvert([parts[1], 1.0], restrict)
        return result

    if '\u22c5' in valuet[0]:	# multiplication dot
        parts = valuet[0].split('\u22c5')
        result = spice_unit_unconvert([parts[0], valuet[1]], restrict)
        if isinstance(result, list):
            result = list(item * spice_unit_unconvert([parts[1], 1.0],
			restrict) for item in result)
        else:
            result *= spice_unit_unconvert([parts[1], 1.0], restrict)
        return result

    if '\u00b2' in valuet[0]:	# squared
        part = valuet[0].split('\u00b2')[0]
        result = spice_unit_unconvert([part, valuet[1]], restrict)
        if isinstance(result, list):
            result = list(item * spice_unit_unconvert([part, 1.0],
			restrict) for item in result)
        else:
            result *= spice_unit_unconvert([part, 1.0], restrict)
        return result

    if valuet[0] == "":		# null case, no units
        return valuet[1]

    for unitrec in unittypes:	# case of no prefix
        if re.match('^' + unitrec + '$', valuet[0]):
            if restrict:
                if unittypes[unitrec] == restrict.lower():
                    return valuet[1]
            else:
                return valuet[1]

    for prerec in prefixtypes:
        for unitrec in unittypes:
            if re.match('^' + prerec + unitrec + '$', valuet[0]):
                if restrict:
                    if unittypes[unitrec] == restrict.lower():
                        if isinstance(valuet[1], list):
                            return list(item / prefixtypes[prerec] for item in valuet[1])
                        else:
                            return valuet[1] / prefixtypes[prerec]
                else:
                    if isinstance(valuet[1], list):
                        return list(item / prefixtypes[prerec] for item in valuet[1])
                    else:
                        return valuet[1] / prefixtypes[prerec]

    # Check for "%", which can apply to anything.
    if valuet[0][0] == '%':
        if isinstance(valuet[1], list):
            return list(item * 100 for item in valuet[1])
        else:
            return valuet[1] * 100
    
    if restrict:
        raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())
    else:
        # raise ValueError('units ' + valuet[0] + ' cannot be parsed')
        # (Assume value is not in SI units and will be passed back as-is)
        return valuet[1]