main.py

#!/usr/bin/env python3
import json
import os
import shutil
import argparse
from core.content_generator.unified_news_generator import UnifiedNewsGenerator
from core.content_generator.stories import StoryGenerator
from core.content_generator.speech import SpeechConverter
from core.audio.audio_master import AudioMaster
from core.content_generator.radio_shows_manager import RadioShowsManager
from core.playlist.manager import Manager
from utils.logging_config import logger
from config.radio_schedule import get_shows_list_for_today
from config.background_music_settings import BG_MUSIC_SETTINGS
import requests
from dotenv import load_dotenv

load_dotenv()


def generate_all_content(system_prompts):
    """Génère tout le contenu (actualités, IA news, histoires, émissions spéciales)"""
    clear_storage_folders()
    logger.info("Début de la génération de contenu")

    # Génération du contenu textuel
    news_gen = UnifiedNewsGenerator()
    story_gen = StoryGenerator()

    # Générateur pour les émissions créatives de radio
    radio_shows_mgr = RadioShowsManager()

    # Génération du contenu pour chaque type d'émission
    news_articles, ai_news_articles = news_gen.generate_news_articles(
        system_prompts["prompts"]["news"],
        system_prompts["prompts"]["ai_news"],
    )
    stories = story_gen.generate_stories(system_prompts["prompts"]["bed_time_stories"])

    # Déterminer les émissions spéciales pour aujourd'hui (à partir de la config centralisée)
    creative_shows_to_generate = get_shows_list_for_today()

    # Génération des émissions créatives
    radio_shows = radio_shows_mgr.generate_all_shows(
        system_prompts["prompts"],
        selected_shows=creative_shows_to_generate,
        episodes_per_show=2,  # Nombre d'épisodes par émission
    )

    # Conversion en audio
    speech = SpeechConverter()

    # Conversion des actualités et histoires
    news_files = speech.convert_to_speech(news_articles, "news")
    ai_news_files = speech.convert_to_speech(ai_news_articles, "ai_news")
    story_files = speech.convert_to_speech(stories, "stories")

    # Conversion des émissions créatives
    radio_show_files = {}
    for show_name, episodes in radio_shows.items():
        logger.info(f"Converting {len(episodes)} episodes of {show_name} to speech")
        show_files = speech.convert_to_speech(episodes, show_name)
        radio_show_files[show_name] = show_files

    # Décharger le modèle TTS pour libérer la mémoire
    speech.unload_model()

    # Mastering audio
    master = AudioMaster()

    # Mastering des actualités et histoires avec musique de fond
    news_settings = BG_MUSIC_SETTINGS.get("news", {})
    news_files = master.process_files(
        news_files,
        "news",
        apply_bg_music=news_settings.get("use_background_music", False),
        **{k: v for k, v in news_settings.items() if k != "use_background_music"},
    )

    ai_news_settings = BG_MUSIC_SETTINGS.get("ai_news", {})
    ai_news_files = master.process_files(
        ai_news_files,
        "ai_news",
        apply_bg_music=ai_news_settings.get("use_background_music", False),
        **{k: v for k, v in ai_news_settings.items() if k != "use_background_music"},
    )

    stories_settings = BG_MUSIC_SETTINGS.get("stories", {})
    story_files = master.process_files(
        story_files,
        "stories",
        apply_bg_music=stories_settings.get("use_background_music", False),
        **{k: v for k, v in stories_settings.items() if k != "use_background_music"},
    )

    # Mastering des émissions créatives avec musique de fond appropriée
    for show_name, files in radio_show_files.items():
        show_settings = BG_MUSIC_SETTINGS.get(show_name, {})
        radio_show_files[show_name] = master.process_files(
            files,
            show_name,
            apply_bg_music=show_settings.get("use_background_music", False),
            **{k: v for k, v in show_settings.items() if k != "use_background_music"},
        )

    logger.info("Génération de contenu terminée")

    # Construire le dictionnaire final avec tous les fichiers
    all_files = {"news": news_files, "ai_news": ai_news_files, "stories": story_files}

    # Ajouter les émissions créatives
    all_files.update(radio_show_files)

    return all_files


def clear_storage_folders():
    """
    Supprime tout le contenu des dossiers storage
    """
    base_path = os.path.join(os.getcwd(), "storage")

    # Liste des dossiers à nettoyer, incluant ceux pour les émissions spéciales
    folders_to_clear = [
        "ai_news",
        "news",
        "stories",
        "skynet",
        "jean_michel_paradox",
        "cassandre_delirium",
        "vincent_voix_double",
        "mme_echo",
        "frequences_interdites",
        "expert_en_rien",
        "confessionnal_absurde",
        "journal_dimensions_paralleles",
        "standardiste_fantome",
        "objets_perdus",
        "conseils",
    ]

    for folder in folders_to_clear:
        folder_path = os.path.join(base_path, folder)

        if os.path.exists(folder_path):
            # Liste tous les éléments dans le dossier
            for item in os.listdir(folder_path):
                item_path = os.path.join(folder_path, item)

                try:
                    if os.path.isfile(item_path):
                        os.unlink(item_path)  # Supprime les fichiers
                    elif os.path.isdir(item_path):
                        shutil.rmtree(
                            item_path
                        )  # Supprime les sous-dossiers et leur contenu
                    logger.debug(f"Supprimé: {item_path}")
                except Exception as e:
                    logger.error(f"Erreur lors de la suppression de {item_path}: {e}")

            logger.info(f"Contenu du dossier {folder_path} supprimé avec succès")
        else:
            logger.warning(f"Le dossier {folder_path} n'existe pas")


def setup_background_music_folders():
    """
    Crée la structure de dossiers pour les musiques de fond
    """
    base_path = os.path.join(os.getcwd(), "assets", "background_music")

    # Liste des dossiers à créer (mêmes que les folders_to_clear + default)
    folders_to_create = [
        "ai_news",
        "news",
        "stories",
        "skynet",
        "jean_michel_paradox",
        "cassandre_delirium",
        "vincent_voix_double",
        "mme_echo",
        "frequences_interdites",
        "expert_en_rien",
        "confessionnal_absurde",
        "journal_dimensions_paralleles",
        "standardiste_fantome",
        "objets_perdus",
        "conseils",
        "default",  # Dossier par défaut pour fallback
    ]

    # Créer le dossier principal
    os.makedirs(base_path, exist_ok=True)

    # Créer les sous-dossiers
    for folder in folders_to_create:
        folder_path = os.path.join(base_path, folder)
        os.makedirs(folder_path, exist_ok=True)
        logger.debug(f"Dossier pour musique de fond créé: {folder_path}")

    logger.info(f"Structure de dossiers pour musique de fond créée: {base_path}")
    print(f"\nDossiers pour musique de fond créés dans: {base_path}")
    print("Placez-y vos boucles musicales de 12 secondes (formats .mp3, .wav, .ogg)")


def generate_playlist():
    """Génère une playlist unique pour la radio"""
    logger.info("Génération de la playlist principale")

    # Utiliser notre gestionnaire de playlist simplifié
    playlist_manager = Manager(start_hour=5)
    playlist_path = playlist_manager.create_master_playlist()

    logger.info(f"Playlist principale générée: {playlist_path}")
    return playlist_path


def main():
    parser = argparse.ArgumentParser(description="AI Harmony Radio System")
    parser.add_argument(
        "--content-only", action="store_true", help="Generate content only"
    )
    parser.add_argument(
        "--playlist-only", action="store_true", help="Generate playlist only"
    )
    parser.add_argument(
        "--shows", type=str, help="Comma-separated list of specific shows to generate"
    )
    parser.add_argument(
        "--setup-bg-music", action="store_true", help="Setup background music folders"
    )
    args = parser.parse_args()

    # Configuration des dossiers pour musique de fond si demandé
    if args.setup_bg_music:
        setup_background_music_folders()
        return

    with open("system_prompts.json", encoding="utf-8") as f:
        system_prompts = json.load(f)

    # Si des émissions spécifiques sont demandées
    if args.shows:
        # Surcharger les émissions du jour avec celles spécifiées
        creative_shows_to_generate = [show.strip() for show in args.shows.split(",")]
        logger.info(
            f"Generating specific shows: {', '.join(creative_shows_to_generate)}"
        )

        # Créer le gestionnaire d'émissions
        radio_shows_mgr = RadioShowsManager()

        # Générer uniquement les émissions spécifiées
        radio_shows = radio_shows_mgr.generate_all_shows(
            system_prompts["prompts"],
            selected_shows=creative_shows_to_generate,
            episodes_per_show=2,
        )

        # Conversion en audio et mastering
        speech = SpeechConverter()
        master = AudioMaster()

        radio_show_files = {}
        for show_name, episodes in radio_shows.items():
            logger.info(f"Converting {len(episodes)} episodes of {show_name} to speech")
            show_files = speech.convert_to_speech(episodes, show_name)

            # Utiliser les paramètres de musique de fond pour cette émission
            show_settings = BG_MUSIC_SETTINGS.get(show_name, {})
            radio_show_files[show_name] = master.process_files(
                show_files,
                show_name,
                apply_bg_music=show_settings.get("use_background_music", False),
                **{
                    k: v
                    for k, v in show_settings.items()
                    if k != "use_background_music"
                },
            )

        speech.unload_model()

        logger.info(f"Generated {len(radio_shows)} specific shows")
        return

    # Générer le contenu et/ou la playlist selon les options
    if args.content_only:
        generate_all_content(system_prompts)
    elif args.playlist_only:
        generate_playlist()
    else:
        # Mode complet : générer le contenu puis la playlist
        generate_all_content(system_prompts)
        generate_playlist()


if __name__ == "__main__":
    main()