Valider la taille des fichiers déjà en cache pour détecter les fichiers incomplets

Problème :
Les fichiers déjà en cache (d'exécutions précédentes interrompues) étaient
considérés comme valides même s'ils étaient incomplets. Cela causait des
erreurs "FLAC decode error: Expected one more byte" lors de la lecture.

Solution :
Vérifier la taille du fichier en cache et la comparer avec min_prebuffer_size.
Si le fichier est trop petit (< 512 KB), il est supprimé et sera re-téléchargé/
ré-ingéré avec le bon prébuffering.

Changements :
- add_from_url() : vérifie file_size >= min_prebuffer_size pour les fichiers
  déjà en cache
- add_from_reader() : même vérification
- Si fichier trop petit : suppression et re-download/re-ingest
- Log warning explicite quand un fichier incomplet est détecté

Résultat :
✓ Les fichiers incomplets en cache sont détectés et re-téléchargés
✓ Garantit que les fichiers ont au minimum 512 KB (environ 5 secondes)
✓ Évite les erreurs de décodage sur des fichiers partiels

pmocache/src/cache.rs

@@ -200,14 +200,28 @@ impl<C: CacheConfig> Cache<C> {
         let pk = crate::cache_trait::pk_from_content_header(&header);
         tracing::debug!("Computed pk {} for URL {}", pk, url);
 
-        // 3. Vérifier si le fichier est déjà en cache
+        // 3. Vérifier si le fichier est déjà en cache ET complet
         if self.db.get(&pk, false).is_ok() {
             let file_path = self.get_file_path(&pk);
             if file_path.exists() {
-                // Déjà en cache, update timestamp et retour rapide
-                tracing::debug!("File with pk {} already in cache, updating timestamp", pk);
-                self.db.update_hit(&pk)?;
-                return Ok(pk);
+                // Vérifier si le fichier semble complet (taille >= min_prebuffer_size)
+                if let Ok(metadata) = std::fs::metadata(&file_path) {
+                    let file_size = metadata.len();
+                    if self.min_prebuffer_size > 0 && file_size < self.min_prebuffer_size {
+                        tracing::warn!(
+                            "File with pk {} in cache is too small ({} bytes < {} bytes), will re-download/re-ingest",
+                            pk, file_size, self.min_prebuffer_size
+                        );
+                        // Supprimer le fichier incomplet
+                        let _ = std::fs::remove_file(&file_path);
+                        // Continuer avec le téléchargement/ingestion
+                    } else {
+                        // Déjà en cache et complet, update timestamp et retour rapide
+                        tracing::debug!("File with pk {} already in cache, updating timestamp", pk);
+                        self.db.update_hit(&pk)?;
+                        return Ok(pk);
+                    }
+                }
             }
         }
 
@@ -315,14 +329,28 @@ impl<C: CacheConfig> Cache<C> {
             tracing::debug!("Computed pk {} from reader", pk);
         }
 
-        // 3. Vérifier si le fichier est déjà en cache
+        // 3. Vérifier si le fichier est déjà en cache ET complet
         if self.db.get(&pk, false).is_ok() {
             let file_path = self.get_file_path(&pk);
             if file_path.exists() {
-                // Déjà en cache, update timestamp et retour rapide
-                tracing::debug!("File with pk {} already in cache, updating timestamp", pk);
-                self.db.update_hit(&pk)?;
-                return Ok(pk);
+                // Vérifier si le fichier semble complet (taille >= min_prebuffer_size)
+                if let Ok(metadata) = std::fs::metadata(&file_path) {
+                    let file_size = metadata.len();
+                    if self.min_prebuffer_size > 0 && file_size < self.min_prebuffer_size {
+                        tracing::warn!(
+                            "File with pk {} in cache is too small ({} bytes < {} bytes), will re-download/re-ingest",
+                            pk, file_size, self.min_prebuffer_size
+                        );
+                        // Supprimer le fichier incomplet
+                        let _ = std::fs::remove_file(&file_path);
+                        // Continuer avec le téléchargement/ingestion
+                    } else {
+                        // Déjà en cache et complet, update timestamp et retour rapide
+                        tracing::debug!("File with pk {} already in cache, updating timestamp", pk);
+                        self.db.update_hit(&pk)?;
+                        return Ok(pk);
+                    }
+                }
             }
         }