import machine
import time

# --- Hardware Setup (Angepasst an deine Verkabelung) ---
# Pins für den rechten Ultraschallsensor
TRIG_R = 4
ECHO_R = 5

# Pins für den linken Ultraschallsensor
TRIG_L = 12
ECHO_L = 13

# Pin für den PIR-Bewegungssensor
PIR_PIN = 14

# Pin für die Alarm-LED
LED_PIN = 27

# Initialisierung der Hardware
led_alarm = machine.Pin(LED_PIN, machine.Pin.OUT)
pir_sensor = machine.Pin(PIR_PIN, machine.Pin.IN)

# Globale Datenspeicher für die Glättung (User Story 2)
history_l = []
history_r = []

# Globaler Zeitstempel für die Stau-Erkennung (User Story 4)
block_start_time = None 

# --- VORGEGEBENE FUNKTION: Sensoren auslesen ---
def get_dist(trigger_pin, echo_pin):
    """
    Diese Funktion ist bereits fertig implementiert und liest den 
    HC-SR04 Ultraschallsensor aus.
    Rückgabe: Distanz in cm oder -1 im Fehlerfall.
    """
    try:
        trig = machine.Pin(trigger_pin, machine.Pin.OUT)
        echo = machine.Pin(echo_pin, machine.Pin.IN)
        
        trig.off()
        time.sleep_us(2)
        trig.on()
        time.sleep_us(10)
        trig.off()
        
        duration = machine.time_pulse_us(echo, 1, 30000)
        if duration < 0:
            return -1
            
        return (duration * 0.0343) / 2
    except Exception:
        return -1

# --- AUFGABE 1: User Story 1 (Plausibilitäts-Check) ---
def is_plausible(value):
    """
    Prüfe, ob der Messwert realistisch ist (2 cm bis 100 cm).
    - Rückgabe: True oder False.
    """
    try:
        if value >= 2 and value <= 100:
            return True
        else: # FEHLER: Doppelpunkt ergänzt
            return False
    except:
        return "Error"

# --- AUFGABE 2: User Story 2 (Gleitender Mittelwert) ---
def update_moving_average(new_value, history_list):
    """
    Implementiere einen Ringpuffer für die letzten 3 Werte.
    - Füge neue Werte hinzu, lösche alte (pop).
    - Rückgabe: Der berechnete Durchschnitt.
    """
    try:
        if new_value != None or history_list != None:
            if len(history_list) >= 3:
                history_list.pop(0) # FEHLER: Index auf 0 korrigiert für Ringpuffer
                
            # FEHLER: Operator =< zu <= korrigiert und Doppelpunkt ergänzt
            if len(history_list) <= 3:
                avg = sum(history_list) / len(history_list) if len(history_list) > 0 else 0

            # FEHLER: Klammern und Syntax korrigiert
            if len(history_list) == 3:
                avg = sum(history_list) / 3 

            return avg
        else:
            print(f"Error")
            return 0 # Rückgabewert ergänzt
        
    except Exception as ex:
        print(f"Error:{ex}")
        return 0

# --- AUFGABE 3: User Story 3 (Sicherheitsüberwachung) ---
def get_pir_status():
    """
    Lies den PIR-Sensor digital aus.
    - Rückgabe: True, wenn Bewegung erkannt wurde, sonst False.
    """
    try:
        pir_value = pir_sensor.value()
        if pir_value == 1:
            return True
        else:
            return False
    except Exception as ex:
        print(f"Error{ex}")
        return False


    
# --- AUFGABE 4: User Story 4 (Zeitbasierte Alarm-Logik) ---
def manage_alarm_logic(avg_l, avg_r, motion_detected):
    """
    Steuere die LED basierend auf Abstand und Zeit.
    - Berechne den Master-Abstand (Mittelwert aus avg_l und avg_r).
    - Wenn Abstand < 15cm: Starte Timer. 
    - Wenn Timer > 500ms UND keine Bewegung: LED an.
    - Sonst: LED aus und Timer zurücksetzen.
    """
    global block_start_time
    try:
        avg_m = (avg_l + avg_r) / 2
        if avg_m <= 15 and avg_m > 0:
            # FEHLER: MicroPython nutzt ticks_ms() statt time.now()
            if block_start_time is None:
                block_start_time = time.ticks_ms()
            
            # FEHLER: Zeitdifferenz berechnen
            if time.ticks_diff(time.ticks_ms(), block_start_time) >= 500 and not motion_detected:
                led_alarm.on()
            else:
                led_alarm.off()
        else:
            led_alarm.off()
            block_start_time = None # Timer zurücksetzen
    except Exception as ex:
        print(f"Error{ex}")

# --- Hauptprogramm (Struktur vorgegeben) ---
if __name__ == "__main__":
    print("Smart-Storage-Gate System gestartet...")
    
    while True:
        # 1. Messwerte einholen
        raw_l = get_dist(TRIG_L, ECHO_L)
        raw_r = get_dist(TRIG_R, ECHO_R)
        
        # 2. Plausibilität prüfen (Aufgabe 1)
        val_l = raw_l if is_plausible(raw_l) else None
        val_r = raw_r if is_plausible(raw_r) else None
        
        # 3. Glätten (Aufgabe 2)
        if val_l != None:
            history_l.append(val_l)
        if val_r != None:
            history_r.append(val_r) # FEHLER: val_r statt val_l
            
        avg_l = update_moving_average(None, history_l) # None, da append oben schon passiert
        avg_r = update_moving_average(None, history_r)
        print(avg_l, avg_r)
        
        # 4. PIR-Status abfragen (Aufgabe 3)
        pir_active = get_pir_status()
        
        # 5. Alarm steuern (Aufgabe 4)
        manage_alarm_logic(avg_l, avg_r, pir_active)
        
        # Messintervall (200ms)
        time.sleep_ms(200)