zeitgesteuerte Aufnahme eines Livestreams mit mpv (eure Ideen)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import tkinter as tk
from tkinter import messagebox, filedialog
import subprocess
import threading
import shutil
import time
from datetime import datetime, timedelta
import os

class ScheduledRecorderApp:
    def __init__(self, root):
        self.root = root
        self.root.title("MPV Zeitgesteuerte Aufnahme")
        self.root.geometry("650x500")

        self.process = None
        self.recording_active = False
        self.timer_thread = None
        self.stop_event = threading.Event()

        # Prüfen, ob mpv installiert ist
        if shutil.which("mpv") is None:
            messagebox.showerror("Fehler", "mpv wurde nicht gefunden.\nBitte installiere mpv (z.B. sudo apt install mpv).")
            root.destroy()
            return

        # --- GUI Elemente ---
        tk.Label(root, text="Stream URL:").pack(pady=(10,0))
        self.url_entry = tk.Entry(root, width=80)
        self.url_entry.pack(pady=5)

        # Rahmen für Startzeit und Dauer
        time_frame = tk.Frame(root)
        time_frame.pack(pady=10, fill=tk.X, padx=20)

        tk.Label(time_frame, text="Startzeit (HH:MM):").pack(side=tk.LEFT, padx=5)
        self.start_time_entry = tk.Entry(time_frame, width=10)
        self.start_time_entry.pack(side=tk.LEFT, padx=5)
        self.start_time_entry.insert(0, "14:30")

        tk.Label(time_frame, text="Dauer (Sekunden oder HH:MM:SS):").pack(side=tk.LEFT, padx=5)
        self.duration_entry = tk.Entry(time_frame, width=15)
        self.duration_entry.pack(side=tk.LEFT, padx=5)
        self.duration_entry.insert(0, "3600")

        # Ausgabedatei
        tk.Label(root, text="Ausgabedatei (optional, leer = automatisch):").pack(pady=(10,0))
        self.output_entry = tk.Entry(root, width=80)
        self.output_entry.pack(pady=5)
        tk.Button(root, text="Datei auswählen...", command=self.select_output_file).pack(pady=2)

        # Buttons
        button_frame = tk.Frame(root)
        button_frame.pack(pady=10)

        self.schedule_button = tk.Button(button_frame, text="Aufnahme planen", command=self.schedule_recording, bg="orange", fg="white", width=15)
        self.schedule_button.pack(side=tk.LEFT, padx=5)

        self.start_now_button = tk.Button(button_frame, text="Sofort starten", command=self.start_now, bg="green", fg="white", width=15)
        self.start_now_button.pack(side=tk.LEFT, padx=5)

        self.stop_button = tk.Button(button_frame, text="Aufnahme stoppen", command=self.stop_recording, state=tk.DISABLED, bg="red", fg="white", width=15)
        self.stop_button.pack(side=tk.LEFT, padx=5)

        self.cancel_schedule_button = tk.Button(button_frame, text="Planung abbrechen", command=self.cancel_schedule, state=tk.DISABLED, bg="gray", fg="white", width=15)
        self.cancel_schedule_button.pack(side=tk.LEFT, padx=5)

        # Statuslabel
        self.status_label = tk.Label(root, text="Bereit", fg="blue")
        self.status_label.pack(pady=5)

        # Log-Bereich
        self.log_text = tk.Text(root, height=12, width=80, state=tk.DISABLED)
        self.log_text.pack(pady=10, padx=10)

    def select_output_file(self):
        file_path = filedialog.asksaveasfilename(
            defaultextension=".ts",
            filetypes=[("Alle Dateien", "*.*"), ("TS-Dateien", "*.ts"), ("MKV-Dateien", "*.mkv"), ("MP4-Dateien", "*.mp4")]
        )
        if file_path:
            self.output_entry.delete(0, tk.END)
            self.output_entry.insert(0, file_path)

    def log(self, message):
        self.log_text.config(state=tk.NORMAL)
        timestamp = datetime.now().strftime("%H:%M:%S")
        self.log_text.insert(tk.END, f"[{timestamp}] {message}\n")
        self.log_text.see(tk.END)
        self.log_text.config(state=tk.DISABLED)

    def parse_duration(self, duration_str):
        """Wandelt Dauer (Sekunden oder HH:MM:SS) in Sekunden um."""
        duration_str = duration_str.strip()
        try:
            return int(duration_str)
        except ValueError:
            pass
        parts = duration_str.split(':')
        try:
            if len(parts) == 1:
                return int(parts[0])
            elif len(parts) == 2:
                return int(parts[0]) * 60 + int(parts[1])
            elif len(parts) == 3:
                return int(parts[0]) * 3600 + int(parts[1]) * 60 + int(parts[2])
            else:
                raise ValueError
        except ValueError:
            raise ValueError("Ungültiges Dauerformat. Verwende Sekunden oder HH:MM:SS")

    def parse_start_time(self, time_str):
        """Wandelt HH:MM in ein datetime-Objekt für heute (falls Zeit in der Zukunft) oder morgen."""
        try:
            hour, minute = map(int, time_str.strip().split(':'))
            if not (0 <= hour <= 23 and 0 <= minute <= 59):
                raise ValueError
        except:
            raise ValueError("Startzeit muss im Format HH:MM sein (z.B. 14:30)")

        now = datetime.now()
        start = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
        if start <= now:
            start += timedelta(days=1)
        return start

    def schedule_recording(self):
        """Plant die Aufnahme zu einer bestimmten Uhrzeit."""
        url = self.url_entry.get().strip()
        if not url:
            messagebox.showerror("Fehler", "Bitte eine Stream-URL eingeben.")
            return

        start_time_str = self.start_time_entry.get().strip()
        try:
            start_dt = self.parse_start_time(start_time_str)
        except ValueError as e:
            messagebox.showerror("Fehler", str(e))
            return

        duration_str = self.duration_entry.get().strip()
        try:
            duration_sec = self.parse_duration(duration_str)
            if duration_sec <= 0:
                raise ValueError
        except ValueError:
            messagebox.showerror("Fehler", "Ungültige Dauer. Verwende Sekunden oder HH:MM:SS")
            return

        # Ausgabedatei vorbereiten
        output_file = self.output_entry.get().strip()
        if not output_file:
            timestamp = start_dt.strftime("%Y%m%d_%H%M%S")
            url_part = url.replace("https://", "").replace("http://", "").replace("/", "_").replace(":", "_")[:40]
            output_file = f"rec_{timestamp}_{url_part}.ts"
            self.output_entry.insert(0, output_file)

        # Verzeichnis prüfen
        output_dir = os.path.dirname(output_file)
        if output_dir and not os.path.exists(output_dir):
            try:
                os.makedirs(output_dir)
            except Exception as e:
                messagebox.showerror("Fehler", f"Verzeichnis konnte nicht erstellt werden: {e}")
                return

        # Wartezeit berechnen
        now = datetime.now()
        wait_seconds = (start_dt - now).total_seconds()
        self.log(f"Geplante Aufnahme um {start_dt.strftime('%Y-%m-%d %H:%M:%S')} (in {wait_seconds:.0f} Sekunden)")
        self.log(f"Dauer: {duration_sec} Sekunden")
        self.log(f"Zieldatei: {output_file}")

        # UI in Planungsmodus versetzen
        self.schedule_button.config(state=tk.DISABLED)
        self.start_now_button.config(state=tk.DISABLED)
        self.cancel_schedule_button.config(state=tk.NORMAL)
        self.status_label.config(text=f"Geplant für {start_dt.strftime('%H:%M:%S')}", fg="orange")

        # Planungs-Thread starten
        self.stop_event.clear()
        self.timer_thread = threading.Thread(target=self._wait_and_record, args=(wait_seconds, url, duration_sec, output_file), daemon=True)
        self.timer_thread.start()

    def _wait_and_record(self, wait_seconds, url, duration_sec, output_file):
        """Wartet die angegebene Zeit und startet dann die Aufnahme."""
        # Sekundenweise warten, damit wir auf Stop reagieren können
        for _ in range(int(wait_seconds)):
            if self.stop_event.is_set():
                self.root.after(0, self._schedule_cancelled)
                return
            time.sleep(1)

        if self.stop_event.is_set():
            self.root.after(0, self._schedule_cancelled)
            return

        # Aufnahme starten (im Hauptthread ausführen lassen)
        self.root.after(0, lambda: self._execute_recording(url, duration_sec, output_file))

    def _schedule_cancelled(self):
        self.log("Geplante Aufnahme wurde abgebrochen.")
        self.status_label.config(text="Planung abgebrochen", fg="red")
        self.schedule_button.config(state=tk.NORMAL)
        self.start_now_button.config(state=tk.NORMAL)
        self.cancel_schedule_button.config(state=tk.DISABLED)

    def start_now(self):
        """Startet die Aufnahme sofort."""
        url = self.url_entry.get().strip()
        if not url:
            messagebox.showerror("Fehler", "Bitte eine Stream-URL eingeben.")
            return

        duration_str = self.duration_entry.get().strip()
        try:
            duration_sec = self.parse_duration(duration_str)
            if duration_sec <= 0:
                raise ValueError
        except ValueError:
            messagebox.showerror("Fehler", "Ungültige Dauer. Verwende Sekunden oder HH:MM:SS")
            return

        output_file = self.output_entry.get().strip()
        if not output_file:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            url_part = url.replace("https://", "").replace("http://", "").replace("/", "_").replace(":", "_")[:40]
            output_file = f"rec_{timestamp}_{url_part}.ts"
            self.output_entry.insert(0, output_file)

        output_dir = os.path.dirname(output_file)
        if output_dir and not os.path.exists(output_dir):
            try:
                os.makedirs(output_dir)
            except Exception as e:
                messagebox.showerror("Fehler", f"Verzeichnis konnte nicht erstellt werden: {e}")
                return

        self._execute_recording(url, duration_sec, output_file)

    def _execute_recording(self, url, duration_sec, output_file):
        """Startet den mpv-Prozess und überwacht ihn."""
        if self.recording_active:
            self.log("Aufnahme bereits aktiv.")
            return

        cmd = [
            "mpv",
            "--stream-record=" + output_file,
            "--length=" + str(duration_sec),
#            "--no-audio-display",
#            "--no-video",
            "--quiet",
            url
        ]

        self.log(f"Starte Aufnahme: {output_file}")
        self.log(f"für {duration_sec} Sekunden")
        self.log(f"Befehl: {' '.join(cmd)}")

        try:
            self.process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
            self.recording_active = True
            self.schedule_button.config(state=tk.DISABLED)
            self.start_now_button.config(state=tk.DISABLED)
            self.stop_button.config(state=tk.NORMAL)
            self.cancel_schedule_button.config(state=tk.DISABLED)
            self.status_label.config(text="Aufnahme läuft...", fg="orange")

            # Überwachungs-Thread
            monitor = threading.Thread(target=self._monitor_process, daemon=True)
            monitor.start()

            # Sicherheitstimer
            self.root.after(duration_sec * 1000 + 5000, self._force_stop_if_stuck)

        except Exception as e:
            self.log(f"Fehler beim Start: {e}")
            messagebox.showerror("Fehler", f"mpv konnte nicht gestartet werden: {e}")
            self._reset_ui()

    def _monitor_process(self):
        if self.process:
            self.process.wait()
            self.root.after(0, self._recording_finished)

    def _recording_finished(self):
        if self.recording_active:
            self.recording_active = False
            self.log("Aufnahme beendet (mpv wurde beendet).")
            self.status_label.config(text="Aufnahme beendet", fg="green")
            self._reset_ui()
            messagebox.showinfo("Fertig", "Die Aufnahme wurde erfolgreich beendet.")

    def _force_stop_if_stuck(self):
        if self.recording_active and self.process and self.process.poll() is None:
            self.log("WARNUNG: Aufnahme hängt – erzwinge Beendigung.")
            self.process.terminate()
            self.root.after(2000, lambda: self.process.kill() if self.process and self.process.poll() is None else None)

    def stop_recording(self):
        """Stoppt die laufende Aufnahme vorzeitig."""
        if self.process and self.process.poll() is None:
            self.log("Aufnahme wird gestoppt...")
            self.process.terminate()
            self.status_label.config(text="Stoppe...", fg="red")
        else:
            self.log("Keine aktive Aufnahme.")

    def cancel_schedule(self):
        """Bricht eine geplante (noch nicht gestartete) Aufnahme ab."""
        if self.timer_thread and self.timer_thread.is_alive():
            self.stop_event.set()
            self.log("Planung wird abgebrochen...")
            self.status_label.config(text="Abbruch der Planung", fg="red")
            # UI wird später in _schedule_cancelled zurückgesetzt
        else:
            self.log("Keine aktive Planung vorhanden.")

    def _reset_ui(self):
        self.recording_active = False
        self.schedule_button.config(state=tk.NORMAL)
        self.start_now_button.config(state=tk.NORMAL)
        self.stop_button.config(state=tk.DISABLED)
        self.cancel_schedule_button.config(state=tk.DISABLED)
        if self.process and self.process.poll() is None:
            self.process.terminate()
        self.process = None

if __name__ == "__main__":
    root = tk.Tk()
    app = ScheduledRecorderApp(root)
    root.mainloop()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import tkinter as tk
from tkinter import ttk, messagebox, filedialog
import subprocess
import threading
import shutil
import time
import json
import os
from datetime import datetime, timedelta

class ScheduledRecorderApp:
    def __init__(self, root):
        self.root = root
        self.root.title("MPV Zeitgesteuerte Aufnahme")
        self.root.geometry("700x600")

        self.process = None
        self.recording_active = False
        self.timer_thread = None
        self.stop_event = threading.Event()

        # Konfigurationsverzeichnis und URL-Datei
        self.config_dir = os.path.expanduser("~/.config/mpv_recorder")
        self.urls_file = os.path.join(self.config_dir, "urls.json")
        self.urls = self.load_urls()

        # Prüfen, ob mpv installiert ist
        if shutil.which("mpv") is None:
            messagebox.showerror("Fehler", "mpv wurde nicht gefunden.\nBitte installiere mpv (z.B. sudo apt install mpv).")
            root.destroy()
            return

        # --- GUI Elemente ---
        tk.Label(root, text="Stream URL:").pack(pady=(10,0))
        
        # Combobox für URL-Auswahl + Eintrag
        self.url_combo = ttk.Combobox(root, width=80, values=self.urls)
        self.url_combo.pack(pady=5)
        self.url_combo.set("")  # leerer Eintrag
        if self.urls:
            self.url_combo.set(self.urls[0])  # erste URL als Vorschlag

        # Rahmen für URL-Verwaltung
        url_frame = tk.Frame(root)
        url_frame.pack(pady=2)
        tk.Button(url_frame, text="Aktuelle URL speichern", command=self.save_current_url, width=18).pack(side=tk.LEFT, padx=5)
        tk.Button(url_frame, text="Ausgewählte URL löschen", command=self.delete_selected_url, width=18).pack(side=tk.LEFT, padx=5)

        # Rahmen für Startzeit und Dauer
        time_frame = tk.Frame(root)
        time_frame.pack(pady=10, fill=tk.X, padx=20)

        tk.Label(time_frame, text="Startzeit (HH:MM):").pack(side=tk.LEFT, padx=5)
        self.start_time_entry = tk.Entry(time_frame, width=10)
        self.start_time_entry.pack(side=tk.LEFT, padx=5)
        self.start_time_entry.insert(0, "14:30")

        tk.Label(time_frame, text="Dauer (Minuten oder HH:MM:SS):").pack(side=tk.LEFT, padx=5)
        self.duration_entry = tk.Entry(time_frame, width=15)
        self.duration_entry.pack(side=tk.LEFT, padx=5)
        self.duration_entry.insert(0, "60")

        # Ausgabedatei
        tk.Label(root, text="Ausgabedatei (optional, leer = automatisch):").pack(pady=(10,0))
        self.output_entry = tk.Entry(root, width=80)
        self.output_entry.pack(pady=5)
        tk.Button(root, text="Datei auswählen...", command=self.select_output_file).pack(pady=2)

        # Buttons
        button_frame = tk.Frame(root)
        button_frame.pack(pady=10)

        self.schedule_button = tk.Button(button_frame, text="Aufnahme planen", command=self.schedule_recording, bg="orange", fg="white", width=15)
        self.schedule_button.pack(side=tk.LEFT, padx=5)

        self.start_now_button = tk.Button(button_frame, text="Sofort starten", command=self.start_now, bg="green", fg="white", width=15)
        self.start_now_button.pack(side=tk.LEFT, padx=5)

        self.stop_button = tk.Button(button_frame, text="Aufnahme stoppen", command=self.stop_recording, state=tk.DISABLED, bg="red", fg="white", width=15)
        self.stop_button.pack(side=tk.LEFT, padx=5)

        self.cancel_schedule_button = tk.Button(button_frame, text="Planung abbrechen", command=self.cancel_schedule, state=tk.DISABLED, bg="gray", fg="white", width=15)
        self.cancel_schedule_button.pack(side=tk.LEFT, padx=5)

        # Statuslabel
        self.status_label = tk.Label(root, text="Bereit", fg="blue")
        self.status_label.pack(pady=5)

        # Log-Bereich
        self.log_text = tk.Text(root, height=14, width=85, state=tk.DISABLED)
        self.log_text.pack(pady=10, padx=10)

    # --- URL-Verwaltung ---
    def load_urls(self):
        """Lädt die gespeicherten URLs aus der JSON-Datei."""
        if not os.path.exists(self.urls_file):
            return []
        try:
            with open(self.urls_file, "r") as f:
                data = json.load(f)
                return data if isinstance(data, list) else []
        except (json.JSONDecodeError, IOError):
            return []

    def save_urls(self):
        """Speichert die aktuellen URLs in die JSON-Datei (maximal 50 Einträge, neueste zuerst)."""
        # Duplikate entfernen, aber Reihenfolge beibehalten (neueste zuerst)
        unique_urls = []
        for url in self.urls:
            if url not in unique_urls:
                unique_urls.append(url)
        # Begrenzung auf 50 URLs
        self.urls = unique_urls[:50]
        try:
            os.makedirs(self.config_dir, exist_ok=True)
            with open(self.urls_file, "w") as f:
                json.dump(self.urls, f, indent=2)
        except IOError as e:
            self.log(f"Fehler beim Speichern der URLs: {e}")

    def add_url(self, url):
        """Fügt eine neue URL zur Liste hinzu (am Anfang, keine Duplikate)."""
        if not url or url.strip() == "":
            return
        url = url.strip()
        if url in self.urls:
            # Falls vorhanden, nach vorne verschieben
            self.urls.remove(url)
        self.urls.insert(0, url)
        self.save_urls()
        self.update_url_combo()

    def save_current_url(self):
        """Speichert die aktuell im Combobox-Feld eingegebene URL."""
        url = self.url_combo.get().strip()
        if not url:
            messagebox.showwarning("Keine URL", "Bitte eine URL eingeben oder auswählen.")
            return
        self.add_url(url)
        self.log(f"URL gespeichert: {url}")

    def delete_selected_url(self):
        """Löscht die aktuell ausgewählte URL aus der Liste."""
        url = self.url_combo.get().strip()
        if not url:
            return
        if url in self.urls:
            self.urls.remove(url)
            self.save_urls()
            self.update_url_combo()
            self.log(f"URL gelöscht: {url}")
            if self.urls:
                self.url_combo.set(self.urls[0])
            else:
                self.url_combo.set("")
        else:
            messagebox.showinfo("Nicht gefunden", "Diese URL ist nicht in der gespeicherten Liste.")

    def update_url_combo(self):
        """Aktualisiert die Werte der Combobox."""
        self.url_combo['values'] = self.urls

    # --- Andere Methoden (unverändert, aber mit Anpassung der URL-Entnahme) ---
    def select_output_file(self):
        file_path = filedialog.asksaveasfilename(
            defaultextension=".ts",
            filetypes=[("Alle Dateien", "*.*"), ("TS-Dateien", "*.ts"), ("MKV-Dateien", "*.mkv"), ("MP4-Dateien", "*.mp4")]
        )
        if file_path:
            self.output_entry.delete(0, tk.END)
            self.output_entry.insert(0, file_path)

    def log(self, message):
        self.log_text.config(state=tk.NORMAL)
        timestamp = datetime.now().strftime("%H:%M:%S")
        self.log_text.insert(tk.END, f"[{timestamp}] {message}\n")
        self.log_text.see(tk.END)
        self.log_text.config(state=tk.DISABLED)

    def parse_duration(self, duration_str):
        duration_str = duration_str.strip()
        try:
            minutes = float(duration_str)
            if minutes <= 0:
                raise ValueError
            return int(minutes * 60)
        except ValueError:
            pass
        parts = duration_str.split(':')
        try:
            if len(parts) == 1:
                return int(parts[0]) * 60
            elif len(parts) == 2:
                return int(parts[0]) * 60 + int(parts[1])
            elif len(parts) == 3:
                return int(parts[0]) * 3600 + int(parts[1]) * 60 + int(parts[2])
            else:
                raise ValueError
        except ValueError:
            raise ValueError("Ungültiges Dauerformat. Verwende Minuten (z.B. 10) oder HH:MM:SS (z.B. 1:30:00)")

    def parse_start_time(self, time_str):
        try:
            hour, minute = map(int, time_str.strip().split(':'))
            if not (0 <= hour <= 23 and 0 <= minute <= 59):
                raise ValueError
        except:
            raise ValueError("Startzeit muss im Format HH:MM sein (z.B. 14:30)")

        now = datetime.now()
        start = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
        if start <= now:
            start += timedelta(days=1)
        return start

    def schedule_recording(self):
        url = self.url_combo.get().strip()
        if not url:
            messagebox.showerror("Fehler", "Bitte eine Stream-URL eingeben oder auswählen.")
            return

        # Neue URL automatisch speichern
        self.add_url(url)

        start_time_str = self.start_time_entry.get().strip()
        try:
            start_dt = self.parse_start_time(start_time_str)
        except ValueError as e:
            messagebox.showerror("Fehler", str(e))
            return

        duration_str = self.duration_entry.get().strip()
        try:
            duration_sec = self.parse_duration(duration_str)
            if duration_sec <= 0:
                raise ValueError
        except ValueError as e:
            messagebox.showerror("Fehler", str(e))
            return

        output_file = self.output_entry.get().strip()
        if not output_file:
            timestamp = start_dt.strftime("%Y%m%d_%H%M%S")
            url_part = url.replace("https://", "").replace("http://", "").replace("/", "_").replace(":", "_")[:40]
            output_file = f"rec_{timestamp}_{url_part}.ts"
            self.output_entry.insert(0, output_file)

        output_dir = os.path.dirname(output_file)
        if output_dir and not os.path.exists(output_dir):
            try:
                os.makedirs(output_dir)
            except Exception as e:
                messagebox.showerror("Fehler", f"Verzeichnis konnte nicht erstellt werden: {e}")
                return

        now = datetime.now()
        wait_seconds = (start_dt - now).total_seconds()
        self.log(f"Geplante Aufnahme um {start_dt.strftime('%Y-%m-%d %H:%M:%S')} (in {wait_seconds:.0f} Sekunden)")
        self.log(f"Dauer: {duration_sec} Sekunden (entspricht {duration_sec/60:.1f} Minuten)")
        self.log(f"Zieldatei: {output_file}")

        self.schedule_button.config(state=tk.DISABLED)
        self.start_now_button.config(state=tk.DISABLED)
        self.cancel_schedule_button.config(state=tk.NORMAL)
        self.status_label.config(text=f"Geplant für {start_dt.strftime('%H:%M:%S')}", fg="orange")

        self.stop_event.clear()
        self.timer_thread = threading.Thread(target=self._wait_and_record, args=(wait_seconds, url, duration_sec, output_file), daemon=True)
        self.timer_thread.start()

    def _wait_and_record(self, wait_seconds, url, duration_sec, output_file):
        for _ in range(int(wait_seconds)):
            if self.stop_event.is_set():
                self.root.after(0, self._schedule_cancelled)
                return
            time.sleep(1)
        if self.stop_event.is_set():
            self.root.after(0, self._schedule_cancelled)
            return
        self.root.after(0, lambda: self._execute_recording(url, duration_sec, output_file))

    def _schedule_cancelled(self):
        self.log("Geplante Aufnahme wurde abgebrochen.")
        self.status_label.config(text="Planung abgebrochen", fg="red")
        self.schedule_button.config(state=tk.NORMAL)
        self.start_now_button.config(state=tk.NORMAL)
        self.cancel_schedule_button.config(state=tk.DISABLED)

    def start_now(self):
        url = self.url_combo.get().strip()
        if not url:
            messagebox.showerror("Fehler", "Bitte eine Stream-URL eingeben oder auswählen.")
            return

        # Neue URL automatisch speichern
        self.add_url(url)

        duration_str = self.duration_entry.get().strip()
        try:
            duration_sec = self.parse_duration(duration_str)
            if duration_sec <= 0:
                raise ValueError
        except ValueError as e:
            messagebox.showerror("Fehler", str(e))
            return

        output_file = self.output_entry.get().strip()
        if not output_file:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            url_part = url.replace("https://", "").replace("http://", "").replace("/", "_").replace(":", "_")[:40]
            output_file = f"rec_{timestamp}_{url_part}.ts"
            self.output_entry.insert(0, output_file)

        output_dir = os.path.dirname(output_file)
        if output_dir and not os.path.exists(output_dir):
            try:
                os.makedirs(output_dir)
            except Exception as e:
                messagebox.showerror("Fehler", f"Verzeichnis konnte nicht erstellt werden: {e}")
                return

        self._execute_recording(url, duration_sec, output_file)

    def _execute_recording(self, url, duration_sec, output_file):
        if self.recording_active:
            self.log("Aufnahme bereits aktiv.")
            return

        cmd = [
            "mpv",
            "--stream-record=" + output_file,
            "--length=" + str(duration_sec),
            "--force-window",
            "--quiet",
            url
        ]

        self.log(f"Starte Aufnahme: {output_file}")
        self.log(f"Dauer: {duration_sec} Sekunden (entspricht {duration_sec/60:.1f} Minuten)")
        self.log(f"Befehl: {' '.join(cmd)}")

        try:
            self.process = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True,
                bufsize=1
            )
            self.recording_active = True
            self.schedule_button.config(state=tk.DISABLED)
            self.start_now_button.config(state=tk.DISABLED)
            self.stop_button.config(state=tk.NORMAL)
            self.cancel_schedule_button.config(state=tk.DISABLED)
            self.status_label.config(text="Aufnahme läuft...", fg="orange")

            def read_stderr():
                if self.process and self.process.stderr:
                    for line in iter(self.process.stderr.readline, ''):
                        if line:
                            self.root.after(0, lambda l=line: self.log(f"mpv: {l.strip()}"))
                        if self.stop_event.is_set():
                            break

            stderr_thread = threading.Thread(target=read_stderr, daemon=True)
            stderr_thread.start()

            monitor = threading.Thread(target=self._monitor_process, daemon=True)
            monitor.start()

            self.root.after(duration_sec * 1000 + 5000, self._force_stop_if_stuck)

        except Exception as e:
            self.log(f"Fehler beim Start: {e}")
            messagebox.showerror("Fehler", f"mpv konnte nicht gestartet werden: {e}")
            self._reset_ui()

    def _monitor_process(self):
        if self.process:
            exit_code = self.process.wait()
            self.root.after(0, lambda: self._recording_finished(exit_code))

    def _recording_finished(self, exit_code):
        if self.recording_active:
            self.recording_active = False
            self.log(f"Aufnahme beendet (mpv wurde beendet, Exit-Code {exit_code}).")
            if exit_code != 0:
                self.log("Hinweis: Exit-Code ungleich null – möglicherweise ist ein Fehler aufgetreten. Siehe die mpv-Ausgaben oben.")
                self.status_label.config(text="Aufnahme mit Fehler beendet", fg="red")
            else:
                self.status_label.config(text="Aufnahme beendet", fg="green")
            self._reset_ui()
            if exit_code == 0:
                messagebox.showinfo("Fertig", "Die Aufnahme wurde erfolgreich beendet.")

    def _force_stop_if_stuck(self):
        if self.recording_active and self.process and self.process.poll() is None:
            self.log("WARNUNG: Aufnahme hängt – erzwinge Beendigung.")
            self.process.terminate()
            self.root.after(2000, lambda: self.process.kill() if self.process and self.process.poll() is None else None)

    def stop_recording(self):
        if self.process and self.process.poll() is None:
            self.log("Aufnahme wird gestoppt...")
            self.process.terminate()
            self.status_label.config(text="Stoppe...", fg="red")
        else:
            self.log("Keine aktive Aufnahme.")

    def cancel_schedule(self):
        if self.timer_thread and self.timer_thread.is_alive():
            self.stop_event.set()
            self.log("Planung wird abgebrochen...")
            self.status_label.config(text="Abbruch der Planung", fg="red")
        else:
            self.log("Keine aktive Planung vorhanden.")

    def _reset_ui(self):
        self.recording_active = False
        self.schedule_button.config(state=tk.NORMAL)
        self.start_now_button.config(state=tk.NORMAL)
        self.stop_button.config(state=tk.DISABLED)
        self.cancel_schedule_button.config(state=tk.DISABLED)
        if self.process and self.process.poll() is None:
            self.process.terminate()
        self.process = None

if __name__ == "__main__":
    root = tk.Tk()
    app = ScheduledRecorderApp(root)
    root.mainloop()