#!/usr/bin/env python3
"""
SERMAN RSS Feed Generator - Lokale Version
Generiert RSS-Feeds aus lokalen MP3-Dateien für Podcast-Apps.
Optimiert für Cron-Jobs.
"""

from local_podcast_generator import LocalPodcastGenerator
import argparse
import sys
import os
import contextlib
from io import StringIO


class QuietLocalPodcastGenerator(LocalPodcastGenerator):
    """Erweiterte Version des Generators mit Quiet-Mode-Unterstützung."""
    
    def __init__(self, audio_dir="../httpdocs/_audio", output_file="podcast_feed.xml", 
                 base_url="https://www.serman.club", quiet=False):
        super().__init__(audio_dir, output_file, base_url)
        self.quiet = quiet
        self.errors = []
    
    def log(self, message):
        """Logging-Funktion die das quiet-Flag berücksichtigt."""
        if not self.quiet:
            print(message)
    
    def log_error(self, message):
        """Error-Logging das immer ausgegeben wird."""
        print(message)
        self.errors.append(message)
    
    def get_mp3_files(self):
        """Überschreibt die Original-Methode für besseres Logging."""
        from pathlib import Path
        
        audio_path = Path(self.audio_dir)
        if not audio_path.exists():
            self.log_error(f"❌ Audio-Verzeichnis '{self.audio_dir}' existiert nicht!")
            return []
        
        mp3_files = list(audio_path.glob("*.mp3"))
        self.log(f"🎵 {len(mp3_files)} MP3-Dateien gefunden in '{self.audio_dir}/'")
        
        # Debug: Zeige alle gefundenen Dateien
        for i, mp3_file in enumerate(mp3_files):
            self.log(f"   Datei {i+1}: '{mp3_file.name}'")
        
        # Benenne MP3-Dateien um (Leerzeichen → Unterstriche)
        renamed_files = []
        rename_count = 0
        for mp3_file in mp3_files:
            self.log(f"   🔍 Prüfe: '{mp3_file.name}' - Leerzeichen vorhanden: {' ' in mp3_file.name}")
            if ' ' in mp3_file.name:
                # Neuer Dateiname ohne Leerzeichen
                new_name = mp3_file.name.replace(' ', '_')
                new_path = mp3_file.parent / new_name
                
                # Prüfe ob neue Datei bereits existiert
                if not new_path.exists():
                    try:
                        mp3_file.rename(new_path)
                        self.log(f"   📝 Umbenannt: '{mp3_file.name}' → '{new_name}'")
                        renamed_files.append(new_path)
                        rename_count += 1
                    except Exception as e:
                        self.log_error(f"   ⚠️  Fehler beim Umbenennen von '{mp3_file.name}': {e}")
                        renamed_files.append(mp3_file)
                else:
                    self.log(f"   ⚠️  Datei '{new_name}' existiert bereits, überspringe Umbenennung")
                    # Verwende die bereits existierende umbenannte Datei
                    renamed_files.append(new_path)
            else:
                self.log(f"   ✅ Keine Umbenennung nötig: '{mp3_file.name}'")
                renamed_files.append(mp3_file)
        
        self.log(f"   📊 {rename_count} Dateien umbenannt, {len(renamed_files)} Dateien total")
        
        # Sortiere nach Änderungsdatum (neueste zuerst)
        renamed_files.sort(key=lambda x: x.stat().st_mtime, reverse=True)
        
        return renamed_files
    
    def create_rss_feed_quiet(self, podcast_title="SERMAN - Organic House Podcast", 
                             podcast_description=None, podcast_author="SERMAN"):
        """RSS-Feed-Erstellung mit unterdrückter Ausgabe für Cron-Jobs."""
        
        if self.quiet:
            # Unterdrücke alle print-Ausgaben während der Feed-Erstellung
            with contextlib.redirect_stdout(StringIO()), contextlib.redirect_stderr(StringIO()):
                try:
                    return super().create_rss_feed(podcast_title, podcast_description, podcast_author)
                except Exception as e:
                    self.log_error(f"❌ Fehler beim Erstellen des RSS-Feeds: {e}")
                    return False
        else:
            # Normale Ausgabe
            return super().create_rss_feed(podcast_title, podcast_description, podcast_author)


def main():
    parser = argparse.ArgumentParser(description="SERMAN RSS Feed Generator - Lokale Version")
    parser.add_argument("-a", "--audio-dir", default="../httpdocs/_audio", 
                       help="Verzeichnis mit MP3-Dateien (Standard: ../httpdocs/_audio)")
    parser.add_argument("-o", "--output", default="serman_podcast.xml", 
                       help="Ausgabedatei für den RSS-Feed (Standard: serman_podcast.xml)")
    parser.add_argument("-u", "--base-url", default="https://www.serman.club",
                       help="Basis-URL für Audio-Dateien (Standard: https://www.serman.club)")
    parser.add_argument("-t", "--title", default="SERMAN - Organic House Podcast",
                       help="Titel des Podcasts")
    parser.add_argument("--author", default="SERMAN",
                       help="Autor des Podcasts")
    parser.add_argument("-q", "--quiet", action="store_true",
                       help="Unterdrückt Ausgaben (nützlich für Cron-Jobs)")
    
    args = parser.parse_args()
    
    # Unterdrücke Ausgaben wenn --quiet gesetzt ist
    def log(message):
        if not args.quiet:
            print(message)
    
    log("🎵 SERMAN RSS Feed Generator - Lokale Version")
    log("=" * 50)
    
    # Prüfe ob Audio-Verzeichnis existiert
    if not os.path.exists(args.audio_dir):
        log(f"❌ Audio-Verzeichnis '{args.audio_dir}' existiert nicht!")
        log(f"💡 Erstelle das Verzeichnis und lege deine MP3-Dateien dort ab.")
        return 1
    
    # Erstelle den Generator
    generator = QuietLocalPodcastGenerator(
        audio_dir=args.audio_dir,
        output_file=args.output,
        base_url=args.base_url,
        quiet=args.quiet
    )
    
    # Generiere den RSS-Feed
    log(f"📂 Scanne '{args.audio_dir}/' nach MP3-Dateien...")
    success = generator.create_rss_feed_quiet(
        podcast_title=args.title,
        podcast_author=args.author
    )
    
    if not success:
        log("❌ Fehler beim Erstellen des RSS-Feeds!")
        # Zeige Fehler auch im quiet-Modus
        if args.quiet and hasattr(generator, 'errors') and generator.errors:
            for error in generator.errors:
                print(error)
        return 1
    
    log("\n🎉 RSS-Feed erfolgreich erstellt!")
    log(f"📄 Datei: {args.output}")
    log(f"🌐 URL: {args.base_url}/{args.output}")
    
    # Im quiet-Modus nur Erfolg bei Fehlern ausgeben
    if args.quiet and success:
        print(f"✅ RSS-Feed erfolgreich erstellt: {args.output}")
    
    return 0


if __name__ == "__main__":
    sys.exit(main())