support config editing and create default if no exist

Author: van-sprundel

src/config.rs

@@ -1,5 +1,5 @@
 use directories::ProjectDirs;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use thiserror::Error;
 
@@ -17,7 +17,7 @@ pub enum ConfigError {
     ValidationError(String),
 }
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Config {
     pub prowlarr: ProwlarrConfig,
     pub tmdb: Option<TmdbConfig>,
@@ -31,47 +31,51 @@ pub struct Config {
     pub subtitles: SubtitlesConfig,
 }
 
-#[derive(Debug, Clone, Default, Deserialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct ExtensionsConfig {
     #[serde(default)]
     pub discord: DiscordConfig,
     #[serde(default)]
     pub trakt: TraktConfig,
 }
 
-#[derive(Debug, Clone, Default, Deserialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct DiscordConfig {
     #[serde(default)]
     pub enabled: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub app_id: Option<String>,
 }
 
-#[derive(Debug, Clone, Default, Deserialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct TraktConfig {
     #[serde(default)]
     pub enabled: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub client_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub access_token: Option<String>,
 }
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ProwlarrConfig {
     pub url: String,
     pub apikey: String,
 }
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct TmdbConfig {
     pub apikey: String,
 }
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct SubtitlesConfig {
     #[serde(default = "default_subtitles_enabled")]
     pub enabled: bool,
     #[serde(default = "default_subtitle_language")]
     pub language: String,
     /// OpenSubtitles API key for fetching subtitles when not included in torrent
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub opensubtitles_api_key: Option<String>,
 }
 
@@ -93,11 +97,11 @@ fn default_subtitle_language() -> String {
     "en".to_string()
 }
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct PlayerConfig {
     #[serde(default = "default_player_command")]
     pub command: String,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub args: Vec<String>,
 }
 
@@ -114,8 +118,9 @@ fn default_player_command() -> String {
     "mpv".to_string()
 }
 
-#[derive(Default, Debug, Clone, Deserialize)]
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct StorageConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub temp_dir: Option<PathBuf>,
 }
 
@@ -133,6 +138,17 @@ impl Config {
         Self::load_from(&path)
     }
 
+    /// Load config, creating a default one if it doesn't exist
+    pub fn load_or_create() -> Result<Self, ConfigError> {
+        let path = Self::config_path()?;
+        if !path.exists() {
+            let config = Self::default();
+            config.save()?;
+            return Ok(config);
+        }
+        Self::load_from(&path)
+    }
+
     pub fn load_from(path: &PathBuf) -> Result<Self, ConfigError> {
         if !path.exists() {
             return Err(ConfigError::NotFound(path.clone()));
@@ -150,6 +166,18 @@ impl Config {
             .ok_or(ConfigError::NoConfigDir)
     }
 
+    pub fn save(&self) -> Result<(), ConfigError> {
+        let path = Self::config_path()?;
+        // Ensure parent directory exists
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        let contents = toml::to_string_pretty(self)
+            .map_err(|e| ConfigError::ValidationError(format!("failed to serialize: {}", e)))?;
+        std::fs::write(&path, contents)?;
+        Ok(())
+    }
+
     fn validate(&self) -> Result<(), ConfigError> {
         // Validate Prowlarr URL
         if self.prowlarr.url.is_empty() {
@@ -175,3 +203,19 @@ impl Config {
         Ok(())
     }
 }
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            prowlarr: ProwlarrConfig {
+                url: "http://localhost:9696".to_string(),
+                apikey: String::new(),
+            },
+            tmdb: None,
+            player: PlayerConfig::default(),
+            storage: StorageConfig::default(),
+            extensions: ExtensionsConfig::default(),
+            subtitles: SubtitlesConfig::default(),
+        }
+    }
+}

src/extensions/mod.rs

@@ -18,6 +18,67 @@ pub struct MediaInfo {
     pub media_type: Option<String>,
     /// Poster URL from TMDB (for Discord RPC)
     pub poster_url: Option<String>,
+    /// Season number (parsed from filename for TV shows)
+    pub season: Option<u32>,
+    /// Episode number (parsed from filename for TV shows)
+    pub episode: Option<u32>,
+}
+
+/// Parse season and episode number from a filename.
+///
+/// Supports common patterns:
+/// - S01E02, s01e02, S1E2
+/// - 1x02, 01x02
+/// - Season 1 Episode 2
+/// - .102. (season 1, episode 02)
+pub fn parse_episode_info(filename: &str) -> (Option<u32>, Option<u32>) {
+    use regex::Regex;
+
+    // S01E02, S1E2 format (most common)
+    let sxex_re = Regex::new(r"(?i)[Ss](\d{1,2})[Ee](\d{1,3})").unwrap();
+    if let Some(caps) = sxex_re.captures(filename) {
+        if let (Some(s), Some(e)) = (caps.get(1), caps.get(2)) {
+            if let (Ok(season), Ok(episode)) = (s.as_str().parse(), e.as_str().parse()) {
+                return (Some(season), Some(episode));
+            }
+        }
+    }
+
+    // 1x02, 01x02 format
+    let x_re = Regex::new(r"(?i)(\d{1,2})x(\d{1,3})").unwrap();
+    if let Some(caps) = x_re.captures(filename) {
+        if let (Some(s), Some(e)) = (caps.get(1), caps.get(2)) {
+            if let (Ok(season), Ok(episode)) = (s.as_str().parse(), e.as_str().parse()) {
+                return (Some(season), Some(episode));
+            }
+        }
+    }
+
+    // Season 1 Episode 2 format (also handles dots instead of spaces)
+    let full_re = Regex::new(r"(?i)season[.\s]*(\d{1,2}).*episode[.\s]*(\d{1,3})").unwrap();
+    if let Some(caps) = full_re.captures(filename) {
+        if let (Some(s), Some(e)) = (caps.get(1), caps.get(2)) {
+            if let (Ok(season), Ok(episode)) = (s.as_str().parse(), e.as_str().parse()) {
+                return (Some(season), Some(episode));
+            }
+        }
+    }
+
+    // .102. or .1002. format (season 1, episode 02 or season 10, episode 02)
+    // Must be surrounded by dots/spaces to avoid matching years
+    let compact_re = Regex::new(r"[.\s](\d)(\d{2})[.\s]").unwrap();
+    if let Some(caps) = compact_re.captures(filename) {
+        if let (Some(s), Some(e)) = (caps.get(1), caps.get(2)) {
+            if let (Ok(season), Ok(episode)) = (s.as_str().parse::<u32>(), e.as_str().parse::<u32>()) {
+                // Only valid if episode isn't too high (avoid matching years like 1999)
+                if (1..=99).contains(&season) && (1..=99).contains(&episode) {
+                    return (Some(season), Some(episode));
+                }
+            }
+        }
+    }
+
+    (None, None)
 }
 
 /// Playback event sent to extensions
@@ -101,3 +162,66 @@ impl Default for ExtensionManager {
         Self::new()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_episode_sxex_format() {
+        assert_eq!(
+            parse_episode_info("Show.Name.S01E02.720p.HDTV.mkv"),
+            (Some(1), Some(2))
+        );
+        assert_eq!(
+            parse_episode_info("Show.Name.S10E23.720p.mkv"),
+            (Some(10), Some(23))
+        );
+        assert_eq!(
+            parse_episode_info("show.s1e5.web.mp4"),
+            (Some(1), Some(5))
+        );
+    }
+
+    #[test]
+    fn test_parse_episode_x_format() {
+        assert_eq!(
+            parse_episode_info("Show.Name.1x02.HDTV.mkv"),
+            (Some(1), Some(2))
+        );
+        assert_eq!(
+            parse_episode_info("Show.Name.10x23.mkv"),
+            (Some(10), Some(23))
+        );
+    }
+
+    #[test]
+    fn test_parse_episode_full_format() {
+        assert_eq!(
+            parse_episode_info("Show Name Season 1 Episode 2.mkv"),
+            (Some(1), Some(2))
+        );
+        assert_eq!(
+            parse_episode_info("Show.Name.Season.3.Episode.15.mkv"),
+            (Some(3), Some(15))
+        );
+    }
+
+    #[test]
+    fn test_parse_episode_no_match() {
+        assert_eq!(parse_episode_info("Movie.2019.1080p.BluRay.mkv"), (None, None));
+        assert_eq!(parse_episode_info("Random.File.Name.mkv"), (None, None));
+    }
+
+    #[test]
+    fn test_parse_episode_case_insensitive() {
+        assert_eq!(
+            parse_episode_info("show.S01e02.mkv"),
+            (Some(1), Some(2))
+        );
+        assert_eq!(
+            parse_episode_info("show.s01E02.mkv"),
+            (Some(1), Some(2))
+        );
+    }
+}

src/extensions/trakt.rs

@@ -77,8 +77,30 @@ impl TraktExtension {
             .is_some_and(|t| t == "tv" || t == "show");
 
         if is_tv {
-            // For TV shows, we'd need season/episode info which we don't have yet
-            // Just scrobble as a show for now (Trakt may not accept this)
+            // Build episode info if we have season/episode from filename
+            let episode_info = match (media.season, media.episode) {
+                (Some(s), Some(e)) => {
+                    tracing::debug!(
+                        title = %media.title,
+                        season = s,
+                        episode = e,
+                        "trakt: parsed episode info from filename"
+                    );
+                    Some(ScrobbleEpisode {
+                        season: s,
+                        number: e,
+                    })
+                }
+                _ => {
+                    tracing::debug!(
+                        title = %media.title,
+                        filename = %media.file_name,
+                        "trakt: no episode info found in filename"
+                    );
+                    None
+                }
+            };
+
             Some(ScrobbleRequest {
                 movie: None,
                 show: Some(ScrobbleShow {
@@ -88,7 +110,7 @@ impl TraktExtension {
                         tmdb: Some(tmdb_id),
                     },
                 }),
-                episode: None, // TODO: Parse season/episode from filename
+                episode: episode_info,
                 progress,
             })
         } else {

src/main.rs

@@ -42,24 +42,24 @@ async fn main() {
             .init();
     }
 
-    let config = match Config::load() {
-        Ok(config) => config,
+    let (config, is_new) = match Config::load() {
+        Ok(config) => (config, false),
+        Err(config::ConfigError::NotFound(_)) => {
+            // Config doesn't exist - create default and open settings
+            match Config::load_or_create() {
+                Ok(config) => {
+                    eprintln!("Created default config. Opening settings to configure...");
+                    std::thread::sleep(std::time::Duration::from_secs(1));
+                    (config, true)
+                }
+                Err(e) => {
+                    eprintln!("Failed to create config: {}", e);
+                    std::process::exit(1);
+                }
+            }
+        }
         Err(e) => {
             eprintln!("Failed to load config: {}", e);
-            if let config::ConfigError::NotFound(path) = &e {
-                eprintln!("\nCreate a config file at: {}", path.display());
-                eprintln!("\nExample config.toml:");
-                eprintln!(
-                    r#"
-[prowlarr]
-url = "http://localhost:9696"
-apikey = "your-api-key"
-
-[player]
-command = "mpv"
-"#
-                );
-            }
             std::process::exit(1);
         }
     };
@@ -80,7 +80,7 @@ command = "mpv"
         )));
     }
 
-    let result = tui::run(config, ext_manager).await;
+    let result = tui::run(config, ext_manager, is_new).await;
 
     if let Err(e) = result {
         eprintln!("Error: {}", e);