import time
import threading
from text2numde import text2num, is_number, sentence2num 
from playsound3 import playsound
from datetime import datetime, timedelta
import re
import math

wecker_thread = None 
wecker_stop = threading.Event()
wecker_status = "idle"
wecker_target_time: datetime | None = None


def parse_time_wecker(text):

    text = text.lower().strip()

    match = re.search(r"\b([\w]+)\s*uhr(?:\s*([\w]+))?\b", text)
    if not match: 
        return None

    hour_text = match.group(1)
    minute_text= match.group(2)


    try:
        hour = text2num(hour_text)
        minute = text2num(minute_text) if minute_text else 0
    except ValueError:
        print("Konnte die Zahl nicht erkennen.")
        return None

    if hour < 0 or hour > 23:
        return None
    if minute < 0 or minute > 59:
        return None
    
    print(f"{hour:02d}:{minute:02d}")
    return hour, minute
    
def calculate_target_datetime(hour: int, minute: int) -> datetime:
    now = datetime.now()

    target = now.replace(hour=hour, minute=minute, second=0, microsecond=0)

    if target <= now:
        target += timedelta(days=1)

    return target


def minutes_until(target: datetime) -> int:
     #return int(((target - now)).total_seconds() // 60) hatte das davor aber das hat abgerundet
    seconds = (target - datetime.now()).total_seconds()
    return math.ceil(seconds / 60)


def start_wecker(target_time: datetime):
    global wecker_thread, wecker_status, wecker_target_time

    if wecker_status == "running":
        return False # wecker läuft bereits
    
    wecker_stop.clear()
    wecker_target_time = target_time
    wecker_status = "running"

    def run():
        global wecker_status
        seconds = (wecker_target_time - datetime.now()).total_seconds()
        if seconds < 0:
            seconds = 0

        if not wecker_stop.wait(seconds):
            wecker_status = "finished"
            print("wecker abgelaufen") # """ TTS """
    
    wecker_thread = threading.Thread(target=run, daemon=True)
    wecker_thread.start()
    return True
""" 
    print(f"wecker startet für {seconds} Sekunden...")
    time.sleep(seconds)
    print("wecker abgelaufen!")
    playsound("/home/tino/Desktop/Abschlussprojekt/test assistant/cloneAssistantAllInOne/RasPi_Voice_Assistant--WIP/clock-alarm-8761.mp3")
    sound.stop()
     """
    
""" # Beispielnutzung
spoken_input = "eine sekunde"  # This could come from a voice assistant
seconds = parse_time(spoken_input)
if seconds:
    start_wecker(seconds) """

def stop_wecker():
    global wecker_status
    if wecker_status != "running":
        print("Kein wecker gestellt")
        return False

    wecker_stop.set()
    wecker_status = "stopped"
    return True  

def wecker_status_info():
    if wecker_status != "running":
        return {"status": wecker_status, "target_time": 0}


    return {
        "status": "running",
        "target_time": wecker_target_time 
    }

def format_duration(seconds):
    if seconds < 60:
        return f"{seconds} {second_text(seconds)}"

    minutes = seconds // 60
    secs = seconds % 60

    if minutes < 10:
        if secs == 0:
            return f"{minutes} {minute_text(minutes)}"
        return f"{minutes} {minute_text(minutes)} und {secs} {second_text(secs)}"

    if minutes < 60:
        return f"{minutes} {minute_text(minutes)}"
    
    hours = minutes // 60
    mins = minutes % 60

    if mins == 0:
        return f"{hours} {hour_text(hours)}"
    return f"{hours} {hour_text(hours)} und {mins} {minute_text(mins)}"



def minute_text(n):
    return "Minute" if n == 1 else "Minuten"

def second_text(n):
    return "Sekunde" if n == 1 else "Sekunden"

def hour_text(n):
    return "Stunde" if n == 1 else "Stunden"