Guide d’implémentation d’une nouvelle MusicSource

#[derive(Clone)]
pub struct QobuzSource {
    inner: Arc<QobuzSourceInner>,
}

struct QobuzSourceInner {
    client: Arc<QobuzClient>,
    cache_manager: SourceCacheManager,
    base_url: String,
    update_counter: tokio::sync::RwLock<u32>,
    last_change: tokio::sync::RwLock<SystemTime>,
}

impl QobuzSource {
    // Ajouter un track avec cache lazy
    pub async fn add_track_lazy(&self, track: &Track) -> Result<(String, String)> {
        let track_id = format!("qobuz://track/{}", track.id);
        let lazy_pk = format!("QOBUZ:{}", track.id);

        // 1. Cache cover EAGERLY (petit, UI en a besoin)
        let cached_cover_pk = if let Some(ref image_url) = track.album.as_ref()
            .and_then(|a| a.image.as_ref()) {
            self.inner.cache_manager.cache_cover(image_url).await.ok()
        } else {
            None
        };

        // 2. Préparer metadata
        let metadata = AudioMetadata {
            title: Some(track.title.clone()),
            artist: track.performer.as_ref().map(|p| p.name.clone()),
            album: track.album.as_ref().map(|a| a.title.clone()),
            duration_secs: Some(track.duration as u64),
            // ... autres champs
        };

        // 3. Cache audio LAZILY (grand, téléchargé à la demande)
        let cached_audio_pk = self
            .inner
            .cache_manager
            .cache_audio_lazy_with_provider(
                &lazy_pk,
                Some(metadata.clone()),
                cached_cover_pk.clone(),
            )
            .await?;

        // 4. Stocker metadata
        self.inner.cache_manager.update_metadata(
            track_id.clone(),
            pmosource::TrackMetadata {
                original_uri: stream_url,
                cached_audio_pk: Some(cached_audio_pk.clone()),
                cached_cover_pk,
            },
        ).await;

        Ok((track_id, cached_audio_pk))
    }

    // Créer une playlist d'album avec TTL
    async fn get_or_create_album_playlist_items(
        &self,
        album_id: &str,
        limit: usize,
    ) -> Result<Vec<Item>> {
        const ALBUM_PLAYLIST_TTL: Duration = Duration::from_secs(7 * 24 * 3600);

        let playlist_id = format!("qobuz-album-{}", album_id);
        let playlist_manager = PlaylistManager();

        // Vérifier validité (existe ET non expirée ET non vide)
        let is_valid = self.is_album_playlist_valid(&playlist_id).await?;

        if is_valid {
            // Récupérer depuis playlist existante
            let reader = playlist_manager.get_read_handle(&playlist_id).await?;
            let items = reader.to_items(limit).await?;
            return self.adapt_playlist_items_to_qobuz(items, album_id).await;
        }

        // Créer nouvelle playlist
        let writer = playlist_manager
            .create_persistent_playlist_with_role(
                playlist_id.clone(),
                pmoplaylist::PlaylistRole::Album,
            )
            .await?;

        // Ajouter tracks avec cache lazy
        self.add_album_to_playlist(&playlist_id, album_id).await?;

        // Récupérer items
        let reader = playlist_manager.get_read_handle(&playlist_id).await?;
        let items = reader.to_items(limit).await?;
        self.adapt_playlist_items_to_qobuz(items, album_id).await
    }
}