import os
import clr
import time
#from difflib import get_close_matches

# DLL laden (Pfad ggf. anpassen)
dll_path = os.path.abspath("LibreHardwareMonitorLib.dll")
clr.AddReference(dll_path)

from LibreHardwareMonitor import Hardware
#from difflib import SequenceMatcher
# ----------------------------------------
# Hilfsfunktion: unscharfer Vergleich
# ----------------------------------------
#from rapidfuzz import fuzz
from rapidfuzz.fuzz import partial_ratio

def best_match_optional(filter_str, target_str, min_token_score=80):
    """
    Für jedes Token im Filter suchen wir das bestpassende Token im Ziel (mit partial_ratio).
    Der finale Score ist der Durchschnitt dieser besten Matches.
    """
    if not filter_str:
        return 1.0

    filter_tokens = filter_str.lower().split()
    target_tokens = target_str.lower().split()

    if not target_tokens:
        return 0.0

    match_scores = []
    for ftoken in filter_tokens:
        best_score = max(
            partial_ratio(ftoken, ttoken)
            for ttoken in target_tokens
        )
        if best_score < min_token_score:
            return 0.0  # Ein Filter-Token ist zu unähnlich → kein Match
        match_scores.append(best_score)

    return sum(match_scores) / (100 * len(match_scores))  # Normiert auf [0.0, 1.0]




# ----------------------------------------
# Einmalige GPU-Auslesung (alle Sensorwerte)
# ----------------------------------------
def lese_gpu_sensorwerte():
    hw = Hardware.Computer()
    hw.IsGpuEnabled = True
    hw.IsCpuEnabled = False
    hw.IsMemoryEnabled = False
    hw.IsMotherboardEnabled = False
    hw.IsStorageEnabled = False
    hw.IsNetworkEnabled = False
    hw.IsControllerEnabled = False
    hw.Open()

    daten = []
    hardware_counter = 0

    for hardware in hw.Hardware:
        hardware.Update()

        #if hardware.HardwareType.ToString().lower() != "gpu":
        #    continue

        hardware_type = hardware.HardwareType.ToString()
        hardware_name = hardware.Name
        hardware_id = f"ID{hardware_counter}"
        hardware_counter += 1

        for sensor in hardware.Sensors:
            eintrag = {
                "ID": hardware_id,
                "HardwareName": hardware_name,
                "HardwareType": hardware_type,
                "SensorName": sensor.Name,
                "SensorType": sensor.SensorType.ToString(),
                "Value": sensor.Value
            }
            daten.append(eintrag)


    hw.Close()
    return daten

# ----------------------------------------
# Filterfunktion mit flexiblen Feldern
# ----------------------------------------
def filter_sensordaten(daten, filterkriterien):
    treffer = []
    for eintrag in daten:
        if all([
            best_match_optional(filterkriterien.get("ID"), eintrag["ID"]),
            best_match_optional(filterkriterien.get("HardwareName"), eintrag["HardwareName"]),
            best_match_optional(filterkriterien.get("HardwareType"), eintrag["HardwareType"]),
            best_match_optional(filterkriterien.get("SensorName"), eintrag["SensorName"]),
            best_match_optional(filterkriterien.get("SensorType"), eintrag["SensorType"]),
            (filterkriterien.get("Value") is None or eintrag["Value"] == filterkriterien["Value"])
        ]):
            treffer.append(eintrag)
    return treffer

# ----------------------------------------
# Hauptprogramm
# ----------------------------------------
if __name__ == "__main__":
    # Alle GPU-Daten einmalig auslesen
    alle_sensoren = lese_gpu_sensorwerte()

    print("\n--- Alle ausgelesenen GPU-Sensorwerte ---")
    for sensor in alle_sensoren:
        val = sensor["Value"]
        val_str = f"{round(val, 1)}" if isinstance(val, (float, int)) else str(val)
        print(f"ID: {sensor['ID']} | HwType: <{sensor['HardwareType']}> | "
              f"HwName: <{sensor['HardwareName']}> | Sensor: <{sensor['SensorName']}> | "
              f"Typ: <{sensor['SensorType']}> = {val_str}")
    print(f"\nInsgesamt {len(alle_sensoren)} Sensoren gefunden.")


    # -------------------------------
    # 10 definierbare Suchabfragen
    # -------------------------------
    suchabfragen = [
        {
            "aktiv": True,
            "filter": {
                "HardwareType": "GpuAmd",
                "HardwareName": "AMD",
                "SensorName": "Core",
                "SensorType": "Temperature",
                "ID": "",
                "Value": None
            }
        },
        
        {
            "aktiv": True,
            "filter": {
                "HardwareType": "GpuAmd",
                "HardwareName": "AMD",
                "SensorName": "Core",
                "SensorType": "Load",
                "ID": "",
                "Value": None
            }
        },

        {
            "aktiv": True,
            "filter": {
                "HardwareType": "GpuAmd",
                "HardwareName": "AMD",
                "SensorName": "GPU Memory Used",
                "SensorType": "",
                "ID": "",
                "Value": None
            }
        },
        
        {
            "aktiv": True,
            "filter": {
                "HardwareType": "GpuAmd",
                "HardwareName": "AMD",
                "SensorName": "GPU Memory Free",
                "SensorType": "",
                "ID": "",
                "Value": None
            }
        },
    
        {
            "aktiv": True,
            "filter": {
                "HardwareType": "GpuAmd",
                "HardwareName": "AMD",
                "SensorName": "GPU Memory Total",
                "SensorType": "",
                "ID": "",
                "Value": None
            }
        },

        {
            "aktiv": False,
            "filter": {
                "HardwareType": "Check",
                "HardwareName": "",
                "SensorName": "",
                "SensorType": "",
                "ID": "",
                "Value": None
            }
        },
        # ... weitere Suchabfragen:
        *[
            {"aktiv": False, "filter": {}}  # Platzhalter
            for _ in range(10)
        ]
    ]

    # -------------------------------
    # Suchabfragen ausführen
    # -------------------------------
    for idx, suchanfrage in enumerate(suchabfragen):
        if not suchanfrage["aktiv"]:
            continue

        print(f"\n--- Suche #{idx + 1} ---")
        resultate = filter_sensordaten(alle_sensoren, suchanfrage["filter"])

        if not resultate:
            print("Keine passenden Sensorwerte gefunden.")
        else:
            for r in resultate:
                val = r["Value"]
                val_str = f"{round(val, 1)}" if isinstance(val, (float, int)) else str(val)
                print(f"ID: {r['ID']} | HwType: <{r['HardwareType']}> | "
                      f"HwName: <{r['HardwareName']}> | Sensor: <{r['SensorName']}> | "
                      f"Typ: <{r['SensorType']}> = {val_str}")
                time.sleep(0.01)

    input("\nDrücke eine Taste zum Beenden...")