import sys
from typing import Optional
from string import Template    
    
class Keithley_SCPI:    
    
    ### private #####################################################################      
    
    # _fm ... function_mode
    def _fm(unit: Optional[str], function: str) -> dict:
        return {'unit': unit, 'function': function}  
    
    _modes: dict[str, dict[Optional[str], str]] = {
        "DCV":      _fm("V",   "VOLTage:DC"),
        "DCI":      _fm("A",   "CURRent:DC"),
        "ACV":      _fm("V",   "VOLTage:AC"),
        "ACI":      _fm("A",   "CURRent:AC"),
        "2W":       _fm("Ω",   "RESistance"),
        "4W":       _fm("Ω",   "FRESistance"),
        "Freq":     _fm("Hz",  "FREQuency"),
        "Period":   _fm("s",   "PERiod"),
        "Diode":    _fm("V",   "DIODe"),
        "Temp":     _fm("°C",  "TEMPerature"),
        "Cap":      _fm("F",   "CAPacitance"),
        "Digi V":   _fm("V",   "VOLTage"),
        "Digi I":   _fm("A",   "CURRent")
    }
    
    #################################################################################    
                   
    # erweiterbare Funktionsliste, mittels Namen wird der hinterlegte SCPI Syntax ausgelesen
    _syntax_table: dict = {
        "getTime":                  ":SYSTem:TIME? 1",         # Reference Manual Seite 12-158
        "setTime":                  ":SYSTem:TIME ",           # Reference Manual Seite 12-158 
        "setFunctionON":            ':SENSe:FUNCtion:ON "${messmode}"', # Reference Manual Seite 12-137  
        "setDigitizeFunctionON":    ':SENSe:DIGItize:FUNCtion:ON "${messmode}"',
        "measure":                  ":MEASure:${messmode}?",   # Reference Manual Seite 12-5  
        "setMeasureCounts":         ":SENSe:COUNt ",           # Reference Manual Seite 12-134
        "setMeasureDigitizeCounts": ":SENSe:DIGItize:COUNt ",  # Reference Manual Seite 12-135     
        "setSampleRateDigitize":    ":SENSe:${messmode}:SRATe ",  # Reference Manual Seite 12-118    
        "read":                     ":READ?",                  # Reference Manual Seite 12-10
        "lastBufferWriteIndex":     ":TRACe:ACTual:END?",      # Reference Manual Seite 12-160        
        "readBuffer":               ":TRACe:DATA?",            # Reference Manual Seite 12-165  
        "averageCount":             ":SENSE:${messmode}:AVERage:COUNt ",
        "averageRepeat":            ":SENSE:${messmode}:AVERage:TCONTrol REPeat",
        "averageMoving":            ":SENSE:${messmode}:AVERage:TCONTrol MOVing",
        "averageHybrid":            ":SENSE:${messmode}:AVERage:TCONTrol HYBRid",
        "averageON":                ":SENSE:${messmode}:AVERage ON",
        "averageOFF":               ":SENSE:${messmode}:AVERage OFF",
        "deleteBuffer":             ":TRACe:CLEar",            # Reference Manual Seite 12-164
        "localMode":                ":TRIGger:CONTinuous RESTart",
        "None":                     "None"
    }

    #################################################################################           
      
    # Konstruktor
    def __init__(self, model):
        self._model: str = model
        self._measureMode: str = None
        self._unit: str = None
        self._function: str = None

    ### public ####################################################################   
              
    def setFunction(self, measure: str) -> str:
        try:
            mode = self._modes[measure]
            self._unit = mode["unit"]
            self._function = mode["function"]   # in Syntax übersetzte Funktion zurück
            return f'function found → {measure}'
        except KeyError:
            self._unit = None
            self._function = None
            print (f'function unknown → {measure}')
            sys.exit("Abbruch")
            
    def scpi_command_syntax (self, name: str, debug: bool = False) -> str:  # "averageON" → ":SENSE:MESSMODE:AVERage ON"
        try:
            syntax = Template(self._syntax_table[name]).substitute(messmode=self._function)
            
            if debug:
                modified_list = {
                    key: Template(cmd).substitute(messmode=self._function)
                    for key, cmd in self._syntax_table.items()
                }
                # mit Formatierung
                max_key_len = max(len(key) for key in modified_list.keys())
                for key, cmd in modified_list.items():
                    print(f"{key:<{max_key_len}} {cmd}")
        
            return syntax
        except KeyError:
            return f'command unknown → {name}'
        
    @property   # Getter - Aufruf ohne ()
    def function(self) -> str:
        return self._function
    
    @property   # Getter - Aufruf ohne ()
    def unit(self) -> str:
        return self._unit

    ### für Debug ####
    def debug_ausgabe_formatiert (self, obj: dict):
        print()
        max_key_len = max(len(key) for key in obj.keys())
        for key, cmd in obj.items():
            print(f"{key:<{max_key_len}} {cmd}")
            
### für schnelle Tests im Modul ###############################

if __name__ == '__main__':
    k = Keithley_SCPI("Keithley DMM6500")
                
    print(k.setFunction("2W"))
    print(k.function)                                   # Debug
    print(k.unit)                                       # Debug
    print(k.scpi_command_syntax("measure"))             # Debug
    
    print(k.setFunction("Temp"))
    print(k.function)                                   # Debug
    print(k.unit)                                       # Debug
    print(k.scpi_command_syntax("averageMoving", True)) # Debug