pmomusic/PMOMusic/src/main.rs

use pmoapp::{WebAppExt, Webapp};
use pmocovers::CoverCacheExt;
use pmomediarenderer::MEDIA_RENDERER;
use pmomediaserver::{MEDIA_SERVER, sources::SourcesExt, MediaServerExt, sources_api_router};
use pmoserver::{ServerBuilder, logs::LoggingOptions};
use pmoupnp::{UpnpServer, ssdp::SsdpServer, upnp_api::UpnpApiExt};
use tracing::info;

#[tokio::main]
async fn main() {
    // Créer le serveur - le trait UpnpServer étend automatiquement Server
    let mut server = ServerBuilder::new_configured().build();

    // Initialiser le logging et enregistrer les routes de logs
    server.init_logging().await;

    info!("📡 Registering the cover cache...");
    let cache = server
        .init_cover_cache_configured()
        .await
        .expect("Cannot initialise the image cache");

    info!("✅ Cover cache ready at {}", cache.cache_dir(),);

    // Routes de base
    server
        .add_route("/info", || async {
            serde_json::json!({"version": "1.0.0"})
        })
        .await;

    // Ajouter la webapp via le trait WebAppExt
    info!("📡 Registering Web application...");
    server.add_webapp_with_redirect::<Webapp>("/app").await;

    // Enregistrer l'API d'introspection UPnP
    server.register_upnp_api().await;

    // Enregistrer l'API de gestion des sources musicales
    info!("📡 Registering Sources API...");
    server.add_router("/api", sources_api_router()).await;

    info!("📡 Registering MediaRenderer...");
    let renderer_instance = server
        .register_device(MEDIA_RENDERER.clone())
        .await
        .expect("Failed to register MediaRenderer routes");

    info!(
        "✅ MediaRenderer ready at {}{}",
        renderer_instance.base_url(),
        renderer_instance.description_route()
    );

    // Enregistrer les sources musicales
    info!("📡 Registering music sources...");

    // Enregistrer Qobuz depuis la configuration
    if let Err(e) = server.register_qobuz_from_config().await {
        tracing::warn!("Failed to register Qobuz: {}", e);
    }

    // Lister toutes les sources enregistrées
    let sources = server.list_music_sources().await;
    info!("✅ {} music source(s) registered", sources.len());
    for source in sources {
        info!("  - {} ({})", source.name(), source.id());
    }

    info!("📡 Registering MediaServer...");
    let server_instance = server
        .register_device(MEDIA_SERVER.clone())
        .await
        .expect("Failed to register MediaServer routes");

    info!(
        "✅ MediaServer ready at {}{}",
        server_instance.base_url(),
        server_instance.description_route()
    );

    // Créer et démarrer le serveur SSDP
    info!("📡 Starting SSDP discovery...");
    let mut ssdp_server = SsdpServer::new();
    ssdp_server.start().expect("Failed to start SSDP server");

    // Créer et enregistrer le device SSDP pour le MediaRenderer
    let ssdp_device = renderer_instance.to_ssdp_device("PMOMusic", "1.0");
    ssdp_server.add_device(ssdp_device);
    info!("✅ SSDP announcements sent for MediaRenderer");

    server.start().await;
    server.wait().await;
}