import sys
from typing import Optional
    
# from MeineModule import KeithleyDMM6500SCPI
    
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(None,  "PERiod"),
        "Diode":    _fm("V",   "DIODe"),
        "Temp":     _fm("°C",  "TEMPerature"),
        "Cap":      _fm("F",   "CAPacitance"),
        "Digi V":   _fm("V",   "VOLTage"),
        "Digi I":   _fm("A",   "CURRent")
    }
    
    #################################################################################    
               
    # _fs ... function syntax
    def _fs(syntax: Optional[str]) -> dict:
        return {'syntax': syntax}  
    
    # erweiterbare Funktionsliste, mittels Namen wird der hinterlegte SCPI Syntax ausgelesen
    _syntax_table: dict[str, dict[Optional[str]]] = {
        "getTime":                  _fs(":SYSTem:TIME? 1"),         # Reference Manual Seite 12-158
        "setTime":                  _fs(":SYSTem:TIME "),           # Reference Manual Seite 12-158 
        "setFunctionON":            _fs(':SENSe:FUNCtion:ON "MESSMODE"'),
        "setDigitizeFunctionON":    _fs(':SENSe:DIGItize:FUNCtion:ON "MESSMODE"'),
        "measure":                  _fs(":MEASure:MESSMODE?"),      # Reference Manual Seite 12-137  
        "setMeasureCounts":         _fs(":SENSe:COUNt "),           # Reference Manual Seite 12-134
        "setMeasureDigitizeCounts": _fs(":SENSe:DIGItize:COUNt "),  # Reference Manual Seite 12-135     
        "setSampleRateDigitize":    _fs(":SENSe:MESSMODE:SRATe "),  # Reference Manual Seite 12-118    
        "read":                     _fs(":READ?"),                  # Reference Manual Seite 12-10
        "lastBufferWriteIndex":     _fs(":TRACe:ACTual:END?"),      # Reference Manual Seite 12-160        
        "readBuffer":               _fs(":TRACe:DATA?"),            # Reference Manual Seite 12-165  
        "averageCount":             _fs(":SENSE:MESSMODE:AVERage:COUNt "),
        "averageRepeat":            _fs(":SENSE:MESSMODE:AVERage:TCONTrol REPeat"),
        "averageMoving":            _fs(":SENSE:MESSMODE:AVERage:TCONTrol MOVing"),
        "averageHybrid":            _fs(":SENSE:MESSMODE:AVERage:TCONTrol HYBRid"),
        "averageON":                _fs(":SENSE:MESSMODE:AVERage ON"),
        "averageOFF":               _fs(":SENSE:MESSMODE:AVERage OFF"),
        "deleteBuffer":             _fs(":TRACe:CLEar"),            # Reference Manual Seite 12-164
        "localMode":                _fs(":TRIGger:CONTinuous RESTart"),
        "None":                     _fs("None")
    }

    #################################################################################           
      
    # Konstruktor
    def __init__(self, model):
        self._model: str = model
        self._unit: str = None
        self._function: str = None
        self._syntax_table_modified: dict = {}  # Kopie von '_syntax_table'

    def _update_table (self, replacement: str):    # Kopie erstellen und Platzhalter ersetzen
        target: str = "MESSMODE"               
        # wird direkt in Kopie 'self._syntax_table_modified' geschrieben
        for key, value in self._syntax_table.items():                 
            modify = value['syntax'].replace(target, replacement)
            self._syntax_table_modified[key] = {'syntax': modify}

    ### 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
            self._update_table(self._function)  # Änderung in Kopie schreiben
            return f'function found → {measure}'
        except KeyError:
            self._unit = None
            self._function = None
            #return f'function unknown → {measure}'
            print (f'function unknown → {measure}')
            sys.exit("Abbruch")
        # finally:
        #     print ("finally wird immer ausgeführt")
            
    def scpi_command_syntax (self, name: str) -> str: # "averageON" → ":SENSE:MESSMODE:AVERage ON"
        try:
            syntax = self._syntax_table_modified[name]["syntax"]
            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, value in obj.items():
            print(f"{key:<{max_key_len}} {value['syntax']}")
            
### gehört hier nicht hin - nur für schnelle Tests im Modul ###############################

k = Keithley_SCPI("Keithley DMM6500")
             
print(k.setFunction("2W"))
print(k.function)                                   # Debug
print(k.unit)                                       # Debug
print(k.scpi_command_syntax("measure"))             # Debug
#k.debug_ausgabe_formatiert(k._syntax_table_modified) # Debug

print(k.setFunction("Temp"))
print(k.function)                                   # Debug
print(k.unit)                                       # Debug
print(k.scpi_command_syntax("measure"))             # Debug
k.debug_ausgabe_formatiert(k._syntax_table_modified) # Debug