feat: add local files provider with indexing and rescan functionality

- Implemented LocalFilesProvider to manage local video files.
- Added LocalIndex for in-memory and SQLite-backed indexing of video files.
- Introduced scanning functionality to detect video files and extract metadata.
- Added API endpoints for listing collections, genres, and series based on provider capabilities.
- Enhanced existing routes to check for provider capabilities before processing requests.
- Updated frontend to utilize provider capabilities for conditional rendering of UI elements.
- Implemented rescan functionality to refresh the local files index.
- Added database migration for local files index schema.

k-tv-backend/infra/src/local_files/provider.rs

@@ -0,0 +1,165 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use domain::{
+    Collection, ContentType, DomainError, DomainResult, IMediaProvider, MediaFilter, MediaItem,
+    MediaItemId, ProviderCapabilities, StreamingProtocol,
+};
+
+use super::config::LocalFilesConfig;
+use super::index::{LocalIndex, decode_id};
+use super::scanner::LocalFileItem;
+
+pub struct LocalFilesProvider {
+    pub index: Arc<LocalIndex>,
+    base_url: String,
+}
+
+const SHORT_DURATION_SECS: u32 = 1200; // 20 minutes
+
+impl LocalFilesProvider {
+    pub fn new(index: Arc<LocalIndex>, config: LocalFilesConfig) -> Self {
+        Self {
+            index,
+            base_url: config.base_url.trim_end_matches('/').to_string(),
+        }
+    }
+}
+
+fn to_media_item(id: MediaItemId, item: &LocalFileItem) -> MediaItem {
+    let content_type = if item.duration_secs < 1200 {
+        ContentType::Short
+    } else {
+        ContentType::Movie
+    };
+    MediaItem {
+        id,
+        title: item.title.clone(),
+        content_type,
+        duration_secs: item.duration_secs,
+        description: None,
+        genres: vec![],
+        year: item.year,
+        tags: item.tags.clone(),
+        series_name: None,
+        season_number: None,
+        episode_number: None,
+    }
+}
+
+#[async_trait]
+impl IMediaProvider for LocalFilesProvider {
+    fn capabilities(&self) -> ProviderCapabilities {
+        ProviderCapabilities {
+            collections: true,
+            series: false,
+            genres: false,
+            tags: true,
+            decade: true,
+            search: true,
+            streaming_protocol: StreamingProtocol::DirectFile,
+            rescan: true,
+        }
+    }
+
+    async fn fetch_items(&self, filter: &MediaFilter) -> DomainResult<Vec<MediaItem>> {
+        let all = self.index.get_all().await;
+
+        let results = all
+            .into_iter()
+            .filter_map(|(id, item)| {
+                // content_type: derive heuristically, then filter
+                let content_type = if item.duration_secs < SHORT_DURATION_SECS {
+                    ContentType::Short
+                } else {
+                    ContentType::Movie
+                };
+                if let Some(ref ct) = filter.content_type {
+                    if &content_type != ct {
+                        return None;
+                    }
+                }
+
+                // collections: match against top_dir
+                if !filter.collections.is_empty() && !filter.collections.contains(&item.top_dir) {
+                    return None;
+                }
+
+                // tags: OR — item must have at least one matching tag
+                if !filter.tags.is_empty() {
+                    let has = filter
+                        .tags
+                        .iter()
+                        .any(|tag| item.tags.iter().any(|t| t.eq_ignore_ascii_case(tag)));
+                    if !has {
+                        return None;
+                    }
+                }
+
+                // decade: year in [decade, decade+9]
+                if let Some(decade) = filter.decade {
+                    match item.year {
+                        Some(y) if y >= decade && y <= decade + 9 => {}
+                        _ => return None,
+                    }
+                }
+
+                // duration bounds
+                if let Some(min) = filter.min_duration_secs {
+                    if item.duration_secs < min {
+                        return None;
+                    }
+                }
+                if let Some(max) = filter.max_duration_secs {
+                    if item.duration_secs > max {
+                        return None;
+                    }
+                }
+
+                // search_term: case-insensitive substring in title
+                if let Some(ref q) = filter.search_term {
+                    if !item.title.to_lowercase().contains(&q.to_lowercase()) {
+                        return None;
+                    }
+                }
+
+                Some(to_media_item(id, &item))
+            })
+            .collect();
+
+        Ok(results)
+    }
+
+    async fn fetch_by_id(&self, item_id: &MediaItemId) -> DomainResult<Option<MediaItem>> {
+        Ok(self
+            .index
+            .get(item_id)
+            .await
+            .map(|item| to_media_item(item_id.clone(), &item)))
+    }
+
+    async fn get_stream_url(&self, item_id: &MediaItemId) -> DomainResult<String> {
+        Ok(format!(
+            "{}/api/v1/files/stream/{}",
+            self.base_url,
+            item_id.as_ref()
+        ))
+    }
+
+    async fn list_collections(&self) -> DomainResult<Vec<Collection>> {
+        let dirs = self.index.collections().await;
+        Ok(dirs
+            .into_iter()
+            .map(|d| Collection {
+                id: d.clone(),
+                name: d,
+                collection_type: None,
+            })
+            .collect())
+    }
+}
+
+/// Decode an encoded ID from a URL path segment to its relative path string.
+pub fn decode_stream_id(encoded: &str) -> Option<String> {
+    decode_id(&MediaItemId::new(encoded))
+}