rusty_commit_saver/

config.rs

use chrono::DateTime;
use log::{error, info, warn};

use std::{
    fs,
    path::{Path, PathBuf},
};

use clap::Parser;
use configparser::ini::Ini;
use dirs::home_dir;
use once_cell::sync::OnceCell;

/// Parses INI file content into a configuration object without file I/O.
///
/// This is a pure function that takes raw INI text and parses it into an `Ini` struct.
/// It's useful for testing configuration parsing logic without reading from disk.
///
/// # Arguments
///
/// * `content` - The raw INI file content as a string
///
/// # Returns
///
/// - `Ok(Ini)` - Successfully parsed configuration
/// - `Err(String)` - Parsing failed with error description
///
/// # INI Format
///
/// The INI format supported:
/// ```text
/// [section_name]
/// key1 = value1
/// key2 = value2
///
/// [another_section]
/// key3 = value3
/// ```
///
/// # Examples
///
/// ```ignore
/// use rusty_commit_saver::config::parse_ini_content;
///
/// let ini_content = r#"
/// [obsidian]
/// root_path_dir = ~/Documents/Obsidian
/// commit_path = Diaries/Commits
///
/// [templates]
/// commit_date_path = %Y/%m-%B/%F.md
/// commit_datetime = %Y-%m-%d %H:%M:%S
/// "#;
///
/// let config = parse_ini_content(ini_content).unwrap();
///
/// // Access parsed values
/// assert_eq!(
///     config.get("obsidian", "root_path_dir"),
///     Some("~/Documents/Obsidian".to_string())
/// );
/// assert_eq!(
///     config.get("templates", "commit_date_path"),
///     Some("%Y/%m-%B/%F.md".to_string())
/// );
/// ```
///
/// # Errors
///
/// Returns an error if:
/// - INI syntax is invalid (malformed sections or key-value pairs)
/// - The content cannot be parsed as valid UTF-8
///
/// # Testing
///
/// This function is particularly useful for unit testing without needing
/// to create temporary files:
///
/// ```ignore
/// use rusty_commit_saver::config::parse_ini_content;
///
/// fn test_config_parsing() {
///     let test_config = "[section]\nkey=value\n";
///     let result = parse_ini_content(test_config);
///     assert!(result.is_ok());
/// }
/// ```
pub fn parse_ini_content(content: &str) -> Result<Ini, String> {
    let mut config = Ini::new();
    config
        .read(content.to_string())
        .map_err(|e| format!("Failed to parse INI: {e:?}"))?;
    Ok(config)
}

/// Thread-safe global configuration container for Rusty Commit Saver.
///
/// This struct holds all runtime configuration loaded from the INI file,
/// using `OnceCell` for lazy initialization and thread safety. Configuration
/// values are set once during initialization and remain immutable thereafter.
///
/// # Usage Pattern
///
/// ```ignore
/// use rusty_commit_saver::config::GlobalVars;
///
/// // 1. Create instance
/// let global_vars = GlobalVars::new();
///
/// // 2. Load configuration from INI file
/// global_vars.set_all();
///
/// // 3. Access configuration values
/// let obsidian_root = global_vars.get_obsidian_root_path_dir();
/// let commit_path = global_vars.get_obsidian_commit_path();
/// ```
///
/// # See Also
///
/// - [`GlobalVars::new()`] - Create new instance
/// - [`GlobalVars::set_all()`] - Initialize from INI file
/// - [`parse_ini_content()`] - Parse INI content
#[derive(Debug, Default)]
pub struct GlobalVars {
    /// The parsed INI configuration file.
    ///
    /// Stores the complete parsed configuration from the INI file.
    /// Initialized once by [`set_all()`](Self::set_all).
    ///
    /// # Thread Safety
    ///
    /// `OnceCell` ensures this is set exactly once and can be safely
    /// accessed from multiple threads.
    pub config: OnceCell<Ini>,

    /// Path of the INI the configuration was read from.
    ///
    /// Retained so a configuration error can name the file to edit. Set by
    /// [`set_all()`](Self::set_all); a `GlobalVars` handed a config directly
    /// (as the tests do) leaves it unset.
    pub config_path: OnceCell<String>,

    /// Root directory of the Obsidian vault.
    ///
    /// The base directory where all Obsidian files are stored.
    /// All diary entries are created under this directory.
    ///
    /// # Examples
    ///
    /// - `/home/user/Documents/Obsidian`
    /// - `C:\Users\username\Documents\Obsidian` (Windows)
    ///
    /// # Configuration
    ///
    /// Loaded from INI file:
    /// ```text
    /// [obsidian]
    /// root_path_dir = ~/Documents/Obsidian
    /// ```
    obsidian_root_path_dir: OnceCell<PathBuf>,

    /// Subdirectory path for commit diary entries.
    ///
    /// Relative path under [`obsidian_root_path_dir`](Self::obsidian_root_path_dir)
    /// where commit entries are organized.
    ///
    /// # Examples
    ///
    /// - `Diaries/Commits`
    /// - `Journal/Git`
    ///
    /// # Full Path Construction
    ///
    /// Combined with root and date template:
    /// ```text
    /// {root_path_dir}/{commit_path}/{date_template}
    /// /home/user/Obsidian/Diaries/Commits/2025/01-January/2025-01-14.md
    /// ```
    ///
    /// # Configuration
    ///
    /// Loaded from INI file:
    /// ```text
    /// [obsidian]
    /// commit_path = Diaries/Commits
    /// ```
    obsidian_commit_path: OnceCell<PathBuf>,

    /// Chrono format string for date-based file paths.
    ///
    /// Controls the directory structure and filename for diary entries.
    /// Uses Chrono format specifiers to create date-organized paths.
    ///
    /// # Format Specifiers
    ///
    /// - `%Y` - Year (e.g., `2025`)
    /// - `%m` - Month number (e.g., `01`)
    /// - `%B` - Full month name (e.g., `January`)
    /// - `%F` - ISO 8601 date (e.g., `2025-01-14`)
    /// - `%d` - Day of month (e.g., `14`)
    ///
    /// # Examples
    ///
    /// ```text
    /// Format: %Y/%m-%B/%F.md
    /// Result: 2025/01-January/2025-01-14.md
    ///
    /// Format: %Y/week-%W/%F.md
    /// Result: 2025/week-02/2025-01-14.md
    /// ```
    ///
    /// # Configuration
    ///
    /// Loaded from INI file:
    /// ```text
    /// [templates]
    /// commit_date_path = %Y/%m-%B/%F.md
    /// ```
    template_commit_date_path: OnceCell<String>,

    /// Chrono format string for datetime display in diary entries.
    ///
    /// Controls how commit timestamps appear in the diary table's TIME column.
    ///
    /// # Format Specifiers
    ///
    /// - `%Y` - Year (e.g., `2025`)
    /// - `%m` - Month (e.g., `01`)
    /// - `%d` - Day (e.g., `14`)
    /// - `%H` - Hour, 24-hour (e.g., `14`)
    /// - `%M` - Minute (e.g., `30`)
    /// - `%S` - Second (e.g., `45`)
    /// - `%T` - Time in HH:MM:SS format
    ///
    /// # Examples
    ///
    /// ```text
    /// Format: %Y-%m-%d %H:%M:%S
    /// Result: 2025-01-14 14:30:45
    ///
    /// Format: %H:%M:%S
    /// Result: 14:30:45
    /// ```
    ///
    /// # Configuration
    ///
    /// Loaded from INI file:
    /// ```text
    /// [templates]
    /// commit_datetime = %Y-%m-%d %H:%M:%S
    /// ```
    template_commit_datetime: OnceCell<String>,

    /// Repository names to exclude from commit capture.
    ///
    /// When the current repository's working-directory name matches an entry in
    /// this list, the post-commit run skips cleanly and writes nothing to the
    /// diary. Populated from the optional `[exclude]` section; empty when that
    /// section is absent.
    ///
    /// # Configuration
    ///
    /// Loaded from the INI file (comma-separated, optional):
    /// ```text
    /// [exclude]
    /// repos = claude-src, some-other-repo
    /// ```
    excluded_repos: OnceCell<Vec<String>>,
}

impl GlobalVars {
    /// Creates a new uninitialized `GlobalVars` instance.
    ///
    /// This constructor initializes all fields as empty `OnceCell` values.
    /// Use [`set_all()`](Self::set_all) to load configuration from the INI file.
    ///
    /// # Thread Safety
    ///
    /// `GlobalVars` uses `OnceCell` for thread-safe, lazy initialization.
    /// Configuration values are set once and cannot be changed afterward.
    ///
    /// # Returns
    ///
    /// A new `GlobalVars` instance with all fields uninitialized
    ///
    /// # Fields
    ///
    /// - `config` - The parsed INI configuration file
    /// - `obsidian_root_path_dir` - Root directory of Obsidian vault
    /// - `obsidian_commit_path` - Subdirectory path for commit entries
    /// - `template_commit_date_path` - Chrono format for date-based directory structure
    /// - `template_commit_datetime` - Chrono format for datetime strings
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use rusty_commit_saver::config::GlobalVars;
    ///
    /// // Create new instance
    /// let global_vars = GlobalVars::new();
    ///
    /// // Now call set_all() to initialize from config file
    /// // global_vars.set_all();
    /// ```
    #[must_use]
    pub fn new() -> Self {
        info!("[GlobalVars::new()] Creating new GlobalVars with OnceCell default values.");
        GlobalVars {
            config: OnceCell::new(),
            config_path: OnceCell::new(),

            obsidian_root_path_dir: OnceCell::new(),
            obsidian_commit_path: OnceCell::new(),

            template_commit_date_path: OnceCell::new(),
            template_commit_datetime: OnceCell::new(),

            excluded_repos: OnceCell::new(),
        }
    }

    /// Loads and initializes all configuration from the INI file.
    ///
    /// This is the main entry point for configuration setup. It:
    /// 1. Reads the INI configuration file from disk (or CLI argument)
    /// 2. Parses it into the `config` field
    /// 3. Extracts and initializes all Obsidian and template variables
    ///
    /// Configuration is loaded from (in order of preference):
    /// - `--config-ini <PATH>` CLI argument
    /// - Default: `~/.config/rusty-commit-saver/rusty-commit-saver.ini`
    ///
    /// # Panics
    ///
    /// Panics if:
    /// - Configuration file doesn't exist
    /// - Configuration file cannot be read
    /// - Configuration file has invalid INI format
    /// - Required sections or keys are missing
    /// - Section count is not exactly 2 (obsidian + templates)
    ///
    /// # Returns
    ///
    /// Returns `self` for method chaining
    ///
    /// # Required INI Structure
    ///
    /// ```text
    /// [obsidian]
    /// root_path_dir = ~/Documents/Obsidian
    /// commit_path = Diaries/Commits
    ///
    /// [templates]
    /// commit_date_path = %Y/%m-%B/%F.md
    /// commit_datetime = %Y-%m-%d %H:%M:%S
    /// ```
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use rusty_commit_saver::config::GlobalVars;
    ///
    /// let global_vars = GlobalVars::new();
    /// global_vars.set_all(); // Reads from default or CLI config
    ///
    /// // Now all getters will return values
    /// let root_path = global_vars.get_obsidian_root_path_dir();
    /// let commit_path = global_vars.get_obsidian_commit_path();
    /// ```
    pub fn set_all(&self) -> &Self {
        info!("[GlobalVars::set_all()] Setting all variables for GlobalVars");
        let config_path = get_or_default_config_ini_path();
        let config = get_ini_file_at(&config_path);

        info!("[GlobalVars::set_all()]: Setting Config Ini file.");
        self.config_path
            .set(config_path)
            .expect("Couldn't set config_path in GlobalVars");
        self.config
            .set(config)
            .expect("Coulnd't set config in GlobalVars");

        info!("[GlobalVars::set_all()]: Setting Obsidian variables from file.");
        self.set_obsidian_vars();

        self
    }

    /// Returns the root directory of the Obsidian vault.
    ///
    /// This is the base directory where all Obsidian vault files are stored.
    /// All diary entries are created under this directory according to the
    /// configured subdirectory structure.
    ///
    /// # Panics
    ///
    /// Panics if called before [`set_all()`](Self::set_all) has been invoked
    ///
    /// # Returns
    ///
    /// A `PathBuf` representing the Obsidian vault root directory
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use rusty_commit_saver::config::GlobalVars;
    ///
    /// let global_vars = GlobalVars::new();
    /// global_vars.set_all();
    ///
    /// let root = global_vars.get_obsidian_root_path_dir();
    /// println!("Obsidian vault root: {}", root.display());
    /// // Output: Obsidian vault root: /home/user/Documents/Obsidian
    /// ```
    ///
    /// # Configuration Source
    ///
    /// Read from INI file:
    /// ```text
    /// [obsidian]
    /// root_path_dir = ~/Documents/Obsidian
    /// ```
    pub fn get_obsidian_root_path_dir(&self) -> PathBuf {
        info!("[GlobalVars::get_obsidian_root_path_dir()]: Getting obsidian_root_path_dir.");
        self.obsidian_root_path_dir
            .get()
            .expect("Could not get obsidian_root_path_dir")
            .clone()
    }

    /// Returns the subdirectory path where commits are stored.
    ///
    /// This is a relative path under [`get_obsidian_root_path_dir()`](Self::get_obsidian_root_path_dir)
    /// where commit diary entries will be organized. The full path is constructed by
    /// combining this with the Obsidian root and the date-based directory structure.
    ///
    /// # Panics
    ///
    /// Panics if called before [`set_all()`](Self::set_all) has been invoked
    ///
    /// # Returns
    ///
    /// A `PathBuf` representing the commits subdirectory (relative path)
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use rusty_commit_saver::config::GlobalVars;
    ///
    /// let global_vars = GlobalVars::new();
    /// global_vars.set_all();
    ///
    /// let commit_path = global_vars.get_obsidian_commit_path();
    /// println!("Commit subdirectory: {}", commit_path.display());
    /// // Output: Commit subdirectory: Diaries/Commits
    ///
    /// // Full path would be constructed as:
    /// // /home/user/Documents/Obsidian/Diaries/Commits/2025/01-January/2025-01-14.md
    /// ```
    ///
    /// # Configuration Source
    ///
    /// Read from INI file:
    /// ```text
    /// [obsidian]
    /// commit_path = Diaries/Commits
    /// ```
    pub fn get_obsidian_commit_path(&self) -> PathBuf {
        info!("[GlobalVars::get_obsidian_commit_path()]: Getting obsidian_commit_path.");
        self.obsidian_commit_path
            .get()
            .expect("Could not get obsidian_commit_path")
            .clone()
    }

    /// Returns the Chrono format string for diary file date hierarchies.
    ///
    /// This format string is used to create the directory structure and filename
    /// for diary entries based on the commit timestamp. It controls how commits
    /// are organized by date.
    ///
    /// # Chrono Format Specifiers
    ///
    /// - `%Y` - Full year (e.g., `2025`)
    /// - `%m` - Month as zero-padded number (e.g., `01`)
    /// - `%B` - Full month name (e.g., `January`)
    /// - `%b` - Abbreviated month (e.g., `Jan`)
    /// - `%d` - Day of month, zero-padded (e.g., `14`)
    /// - `%F` - ISO 8601 date (equivalent to `%Y-%m-%d`, e.g., `2025-01-14`)
    /// - `%H` - Hour in 24-hour format (e.g., `14`)
    /// - `%M` - Minute (e.g., `30`)
    /// - `%S` - Second (e.g., `45`)
    ///
    /// # Panics
    ///
    /// Panics if called before [`set_all()`](Self::set_all) has been invoked
    ///
    /// # Returns
    ///
    /// A `String` containing the Chrono format specifiers
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use rusty_commit_saver::config::GlobalVars;
    ///
    /// let global_vars = GlobalVars::new();
    /// global_vars.set_all();
    ///
    /// let date_template = global_vars.get_template_commit_date_path();
    /// println!("Date format: {}", date_template);
    /// // Output: Date format: %Y/%m-%B/%F.md
    ///
    /// // This creates paths like:
    /// // /home/user/Obsidian/Diaries/Commits/2025/01-January/2025-01-14.md
    /// ```
    ///
    /// # Configuration Source
    ///
    /// Read from INI file:
    /// ```text
    /// [templates]
    /// commit_date_path = %Y/%m-%B/%F.md
    /// ```
    pub fn get_template_commit_date_path(&self) -> String {
        info!("[GlobalVars::get_template_commit_date_path()]: Getting template_commit_date_path.");
        self.template_commit_date_path
            .get()
            .expect("Could not get template_commit_date_path")
            .clone()
    }

    /// Returns the Chrono format string for commit timestamps in diary entries.
    ///
    /// This format string is used to display the commit time in the diary table.
    /// It controls how timestamps appear in the commit entry rows.
    ///
    /// # Chrono Format Specifiers
    ///
    /// - `%Y` - Full year (e.g., `2025`)
    /// - `%m` - Month as zero-padded number (e.g., `01`)
    /// - `%B` - Full month name (e.g., `January`)
    /// - `%d` - Day of month, zero-padded (e.g., `14`)
    /// - `%H` - Hour in 24-hour format (e.g., `14`)
    /// - `%M` - Minute, zero-padded (e.g., `30`)
    /// - `%S` - Second, zero-padded (e.g., `45`)
    /// - `%T` - Time in HH:MM:SS format (equivalent to `%H:%M:%S`)
    ///
    /// # Panics
    ///
    /// Panics if called before [`set_all()`](Self::set_all) has been invoked
    ///
    /// # Returns
    ///
    /// A `String` containing the Chrono format specifiers for datetime
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use rusty_commit_saver::config::GlobalVars;
    ///
    /// let global_vars = GlobalVars::new();
    /// global_vars.set_all();
    ///
    /// let datetime_template = global_vars.get_template_commit_datetime();
    /// println!("Datetime format: {}", datetime_template);
    /// // Output: Datetime format: %Y-%m-%d %H:%M:%S
    ///
    /// // This renders timestamps like:
    /// // 2025-01-14 14:30:45
    /// ```
    ///
    /// # Diary Table Usage
    ///
    /// In the diary table, this format appears in the TIME column:
    /// ```text
    /// | FOLDER | TIME | COMMIT MESSAGE | REPOSITORY URL | BRANCH | COMMIT HASH |
    /// |--------|------|----------------|----------------|--------|-------------|
    /// | /work/project | 14:30:45 | feat: add feature | https://github.com/... | main | abc123... |
    /// ```
    ///
    /// # Configuration Source
    ///
    /// Read from INI file:
    /// ```text
    /// [templates]
    /// commit_datetime = %Y-%m-%d %H:%M:%S
    /// ```
    pub fn get_template_commit_datetime(&self) -> String {
        info!("[GlobalVars::get_template_commit_datetime()]: Getting template_commit_datetime.");
        self.template_commit_datetime
            .get()
            .expect("Could not get template_commit_datetime")
            .clone()
    }

    /// Retrieves a clone of the parsed INI configuration.
    ///
    /// This is a private helper method that returns a copy of the configuration
    /// object. Used internally by other helper methods to access sections and keys.
    ///
    /// # Panics
    ///
    /// Panics if called before [`set_all()`](Self::set_all) has initialized the config.
    ///
    /// # Returns
    ///
    /// A cloned `Ini` configuration object
    fn get_config(&self) -> Ini {
        info!("[GlobalVars::get_config()] Getting config");
        self.config
            .get()
            .expect("Could not get Config. Config not initialized")
            .clone()
    }

    fn get_key_from_section_from_ini(&self, section: &str, key: &str) -> Option<String> {
        info!(
            "[GlobalVars::get_key_from_section_from_ini()] Getting key: {key:} from section: {section:}."
        );
        self.config
            .get()
            .expect("Retrieving the config for commit_path")
            .get(section, key)
    }

    /// The sections this binary understands. Adding a section to
    /// `set_obsidian_vars`' dispatch means adding it here too, or the section
    /// gets applied *and* reported as unrecognised.
    const KNOWN_SECTIONS: [&'static str; 3] = ["obsidian", "templates", "exclude"];

    /// The keys each known section understands. Adding a key to a setter means
    /// adding it here too, or the key gets applied *and* reported as
    /// unrecognised.
    const KNOWN_KEYS: [(&'static str, &'static [&'static str]); 3] = [
        ("obsidian", &["root_path_dir", "commit_path"]),
        ("templates", &["commit_date_path", "commit_datetime"]),
        ("exclude", &["repos"]),
    ];

    /// Lists the keys this binary does not understand, as sorted
    /// `[section] key` labels.
    ///
    /// Only keys in a *known* section are listed: an unrecognised section is
    /// already reported whole by [`get_sections_from_config()`](Self::get_sections_from_config),
    /// and listing its keys as well would charge one mistake twice.
    ///
    /// Sorted because the parser holds keys in a hash map, whose iteration
    /// order would otherwise vary from run to run.
    fn unrecognised_keys(&self) -> Vec<String> {
        let mut unknown = Vec::new();

        for (section, _) in Self::KNOWN_KEYS {
            for key in self.unrecognised_keys_in(section) {
                unknown.push(format!("[{section}] {key}"));
            }
        }

        unknown.sort();
        unknown
    }

    /// The unrecognised keys of one known section, sorted, without the
    /// `[section]` prefix. An unknown section has none by definition: the
    /// binary has no idea what it should contain.
    fn unrecognised_keys_in(&self, section: &str) -> Vec<String> {
        let Some((_, known)) = Self::KNOWN_KEYS.iter().find(|(name, _)| *name == section) else {
            return Vec::new();
        };

        let config = self.get_config();
        let Some(present) = config.get_map_ref().get(section) else {
            return Vec::new();
        };

        let mut unknown: Vec<String> = present
            .keys()
            .filter(|key| !known.contains(&key.as_str()))
            .cloned()
            .collect();

        unknown.sort();
        unknown
    }

    /// Names the configuration file for an error message.
    ///
    /// Falls back to a plain description rather than a guessed path when the
    /// config was handed in directly instead of read from disk.
    fn config_file_label(&self) -> String {
        self.config_path
            .get()
            .cloned()
            .unwrap_or_else(|| "the rusty-commit-saver config".to_string())
    }

    /// Reads a key the binary cannot work without.
    ///
    /// Fatal by design. Without it there is no destination to write to, and a
    /// hook that quietly journals nothing is indistinguishable from a quiet
    /// day - the diary would stop for weeks before anyone noticed. What the
    /// fatal path owes the user is a message they can act on: it names the
    /// resolved config file, the `[section] key`, and any unrecognised key in
    /// that same section, because a misspelt `commit_paths` is the usual
    /// reason `commit_path` is missing and naming both at once saves reading
    /// the source.
    ///
    /// A present-but-blank value counts as missing: `commit_path =` used to
    /// satisfy the old presence check and silently journal into the vault
    /// root instead of the configured folder.
    ///
    /// # Panics
    ///
    /// Panics if the key is absent, or its value is empty or whitespace.
    fn require_key(&self, section: &str, key: &str) -> String {
        let value = self
            .get_key_from_section_from_ini(section, key)
            .filter(|value| !value.trim().is_empty());

        if let Some(value) = value {
            return value;
        }

        let file = self.config_file_label();
        let typos = self.unrecognised_keys_in(section);
        let hint = if typos.is_empty() {
            String::new()
        } else {
            format!("; unrecognised in [{section}]: {}", typos.join(", "))
        };

        error!(
            "[GlobalVars::require_key()] {file}: missing required key '{key}' in section [{section}]{hint}"
        );
        panic!(
            "rusty-commit-saver: {file}: missing required key '{key}' in section [{section}]{hint}"
        )
    }

    /// Reads a required key whose value must be a `chrono` format string.
    ///
    /// A format `chrono` cannot render is config skew like any other, but it
    /// used to surface from deep inside the writer as `a formatting trait
    /// implementation returned an error when the underlying stream did not`,
    /// naming neither the file nor the key - and only after an empty diary
    /// file had already been created. Checking it where the rest of the config
    /// is checked keeps the message the same shape as every other config
    /// fault, and stops the run before it writes anything.
    ///
    /// # Panics
    ///
    /// Panics if the key is missing (see [`require_key()`](Self::require_key)),
    /// or if `chrono` cannot render its value.
    fn require_time_format(&self, section: &str, key: &str) -> String {
        let format = self.require_key(section, key);

        if is_renderable_time_format(&format) {
            return format;
        }

        let file = self.config_file_label();
        error!(
            "[GlobalVars::require_time_format()] {file}: key '{key}' in section [{section}] is not a format chrono can render: '{format}'"
        );
        panic!(
            "rusty-commit-saver: {file}: key '{key}' in section [{section}] is not a format chrono can render: '{format}'"
        )
    }

    /// Reports every unrecognised key, then carries on.
    ///
    /// An unknown key is never fatal, for the reason an unknown section is not:
    /// one INI file is shared by every checkout on the machine, so a key
    /// written for a newer release must not brick a binary that predates it.
    /// Reporting it is what a silent skip failed to do - a misspelt
    /// `commit_datetimes` used to apply nothing and say nothing.
    fn report_unrecognised_keys(&self) {
        let unknown = self.unrecognised_keys();
        if unknown.is_empty() {
            return;
        }

        let list = unknown.join(", ");
        warn!(
            "[GlobalVars::report_unrecognised_keys()] ignoring unrecognised config keys {list}; this binary may be older than the config"
        );
        // Also on stderr, for the same reason the section warning is: the git
        // hook runs without RUST_LOG, where env_logger caps the level at Error
        // and would swallow the warning entirely.
        eprintln!(
            "rusty-commit-saver: ignoring unrecognised config keys {list}; this binary may be older than the config"
        );
    }

    fn get_sections_from_config(&self) -> Vec<String> {
        info!("[GlobalVars::get_sections_from_config()] Getting sections from config");
        let sections = self.get_config().sections();

        info!("[GlobalVars::get_sections_from_config()] Checking validity of config sections.");
        let has_required = ["obsidian", "templates"]
            .iter()
            .all(|required| sections.iter().any(|s| s == required));

        if !has_required {
            error!(
                // LCOV_EXCL_START
                "[GlobalVars::get_sections_from_config()] These are the sections found: {sections:?}"
            ); // LCOV_EXCL_STOP
            panic!(
                "[GlobalVars::get_sections_from_config()] config must have [obsidian] and [templates]."
            )
        }

        // An unrecognised section is ignored, never fatal: the config is shared
        // by every checkout on the machine, so a section added for a newer
        // release must not brick a binary that predates it. Adding [exclude]
        // is exactly what killed every checkout older than 4.17.0.
        let unknown: Vec<&String> = sections
            .iter()
            .filter(|s| !Self::KNOWN_SECTIONS.contains(&s.as_str()))
            .collect();
        if !unknown.is_empty() {
            warn!(
                "[GlobalVars::get_sections_from_config()] ignoring unrecognised config sections {unknown:?}; this binary may be older than the config"
            );
            // Also on stderr: the git hook runs without RUST_LOG, where
            // env_logger caps the level at Error and would swallow the warning
            // entirely. A misspelt section must never be silent - that is how
            // an [excludes] typo would quietly journal the repos you excluded.
            eprintln!(
                "rusty-commit-saver: ignoring unrecognised config sections {unknown:?}; this binary may be older than the config"
            );
        }

        sections
    }

    /// Loads all configuration variables from the "obsidian" and "templates" sections.
    ///
    /// This method iterates through all sections returned by `get_sections_from_config`.
    /// For each recognized section, it initializes the corresponding runtime variables
    /// by calling their dedicated setters:
    ///
    /// - For the **"obsidian"** section: calls `set_obsidian_root_path_dir` and `set_obsidian_commit_path`.
    /// - For the **"templates"** section: calls `set_templates_commit_date_path` and `set_templates_datetime`.
    /// - For the **"exclude"** section: calls `set_excluded_repos`.
    ///
    /// Any other section is skipped. Keys the binary does not understand are
    /// reported on stderr and skipped too.
    ///
    /// # Panics
    ///
    /// Panics if the INI file is missing `[obsidian]` or `[templates]`; both are
    /// required. An unrecognised section or key is not fatal.
    ///
    /// # Logging
    ///
    /// - Logs an info message when applying each section.
    /// - Logs an error right before panicking on a missing required section.
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use rusty_commit_saver::config::GlobalVars;
    /// let mut config = configparser::ini::Ini::new();
    /// config.set("obsidian", "root_path_dir", Some("~/Obsidian".to_string()));
    /// config.set("obsidian", "commit_path", Some("Diary/Commits".to_string()));
    /// config.set("templates", "commit_date_path", Some("%Y-%m-%d.md".to_string()));
    /// config.set("templates", "commit_datetime", Some("%Y-%m-%d %H:%M:%S".to_string()));
    /// let global_vars = GlobalVars::new();
    /// global_vars.config.set(config).unwrap();
    /// global_vars.set_obsidian_vars();
    /// ```
    pub fn set_obsidian_vars(&self) {
        let sections = self.get_sections_from_config();
        self.report_unrecognised_keys();

        for section in sections {
            if section == "obsidian" {
                info!("[GlobalVars::set_obsidian_vars()] Setting 'obsidian' section variables.");
                self.set_obsidian_root_path_dir(&section);
                self.set_obsidian_commit_path(&section);
            } else if section == "templates" {
                info!("[GlobalVars::set_obsidian_vars()] Setting 'templates' section variables.");
                self.set_templates_commit_date_path(&section);
                self.set_templates_datetime(&section);
            } else if section == "exclude" {
                info!("[GlobalVars::set_obsidian_vars()] Setting 'exclude' section variables.");
                self.set_excluded_repos(&section);
            }
            // No `else`: an unrecognised section is deliberately skipped here.
            // `get_sections_from_config()` returns it after warning about it,
            // because a config written for a newer release must not be fatal.
        }
    }

    /// Sets the `template_commit_datetime` field from the `[templates]` section.
    ///
    /// Reads the `commit_datetime` key from the INI file and stores it in the
    /// `template_commit_datetime` `OnceCell`.
    ///
    /// # Arguments
    ///
    /// * `section` - Should be `"templates"` (validated by caller)
    ///
    /// # Panics
    ///
    /// Panics if:
    /// - The `commit_datetime` key is missing, or its value is blank, or it is
    ///   not a format `chrono` can render
    /// - The `OnceCell` has already been set (called multiple times)
    ///
    /// # Expected INI Key
    ///
    /// ```text
    /// [templates]
    /// commit_datetime = %Y-%m-%d %H:%M:%S
    /// ```
    fn set_templates_datetime(&self, section: &str) {
        info!("[GlobalVars::set_templates_datetime()]: Setting the templates_datetime.");
        let key = self.require_time_format(section, "commit_datetime");

        self.template_commit_datetime
            .set(key)
            .expect("Could not set the template_commit_datetime GlobalVars");
    }

    /// Sets the `excluded_repos` field from the optional `[exclude]` section.
    ///
    /// Reads the `repos` key, parses it as a comma-separated list of repository
    /// names, and stores the result. A missing `repos` key yields an empty list.
    ///
    /// # Arguments
    ///
    /// * `section` - Should be `"exclude"` (validated by caller)
    ///
    /// # Expected INI Key
    ///
    /// ```text
    /// [exclude]
    /// repos = claude-src, some-other-repo
    /// ```
    fn set_excluded_repos(&self, section: &str) {
        info!("[GlobalVars::set_excluded_repos()]: Setting the excluded repos list.");
        let raw = self
            .get_key_from_section_from_ini(section, "repos")
            .unwrap_or_default();

        self.excluded_repos
            .set(parse_exclude_repos(&raw))
            .expect("Could not set the excluded_repos in GlobalVars");
    }

    /// Returns the list of repository names excluded from commit capture.
    ///
    /// Reads the value populated from the optional `[exclude]` section. When that
    /// section (or its `repos` key) is absent, returns an empty list — meaning no
    /// repository is excluded.
    ///
    /// # Returns
    ///
    /// A `Vec<String>` of excluded repository names (working-directory names).
    ///
    /// # Configuration Source
    ///
    /// Read from the INI file:
    /// ```text
    /// [exclude]
    /// repos = claude-src
    /// ```
    #[must_use]
    pub fn get_excluded_repos(&self) -> Vec<String> {
        info!("[GlobalVars::get_excluded_repos()]: Getting excluded repos list.");
        self.excluded_repos.get().cloned().unwrap_or_default()
    }

    /// Sets the `template_commit_date_path` field from the `[templates]` section.
    ///
    /// Reads the `commit_date_path` key from the INI file and stores it in the
    /// `template_commit_date_path` `OnceCell`.
    ///
    /// # Arguments
    ///
    /// * `section` - Should be `"templates"` (validated by caller)
    ///
    /// # Panics
    ///
    /// Panics if:
    /// - The `commit_date_path` key is missing, or its value is blank, or it is
    ///   not a format `chrono` can render
    /// - The `OnceCell` has already been set (called multiple times)
    ///
    /// # Expected INI Key
    ///
    /// ```text
    /// [templates]
    /// commit_date_path = %Y/%m-%B/%F.md
    /// ```
    fn set_templates_commit_date_path(&self, section: &str) {
        info!(
            "[GlobalVars::set_templates_commit_date_path()]: Setting the template_commit_date_path."
        );
        let key = self.require_time_format(section, "commit_date_path");

        self.template_commit_date_path
            .set(key)
            .expect("Could not set the template_commit_date_path in GlobalVars");
    }

    /// Sets the `obsidian_commit_path` field from the `[obsidian]` section.
    ///
    /// Reads the `commit_path` key, expands tilde (`~`) to the home directory
    /// if present, splits the path by `/`, and constructs a `PathBuf`.
    ///
    /// # Arguments
    ///
    /// * `section` - Should be `"obsidian"` (validated by caller)
    ///
    /// # Tilde Expansion
    ///
    /// - `~/Diaries/Commits` → `/home/user/Diaries/Commits`
    /// - `/absolute/path` → `/absolute/path` (unchanged)
    ///
    /// # Panics
    ///
    /// Panics if:
    /// - The `commit_path` key is missing, or its value is blank
    /// - Home directory cannot be determined (when `~` is used)
    /// - The `OnceCell` has already been set
    ///
    /// # Expected INI Key
    ///
    /// ```text
    /// [obsidian]
    /// commit_path = ~/Documents/Obsidian/Diaries/Commits
    /// ```
    fn set_obsidian_commit_path(&self, section: &str) {
        let string_path = self.require_key(section, "commit_path");

        let fixed_home = if string_path.contains('~') {
            info!("[GlobalVars::set_obsidian_commit_path()]: Path does contain: '~'.");
            set_proper_home_dir(&string_path)
        } else {
            info!("[GlobalVars::set_obsidian_commit_path()]: Path does NOT contain: '~'.");
            string_path
        };

        let vec_str = fixed_home.split('/');

        let mut path = PathBuf::new();

        info!(
            "[GlobalVars::set_obsidian_commit_path()]: Pushing strings folders to create PathBuf."
        );
        for s in vec_str {
            path.push(s);
        }
        self.obsidian_commit_path
            .set(path)
            .expect("Could not set the path for obsidian_root_path_dir");
    }

    /// Sets the `obsidian_root_path_dir` field from the `[obsidian]` section.
    ///
    /// Reads the `root_path_dir` key, expands tilde (`~`) to the home directory
    /// if present, prepends `/` for absolute paths, and constructs a `PathBuf`.
    ///
    /// # Arguments
    ///
    /// * `section` - Should be `"obsidian"` (validated by caller)
    ///
    /// # Path Construction
    ///
    /// - Starts with `/` to ensure absolute path
    /// - Expands `~` to home directory
    /// - Splits by `/` and constructs `PathBuf`
    ///
    /// # Tilde Expansion Examples
    ///
    /// - `~/Documents/Obsidian` → `/home/user/Documents/Obsidian`
    /// - `/absolute/path` → `/absolute/path`
    ///
    /// # Panics
    ///
    /// Panics if:
    /// - The `root_path_dir` key is missing, or its value is blank
    /// - Home directory cannot be determined (when `~` is used)
    /// - The `OnceCell` has already been set
    ///
    /// # Expected INI Key
    ///
    /// ```text
    /// [obsidian]
    /// root_path_dir = ~/Documents/Obsidian
    /// ```
    fn set_obsidian_root_path_dir(&self, section: &str) {
        let string_path = self.require_key(section, "root_path_dir");

        let fixed_home = if string_path.contains('~') {
            info!("[GlobalVars::set_obsidian_root_path_dir()]: Does contain ~");
            set_proper_home_dir(&string_path)
        } else {
            info!("[GlobalVars::set_obsidian_root_path_dir()]: Does NOT contain ~");
            string_path
        };

        let vec_str = fixed_home.split('/');
        let mut path = PathBuf::new();

        info!(
            "[GlobalVars::set_obsidian_root_path_dir()]: Pushing '/' to PathBuf for proper path."
        );
        path.push("/");

        info!(
            "[GlobalVars::set_obsidian_root_path_dir()]: Pushing strings folders to create PathBuf."
        );
        for s in vec_str {
            path.push(s);
        }

        self.obsidian_root_path_dir
            .set(path)
            .expect("Could not set the path for obsidian_root_path_dir");
    }
}

/// Command-line argument parser for configuration file path.
///
/// This struct uses `clap` to parse CLI arguments and provide configuration
/// options for the application. Currently supports specifying a custom INI
/// configuration file path.
///
/// # CLI Arguments
///
/// - `--config-ini <PATH>` - Optional path to a custom configuration file
///
/// # Examples
///
/// ```text
/// # Use default config (~/.config/rusty-commit-saver/rusty-commit-saver.ini)
/// rusty-commit-saver
///
/// # Use custom config file
/// rusty-commit-saver --config-ini /path/to/custom.ini
/// ```
///
/// # See Also
///
/// - [`retrieve_config_file_path()`] - Gets the config path from CLI or default
/// - [`get_ini_file()`] - Loads the INI file from the resolved path
#[derive(Parser, Debug, Clone)]
#[command(version, about, long_about = None)]
#[command(propagate_version = true)]
#[command(about = "Rusty Commit Saver config", long_about = None)]
pub struct UserInput {
    /// Path to a custom INI configuration file.
    ///
    /// If not provided, the default configuration file is used:
    /// `~/.config/rusty-commit-saver/rusty-commit-saver.ini`
    ///
    /// # CLI Usage
    ///
    /// ```text
    /// rusty-commit-saver --config-ini /custom/path/config.ini
    /// ```
    ///
    /// # Examples
    ///
    /// Valid paths:
    /// - `~/my-configs/commit-saver.ini`
    /// - `/etc/rusty-commit-saver/config.ini`
    /// - `./local-config.ini`
    #[arg(short, long)]
    pub config_ini: Option<String>,

    /// Reconcile these repositories against their day notes, instead of
    /// journalling the commit that just happened.
    ///
    /// Repeatable. Each value is a path inside a git repository; the
    /// repository is discovered from it the same way the hook discovers its
    /// own, and the history walked is what that checkout's `HEAD` can reach.
    /// Given at least once, the binary does not journal the repository it was
    /// started in and does not behave as a hook at all.
    ///
    /// # CLI Usage
    ///
    /// ```text
    /// rusty-commit-saver --reconcile ~/src/one --reconcile ~/src/two
    /// ```
    #[arg(long, value_name = "PATH")]
    pub reconcile: Vec<PathBuf>,

    /// Ignore commits older than this date when reconciling, as `YYYY-MM-DD`.
    ///
    /// Without it every commit reachable from `HEAD` is considered, which is
    /// what a first backfill wants and what a nightly pass does not.
    ///
    /// # CLI Usage
    ///
    /// ```text
    /// rusty-commit-saver --reconcile ~/src/one --since 2026-08-01
    /// ```
    #[arg(long, value_name = "DATE")]
    pub since: Option<String>,
}

/// Parses a `--since` value into the instant commits are compared against.
///
/// A date rather than a timestamp, because the journal is organised by day and
/// an operator writing this into a timer unit thinks in days. Midnight UTC is
/// the floor, matching the UTC the rest of the tool records commits in.
///
/// # Errors
///
/// Returns a message naming the value and the expected shape when the date
/// cannot be parsed.
pub fn parse_since(value: &str) -> Result<chrono::DateTime<chrono::Utc>, String> {
    let day = chrono::NaiveDate::parse_from_str(value.trim(), "%Y-%m-%d")
        .map_err(|_| format!("--since expects a date as YYYY-MM-DD, not '{value}'"))?;

    day.and_hms_opt(0, 0, 0)
        .map(|naive| naive.and_utc())
        .ok_or_else(|| format!("--since could not be read as an instant: '{value}'"))
}

/// Retrieves the configuration file path from CLI arguments or returns the default.
///
/// This function parses command-line arguments and returns the path to the INI configuration file.
/// If no `--config-ini` argument is provided, returns the default path.
///
/// # Default Path
///
/// `~/.config/rusty-commit-saver/rusty-commit-saver.ini`
///
/// # Returns
///
/// A `String` containing the absolute path to the configuration file.
///
/// # CLI Usage
///
/// ```text
/// // Use default config
/// $ rusty-commit-saver
/// // Returns: ~/.config/rusty-commit-saver/rusty-commit-saver.ini
///
/// // Use custom config
/// $ rusty-commit-saver --config-ini /custom/path/config.ini
/// // Returns: /custom/path/config.ini
/// ```
///
/// # Panics
///
/// Panics if:
/// - The resolved configuration file does not exist on the filesystem
/// - The file cannot be read (permission denied, IO error)
/// - The file path cannot be converted to a valid string
///
/// # Examples
///
/// ```ignore
/// use rusty_commit_saver::config::retrieve_config_file_path;
///
/// let config_path = retrieve_config_file_path();
/// println!("Using config: {}", config_path);
/// ```
///
/// # See Also
///
/// - [`get_or_default_config_ini_path`] - Helper that implements the CLI parsing logic
/// - [`get_default_ini_path`] - Constructs the default configuration path
#[must_use]
pub fn retrieve_config_file_path() -> String {
    info!(
        "[UserInput::retrieve_config_file_path()]: retrieving the string path from CLI or default"
    );
    read_config_file(&get_or_default_config_ini_path())
}

/// Reads the configuration file at `config_path` and returns its contents.
///
/// Split from [`retrieve_config_file_path()`] so a caller that needs the path
/// itself - to name the file in an error - resolves it once and passes it in,
/// rather than resolving it a second time behind the caller's back.
///
/// # Panics
///
/// Panics if the file does not exist, or cannot be read.
#[must_use]
fn read_config_file(config_path: &str) -> String {
    if Path::new(config_path).exists() {
        info!("[UserInput::retrieve_config_file_path()]: config_path exists {config_path:}");
    } else {
        error!(
            "[UserInput::retrieve_config_file_path()]: config_path DOES NOT exists {config_path:}"
        );
        panic!(
            "[UserInput::retrieve_config_file_path()]: config_path DOES NOT exists {config_path:}"
        );
    }
    info!("[UserInput::retrieve_config_file_path()] retrieved config path: {config_path:}");
    fs::read_to_string(config_path)
        .unwrap_or_else(|_| panic!("Should have been able to read the file: {config_path:}"))
}

/// Returns the config path from CLI arguments or the default path.
///
/// Internal helper function that parses CLI arguments using `UserInput` and
/// returns either the provided `--config-ini` path or the default configuration
/// file location.
///
/// # Returns
///
/// - CLI path if `--config-ini` was provided
/// - Default path (`~/.config/rusty-commit-saver/rusty-commit-saver.ini`) otherwise
///
/// # Called By
///
/// This function is called internally by [`retrieve_config_file_path()`].
///
/// # See Also
///
/// - [`get_default_ini_path()`] - Constructs the default configuration path
#[must_use]
pub fn resolve_config_path(cli_arg: Option<String>, env_var: Option<String>) -> String {
    // Check env var first
    if let Some(env_path) = env_var {
        info!("[resolve_config_path]: Using config from env var.");
        return if env_path.contains('~') {
            set_proper_home_dir(&env_path)
        } else {
            env_path
        };
    }

    // Check CLI arg
    if let Some(cfg_str) = cli_arg {
        if cfg_str.contains('~') {
            info!("[resolve_config_path]: CLI path contains '~'.");
            set_proper_home_dir(&cfg_str)
        } else {
            info!("[resolve_config_path]: CLI path without '~'.");
            cfg_str
        }
    } else {
        info!("[resolve_config_path]: Using default path.");
        get_default_ini_path()
    }
}

#[must_use]
#[cfg_attr(coverage_nightly, coverage(off))]
pub fn get_or_default_config_ini_path() -> String {
    get_or_default_config_ini_path_with(std::env::var("RUSTY_COMMIT_SAVER_CONFIG").ok(), || {
        UserInput::parse().config_ini
    })
}

#[must_use]
fn get_or_default_config_ini_path_with<F>(env_var: Option<String>, cli_parser: F) -> String
where
    F: FnOnce() -> Option<String>,
{
    info!("[get_or_default_config_ini_path()]: Parsing CLI inputs.");

    let cli_arg = if env_var.is_some() {
        None // Skip parsing if env var is set
    } else {
        cli_parser()
    };

    let config_path = resolve_config_path(cli_arg, env_var);
    info!("[get_or_default_config_ini_path()]: Config path found: {config_path:}");
    config_path
}

/// Constructs the default configuration file path.
///
/// Builds the standard XDG configuration path for the application by combining
/// the user's home directory with the application-specific config directory.
///
/// # Returns
///
/// A `String` with the default INI file path:
/// `~/.config/rusty-commit-saver/rusty-commit-saver.ini`
///
/// # Directory Structure
///
/// ```text
/// ~/.config/
///   └── rusty-commit-saver/
///       └── rusty-commit-saver.ini
/// ```
///
/// # Panics
///
/// Panics if the user's home directory cannot be determined
/// (via the `dirs::home_dir()` function).
///
/// # Examples
///
/// ```ignore
/// // Internal usage
/// let default_path = get_default_ini_path();
/// // Returns: "/home/user/.config/rusty-commit-saver/rusty-commit-saver.ini"
/// ```
///
/// # See Also
///
/// - [`retrieve_config_file_path()`] - Public API for getting config path
#[must_use]
pub fn get_default_ini_path() -> String {
    info!("[get_default_ini_path()]: Getting default ini file.");
    let cfg_str = "~/.config/rusty-commit-saver/rusty-commit-saver.ini".to_string();
    set_proper_home_dir(&cfg_str)
}

/// Loads and parses the INI configuration file from disk.
///
/// Reads the configuration file (from CLI argument or default location),
/// parses its contents using [`parse_ini_content()`], and returns the
/// parsed `Ini` object.
///
/// # Returns
///
/// A parsed `Ini` configuration object
///
/// # Panics
///
/// Panics if:
/// - The configuration file doesn't exist at the resolved path
/// - The file cannot be read (permission denied, I/O error)
/// - The file content is not valid UTF-8
/// - The INI syntax is invalid (malformed sections or key-value pairs)
///
/// # File Resolution Order
///
/// 1. Check for `--config-ini <PATH>` CLI argument
/// 2. Fall back to `~/.config/rusty-commit-saver/rusty-commit-saver.ini`
///
/// # Expected INI Structure
///
/// ```text
/// [obsidian]
/// root_path_dir = ~/Documents/Obsidian
/// commit_path = Diaries/Commits
///
/// [templates]
/// commit_date_path = %Y/%m-%B/%F.md
/// commit_datetime = %Y-%m-%d %H:%M:%S
/// ```
///
/// # Called By
///
/// This function is called internally by [`GlobalVars::set_all()`].
///
/// # See Also
///
/// - [`retrieve_config_file_path()`] - Resolves the config file path
/// - [`parse_ini_content()`] - Parses INI text into `Ini` struct
#[must_use]
pub fn get_ini_file() -> Ini {
    get_ini_file_at(&get_or_default_config_ini_path())
}

/// Loads and parses the INI configuration file at `config_path`.
///
/// The path-taking half of [`get_ini_file()`], for a caller that has already
/// resolved the path and wants to keep it - [`GlobalVars::set_all()`] retains
/// it so a configuration error can name the file to edit.
///
/// # Panics
///
/// Panics under the same conditions as [`get_ini_file()`]: the file is
/// missing, unreadable, or not valid INI.
#[must_use]
pub fn get_ini_file_at(config_path: &str) -> Ini {
    info!("[get_ini_file()]: Retrieving the INI File");
    let content_ini = read_config_file(config_path);
    let mut config = Ini::new();
    config
        .read(content_ini)
        .expect("Could not read the INI file!");

    info!("[get_ini_file()]: This is the INI File:\n\n{config:?}");
    config
}

/// Expands the tilde (`~`) character to the user's home directory path.
///
/// Replaces the leading `~` in a path string with the absolute path to the
/// user's home directory. If no `~` is present, returns the string unchanged.
///
/// # Arguments
///
/// * `cfg_str` - A path string that may contain a leading `~`
///
/// # Returns
///
/// A `String` with `~` expanded to the full home directory path
///
/// # Panics
///
/// Panics if the user's home directory cannot be determined
/// (via the `dirs::home_dir()` function).
///
/// # Examples
///
/// ```ignore
/// // On Linux/macOS with home at /home/user
/// let expanded = set_proper_home_dir("~/Documents/Obsidian");
/// assert_eq!(expanded, "/home/user/Documents/Obsidian");
///
/// // Path without tilde is returned unchanged
/// let unchanged = set_proper_home_dir("/absolute/path");
/// assert_eq!(unchanged, "/absolute/path");
/// ```
///
/// # Platform Behavior
///
/// - **Linux/macOS**: Expands to `/home/username` or `/Users/username`
/// - **Windows**: Expands to `C:\Users\username`
///
/// # Used By
///
/// This function is called by:
/// - [`GlobalVars::set_obsidian_root_path_dir()`]
/// - [`GlobalVars::set_obsidian_commit_path()`]
fn set_proper_home_dir(cfg_str: &str) -> String {
    info!("[set_proper_home_dir()]: Changing the '~' to full home directory.");
    let home_dir = home_dir()
        .expect("Could not get home_dir")
        .into_os_string()
        .into_string()
        .expect("Could not convert home_dir from OsString to String");

    cfg_str.replace('~', &home_dir)
}

/// Whether `chrono` can render this format string.
///
/// `DateTime::format()` defers the work, and `to_string()` turns an invalid
/// specifier into a panic; writing into a `String` returns the error instead,
/// which is what makes the format checkable at all.
fn is_renderable_time_format(format: &str) -> bool {
    use std::fmt::Write;

    let probe = DateTime::from_timestamp(0, 0).expect("the epoch is a valid timestamp");
    let mut rendered = String::new();

    write!(rendered, "{}", probe.format(format)).is_ok()
}

/// Parses a comma-separated list of repository names into a clean vector.
///
/// Each entry is trimmed of surrounding whitespace and empty entries are
/// dropped, so trailing commas and stray spaces are tolerated.
///
/// # Arguments
///
/// * `raw` - The raw comma-separated value (e.g. `"claude-src, other-repo"`)
///
/// # Returns
///
/// A `Vec<String>` with one entry per non-empty, trimmed repository name.
///
/// # Examples
///
/// ```ignore
/// use rusty_commit_saver::config::parse_exclude_repos;
///
/// assert_eq!(parse_exclude_repos("claude-src, foo"), vec!["claude-src", "foo"]);
/// assert_eq!(parse_exclude_repos("  "), Vec::<String>::new());
/// ```
#[must_use]
pub fn parse_exclude_repos(raw: &str) -> Vec<String> {
    raw.split(',')
        .map(str::trim)
        .filter(|s| !s.is_empty())
        .map(String::from)
        .collect()
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod global_vars_tests {
    use super::*;
    use std::panic::{self, AssertUnwindSafe};

    #[test]
    fn test_global_vars_new() {
        let global_vars = GlobalVars::new();

        assert!(global_vars.config.get().is_none());
    }

    #[test]
    fn test_global_vars_default() {
        let global_vars = GlobalVars::default();

        assert!(global_vars.config.get().is_none());
    }

    #[test]
    fn test_get_sections_from_config_valid() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let sections = global_vars.get_sections_from_config();

        assert_eq!(sections.len(), 2);
        assert!(sections.contains(&"obsidian".to_string()));
        assert!(sections.contains(&"templates".to_string()));
    }

    #[test]
    fn test_get_sections_from_config_rejects_a_lone_unknown_section() {
        let mut config = Ini::new();
        config.set("only_one_section", "key", Some("value".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let result =
            panic::catch_unwind(AssertUnwindSafe(|| global_vars.get_sections_from_config()));

        assert!(
            result.is_err(),
            "Expected panic: the required sections are missing"
        );

        // Verify the panic message (panic! with string literal = &str)
        let panic_info = result.unwrap_err();
        let msg = panic_info
            .downcast_ref::<&str>()
            .expect("Panic message should be &str");
        assert!(
            msg.contains("must have [obsidian] and [templates]"),
            "Unexpected panic message: {msg}"
        );
    }

    #[test]
    fn test_get_sections_from_config_panics_with_zero_sections() {
        let config = Ini::new();

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let result =
            panic::catch_unwind(AssertUnwindSafe(|| global_vars.get_sections_from_config()));

        assert!(result.is_err(), "Expected panic for zero sections");
    }

    #[test]
    fn test_get_sections_from_config_keeps_an_extra_section() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set("templates", "commit_date_path", Some("%Y.md".to_string()));
        config.set("extra", "key", Some("value".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let result =
            panic::catch_unwind(AssertUnwindSafe(|| global_vars.get_sections_from_config()));

        assert!(
            result.is_ok(),
            "An unrecognised section must be ignored, not fatal"
        );
        assert_eq!(result.unwrap().len(), 3);
    }

    #[test]
    fn test_unrecognised_keys_names_a_typo_in_a_known_section() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set("obsidian", "commit_path", Some("commits".to_string()));
        config.set("templates", "commit_date_path", Some("%F.md".to_string()));
        // The rename/typo case: the real key is still there, so nothing breaks
        // - which is exactly why this used to pass unnoticed.
        config.set("templates", "commit_datetime", Some("%T".to_string()));
        config.set("templates", "commit_datetimes", Some("%T".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        assert_eq!(
            global_vars.unrecognised_keys(),
            vec!["[templates] commit_datetimes".to_string()],
            "an unknown key must be named, not swallowed"
        );
    }

    #[test]
    fn test_unrecognised_keys_is_empty_for_a_known_config() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set("obsidian", "commit_path", Some("commits".to_string()));
        config.set("templates", "commit_date_path", Some("%F.md".to_string()));
        config.set("templates", "commit_datetime", Some("%T".to_string()));
        config.set("exclude", "repos", Some("claude-src".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        assert!(
            global_vars.unrecognised_keys().is_empty(),
            "a config this binary fully understands must warn about nothing"
        );
    }

    #[test]
    fn test_unrecognised_keys_leaves_an_unknown_section_to_the_section_check() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set("obsidian", "commit_path", Some("commits".to_string()));
        config.set("templates", "commit_date_path", Some("%F.md".to_string()));
        config.set("templates", "commit_datetime", Some("%T".to_string()));
        config.set("future_release", "whatever", Some("value".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        assert!(
            global_vars.unrecognised_keys().is_empty(),
            "the section is already reported whole; its keys must not double the noise"
        );
    }

    #[test]
    fn test_unrecognised_keys_in_an_unknown_section_is_empty() {
        let mut config = Ini::new();
        config.set("future_release", "whatever", Some("value".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        assert!(
            global_vars
                .unrecognised_keys_in("future_release")
                .is_empty(),
            "the binary cannot know what an unknown section should contain"
        );
    }

    #[test]
    fn test_unrecognised_keys_in_a_section_the_config_lacks_is_empty() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        assert!(
            global_vars.unrecognised_keys_in("exclude").is_empty(),
            "a section that is not in the config has no keys to report"
        );
    }

    #[test]
    fn test_unrecognised_keys_are_sorted_and_name_every_section() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set("obsidian", "commit_path", Some("commits".to_string()));
        config.set("obsidian", "vault", Some("stale".to_string()));
        config.set("templates", "commit_date_path", Some("%F.md".to_string()));
        config.set("templates", "commit_datetime", Some("%T".to_string()));
        config.set("templates", "author", Some("stale".to_string()));
        config.set("exclude", "repos", Some("claude-src".to_string()));
        config.set("exclude", "branches", Some("stale".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        assert_eq!(
            global_vars.unrecognised_keys(),
            vec![
                "[exclude] branches".to_string(),
                "[obsidian] vault".to_string(),
                "[templates] author".to_string(),
            ],
            "hash-map order must not leak into the reported list"
        );
    }

    #[test]
    fn test_set_obsidian_vars_survives_an_unrecognised_key() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set("obsidian", "commit_path", Some("commits".to_string()));
        config.set("templates", "commit_date_path", Some("%F.md".to_string()));
        config.set("templates", "commit_datetime", Some("%T".to_string()));
        config.set("templates", "commit_datetimes", Some("%T".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let result = panic::catch_unwind(AssertUnwindSafe(|| global_vars.set_obsidian_vars()));

        assert!(
            result.is_ok(),
            "an unrecognised key must be reported, never fatal"
        );
        assert_eq!(global_vars.get_template_commit_datetime(), "%T");
    }

    #[test]
    fn test_get_key_from_section_from_ini_exists() {
        let mut config = Ini::new();
        config.set(
            "obsidian",
            "root_path_dir",
            Some("/home/user/Obsidian".to_string()),
        );

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let result = global_vars.get_key_from_section_from_ini("obsidian", "root_path_dir");

        assert_eq!(result, Some("/home/user/Obsidian".to_string()));
    }

    #[test]
    fn test_get_key_from_section_from_ini_not_exists() {
        let mut config = Ini::new();
        config.set("obsidian", "other_key", Some("value".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let result = global_vars.get_key_from_section_from_ini("obsidian", "non_existent_key");

        assert_eq!(result, None);
    }

    #[test]
    fn test_get_config() {
        let mut config = Ini::new();
        config.set("test", "key", Some("value".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config.clone()).unwrap();

        let retrieved_config = global_vars.get_config();

        assert_eq!(
            retrieved_config.get("test", "key"),
            Some("value".to_string())
        );
    }

    #[test]
    fn test_set_obsidian_root_path_dir_with_tilde() {
        let mut config = Ini::new();
        config.set(
            "obsidian",
            "root_path_dir",
            Some("~/Documents/Obsidian".to_string()),
        );
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_obsidian_root_path_dir("obsidian");

        let result = global_vars.get_obsidian_root_path_dir();

        // Should expand ~ to full home path
        assert!(!result.to_string_lossy().contains('~'));
        // Should start with /
        assert!(result.to_string_lossy().starts_with('/'));
        // Should end with Obsidian
        assert!(result.to_string_lossy().ends_with("Obsidian"));
    }

    #[test]
    fn test_set_obsidian_root_path_dir_absolute_path() {
        let mut config = Ini::new();
        config.set(
            "obsidian",
            "root_path_dir",
            Some("/absolute/path/Obsidian".to_string()),
        );
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_obsidian_root_path_dir("obsidian");

        let result = global_vars.get_obsidian_root_path_dir();

        // Should preserve absolute path
        assert!(result.to_string_lossy().contains("/absolute/path/Obsidian"));
    }

    #[test]
    fn test_set_obsidian_commit_path_with_tilde() {
        let mut config = Ini::new();
        config.set(
            "obsidian",
            "commit_path",
            Some("~/Diaries/Commits".to_string()),
        );
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_obsidian_commit_path("obsidian");

        let result = global_vars.get_obsidian_commit_path();

        // Should expand ~ to full home path
        assert!(!result.to_string_lossy().contains('~'));
        // Should end with Commits
        assert!(result.to_string_lossy().ends_with("Commits"));
    }

    #[test]
    fn test_set_obsidian_commit_path_absolute_path() {
        let mut config = Ini::new();
        config.set(
            "obsidian",
            "commit_path",
            Some("absolute/Diaries/Commits".to_string()),
        );
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_obsidian_commit_path("obsidian");

        let result = global_vars.get_obsidian_commit_path();

        // set_obsidian_commit_path() doesn't add leading / (unlike root_path_dir)
        // It just splits by / and rebuilds the PathBuf
        assert!(result.to_string_lossy().contains("absolute"));
        assert!(result.to_string_lossy().ends_with("Commits"));
    }

    #[test]
    fn test_set_templates_commit_date_path() {
        let mut config = Ini::new();
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y/%m-%B/%F.md".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_templates_commit_date_path("templates");

        let result = global_vars.get_template_commit_date_path();

        assert_eq!(result, "%Y/%m-%B/%F.md");
    }

    #[test]
    fn test_set_templates_datetime() {
        let mut config = Ini::new();
        config.set(
            "templates",
            "commit_datetime",
            Some("%Y-%m-%d %H:%M:%S".to_string()),
        );

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_templates_datetime("templates");

        let result = global_vars.get_template_commit_datetime();

        assert_eq!(result, "%Y-%m-%d %H:%M:%S");
    }

    #[test]
    fn test_set_obsidian_vars_both_sections() {
        let mut config = Ini::new();
        config.set(
            "obsidian",
            "root_path_dir",
            Some("/home/user/Obsidian".to_string()),
        );
        config.set(
            "obsidian",
            "commit_path",
            Some("Diaries/Commits".to_string()),
        );
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d.md".to_string()),
        );
        config.set(
            "templates",
            "commit_datetime",
            Some("%Y-%m-%d %H:%M:%S".to_string()),
        );

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        // Call the private method indirectly through set_obsidian_vars
        global_vars.set_obsidian_vars();

        // Verify all getters work (meaning setters were called)
        let root_path = global_vars.get_obsidian_root_path_dir();
        let commit_path = global_vars.get_obsidian_commit_path();
        let date_path = global_vars.get_template_commit_date_path();
        let datetime = global_vars.get_template_commit_datetime();

        assert!(root_path.to_string_lossy().contains("Obsidian"));
        assert!(commit_path.to_string_lossy().contains("Commits"));
        assert_eq!(date_path, "%Y-%m-%d.md");
        assert_eq!(datetime, "%Y-%m-%d %H:%M:%S");
    }

    #[test]
    #[should_panic(expected = "must have [obsidian] and [templates]")]
    fn test_set_obsidian_vars_without_the_obsidian_section() {
        let mut config = Ini::new();
        // [templates] is present but [obsidian] is not, which is fatal. The
        // unrecognised section is incidental - it is not what makes this panic.
        config.set("invalid_section", "key", Some("value".to_string()));
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d.md".to_string()),
        );
        config.set(
            "templates",
            "commit_datetime",
            Some("%Y-%m-%d %H:%M".to_string()),
        );

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        // Panics: [obsidian] is required and missing.
        global_vars.set_obsidian_vars();
    }

    #[test]
    fn test_set_all_integration() {
        use std::io::Write;
        use tempfile::NamedTempFile;

        // Create a temporary config file
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "[obsidian]").unwrap();
        writeln!(temp_file, "root_path_dir=/tmp/test_obsidian").unwrap();
        writeln!(temp_file, "commit_path=TestDiaries/TestCommits").unwrap();
        writeln!(temp_file, "[templates]").unwrap();
        writeln!(temp_file, "commit_date_path=%Y-%m-%d.md").unwrap();
        writeln!(temp_file, "commit_datetime=%Y-%m-%d %H:%M:%S").unwrap();
        temp_file.flush().unwrap();

        // Parse the config manually and test set_all
        let content = std::fs::read_to_string(temp_file.path()).unwrap();
        let config = parse_ini_content(&content).unwrap();

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_obsidian_vars();

        // Verify all values were set
        let root = global_vars.get_obsidian_root_path_dir();
        let commit = global_vars.get_obsidian_commit_path();
        let date = global_vars.get_template_commit_date_path();
        let datetime = global_vars.get_template_commit_datetime();

        assert!(root.to_string_lossy().contains("test_obsidian"));
        assert!(commit.to_string_lossy().contains("TestCommits"));
        assert_eq!(date, "%Y-%m-%d.md");
        assert_eq!(datetime, "%Y-%m-%d %H:%M:%S");
    }

    #[test]
    #[should_panic(expected = "Could not get")]
    fn test_get_obsidian_root_path_dir_not_set() {
        let global_vars = GlobalVars::new();
        // Don't set any values
        // This should panic when trying to get
        global_vars.get_obsidian_root_path_dir();
    }

    #[test]
    #[should_panic(expected = "Could not get")]
    fn test_get_obsidian_commit_path_not_set() {
        let global_vars = GlobalVars::new();
        global_vars.get_obsidian_commit_path();
    }

    #[test]
    #[should_panic(expected = "Could not get")]
    fn test_get_template_commit_date_path_not_set() {
        let global_vars = GlobalVars::new();
        global_vars.get_template_commit_date_path();
    }

    #[test]
    #[should_panic(expected = "Could not get")]
    fn test_get_template_commit_datetime_not_set() {
        let global_vars = GlobalVars::new();
        global_vars.get_template_commit_datetime();
    }

    #[test]
    #[should_panic(expected = "Could not get Config")]
    fn test_get_config_not_initialized() {
        let global_vars = GlobalVars::new();
        // Config not set
        global_vars.get_config();
    }

    #[test]
    fn test_set_config_twice_fails() {
        let global_vars = GlobalVars::new();
        let config1 = Ini::new();
        let config2 = Ini::new();

        assert!(global_vars.config.set(config1).is_ok());
        // Second set should fail
        assert!(global_vars.config.set(config2).is_err());
    }

    #[test]
    fn test_global_vars_set_all_end_to_end() {
        use std::io::Write;
        use tempfile::NamedTempFile;

        // Create a real config file
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "[obsidian]").unwrap();
        writeln!(temp_file, "root_path_dir=/tmp/obsidian_test").unwrap();
        writeln!(temp_file, "commit_path=TestDiaries/TestCommits").unwrap();
        writeln!(temp_file, "[templates]").unwrap();
        writeln!(temp_file, "commit_date_path=%Y/%m-%B/%F.md").unwrap();
        writeln!(temp_file, "commit_datetime=%Y-%m-%d %H:%M:%S").unwrap();
        temp_file.flush().unwrap();

        // Read and parse the config
        let content = std::fs::read_to_string(temp_file.path()).unwrap();
        let mut config = Ini::new();
        config.read(content).unwrap();

        // Now test set_all
        let global_vars = GlobalVars::new();
        let result = global_vars.config.set(config);
        assert!(result.is_ok());

        // Call set_obsidian_vars (which set_all would call)
        global_vars.set_obsidian_vars();

        // Verify everything is accessible
        let root = global_vars.get_obsidian_root_path_dir();
        let commit = global_vars.get_obsidian_commit_path();
        let date_path = global_vars.get_template_commit_date_path();
        let datetime = global_vars.get_template_commit_datetime();

        assert!(root.to_string_lossy().contains("obsidian_test"));
        assert!(commit.to_string_lossy().contains("TestCommits"));
        assert_eq!(date_path, "%Y/%m-%B/%F.md");
        assert_eq!(datetime, "%Y-%m-%d %H:%M:%S");
    }

    #[test]
    fn test_set_obsidian_root_path_dir_with_trailing_slash() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test/".to_string()));
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_obsidian_root_path_dir("obsidian");

        let result = global_vars.get_obsidian_root_path_dir();

        // Should handle trailing slashes gracefully
        assert!(result.to_string_lossy().contains("test"));
    }

    #[test]
    fn test_set_obsidian_commit_path_with_multiple_slashes() {
        let mut config = Ini::new();
        config.set(
            "obsidian",
            "commit_path",
            Some("Diaries//Commits///Nested".to_string()),
        );
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_obsidian_commit_path("obsidian");

        let result = global_vars.get_obsidian_commit_path();

        // Path should be constructed despite multiple slashes
        assert!(result.to_string_lossy().contains("Nested"));
    }

    #[test]
    fn test_set_obsidian_root_path_dir_empty_string() {
        // This used to assert the opposite - that an empty root_path_dir still
        // produced a usable PathBuf. It did: `/`. The vault root silently
        // became the filesystem root, and the run carried on at exit 0. A
        // blank value now counts as a missing key, which is the whole point of
        // the check; the old contract is deliberately withdrawn.
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some(String::new()));
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let result = panic::catch_unwind(AssertUnwindSafe(|| {
            global_vars.set_obsidian_root_path_dir("obsidian")
        }));

        let panic_info = result.expect_err("a blank root_path_dir must be fatal");
        let msg = panic_info
            .downcast_ref::<String>()
            .expect("panic message should be a formatted String");

        assert!(
            msg.contains("missing required key 'root_path_dir' in section [obsidian]"),
            "a blank value must be reported as the missing key it is: {msg}"
        );
    }

    #[test]
    #[should_panic(expected = "missing required key 'commit_path' in section [obsidian]")]
    fn test_set_obsidian_commit_path_missing_key() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        global_vars.set_obsidian_commit_path("obsidian");
    }

    #[test]
    #[should_panic(expected = "missing required key 'root_path_dir' in section [obsidian]")]
    fn test_set_obsidian_root_path_dir_missing_key() {
        let mut config = Ini::new();
        config.set("obsidian", "commit_path", Some("commits".to_string()));
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        global_vars.set_obsidian_root_path_dir("obsidian");
    }

    #[test]
    #[should_panic(expected = "missing required key 'commit_date_path' in section [templates]")]
    fn test_set_templates_commit_date_path_missing_key() {
        let mut config = Ini::new();
        config.set("templates", "commit_datetime", Some("%Y-%m-%d".to_string()));
        config.set("obsidian", "root_path_dir", Some("/tmp".to_string()));
        config.set("obsidian", "commit_path", Some("commits".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        global_vars.set_templates_commit_date_path("templates");
    }

    #[test]
    #[should_panic(expected = "missing required key 'commit_datetime' in section [templates]")]
    fn test_set_templates_datetime_missing_key() {
        let mut config = Ini::new();
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d".to_string()),
        );
        config.set("obsidian", "root_path_dir", Some("/tmp".to_string()));
        config.set("obsidian", "commit_path", Some("commits".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        global_vars.set_templates_datetime("templates");
    }

    #[test]
    #[should_panic(expected = "missing required key 'commit_path' in section [obsidian]")]
    fn test_require_key_treats_a_blank_value_as_missing() {
        // `commit_path =` used to satisfy the presence check and journal into
        // the vault root instead of the configured folder, at exit 0.
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set("obsidian", "commit_path", Some("   ".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        global_vars.set_obsidian_commit_path("obsidian");
    }

    #[test]
    fn test_require_key_names_the_config_file_and_the_typo() {
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        // The whole point: the missing key and the reason it is missing get
        // named together, so nobody has to read the source to connect them.
        config.set("obsidian", "commit_paths", Some("commits".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars
            .config_path
            .set("/tmp/some/rusty-commit-saver.ini".to_string())
            .unwrap();

        let result = panic::catch_unwind(AssertUnwindSafe(|| {
            global_vars.set_obsidian_commit_path("obsidian")
        }));

        let panic_info = result.expect_err("a missing required key must be fatal");
        let msg = panic_info
            .downcast_ref::<String>()
            .expect("panic message should be a formatted String");

        assert!(
            msg.contains("/tmp/some/rusty-commit-saver.ini"),
            "the message must name the file to edit: {msg}"
        );
        assert!(
            msg.contains("missing required key 'commit_path' in section [obsidian]"),
            "the message must name the key and its section: {msg}"
        );
        assert!(
            msg.contains("unrecognised in [obsidian]: commit_paths"),
            "the message must name the typo that explains the absence: {msg}"
        );
    }

    #[test]
    fn test_require_time_format_rejects_what_chrono_cannot_render() {
        let mut config = Ini::new();
        config.set("templates", "commit_datetime", Some("%Q".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars
            .config_path
            .set("/tmp/some/rusty-commit-saver.ini".to_string())
            .unwrap();

        let result = panic::catch_unwind(AssertUnwindSafe(|| {
            global_vars.set_templates_datetime("templates")
        }));

        let panic_info = result.expect_err("a format chrono cannot render must be fatal");
        let msg = panic_info
            .downcast_ref::<String>()
            .expect("panic message should be a formatted String");

        assert!(
            msg.contains("/tmp/some/rusty-commit-saver.ini"),
            "the message must name the file to edit: {msg}"
        );
        assert!(
            msg.contains("key 'commit_datetime' in section [templates]"),
            "the message must name the key and its section: {msg}"
        );
        assert!(
            msg.contains("'%Q'"),
            "the message must quote the value that cannot be rendered: {msg}"
        );
    }

    #[test]
    fn test_require_time_format_guards_the_date_path_too() {
        // Both format keys go through the same check. Without this, reverting
        // the date-path call site alone would leave every test green.
        let mut config = Ini::new();
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y/%Q.md".to_string()),
        );

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let result = panic::catch_unwind(AssertUnwindSafe(|| {
            global_vars.set_templates_commit_date_path("templates")
        }));

        let panic_info = result.expect_err("a format chrono cannot render must be fatal");
        let msg = panic_info
            .downcast_ref::<String>()
            .expect("panic message should be a formatted String");

        assert!(
            msg.contains("key 'commit_date_path' in section [templates]"),
            "the message must name the key and its section: {msg}"
        );
    }

    #[test]
    fn test_is_renderable_time_format_accepts_the_shipped_defaults() {
        assert!(is_renderable_time_format("%H:%M:%S"));
        assert!(is_renderable_time_format("%Y/%m-%B/%F.md"));
        assert!(
            is_renderable_time_format("Commits"),
            "a format with no specifier at all is still renderable"
        );
        assert!(!is_renderable_time_format("%Q"));
    }

    #[test]
    fn test_require_key_says_which_config_when_none_was_read() {
        let mut config = Ini::new();
        config.set("obsidian", "commit_path", Some("commits".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let result = panic::catch_unwind(AssertUnwindSafe(|| {
            global_vars.set_obsidian_root_path_dir("obsidian")
        }));

        let panic_info = result.expect_err("a missing required key must be fatal");
        let msg = panic_info
            .downcast_ref::<String>()
            .expect("panic message should be a formatted String");

        assert!(
            msg.contains("the rusty-commit-saver config"),
            "with no file read, the message must say so rather than guess a path: {msg}"
        );
    }

    #[test]
    fn test_global_vars_set_all_method() {
        use std::io::Write;
        use tempfile::NamedTempFile;

        // Create a real config file
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "[obsidian]").unwrap();
        writeln!(temp_file, "root_path_dir=/tmp/obsidian_full_test").unwrap();
        writeln!(temp_file, "commit_path=FullTest/Commits").unwrap();
        writeln!(temp_file, "[templates]").unwrap();
        writeln!(temp_file, "commit_date_path=%Y/%m/%d.md").unwrap();
        writeln!(temp_file, "commit_datetime=%Y-%m-%d %H:%M:%S").unwrap();
        temp_file.flush().unwrap();

        // Parse config manually
        let content = std::fs::read_to_string(temp_file.path()).unwrap();
        let config = parse_ini_content(&content).unwrap();

        // Test set_all workflow
        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_obsidian_vars();

        // Verify all values accessible via set_all pattern
        let root = global_vars.get_obsidian_root_path_dir();
        let commit = global_vars.get_obsidian_commit_path();
        let date = global_vars.get_template_commit_date_path();
        let datetime = global_vars.get_template_commit_datetime();

        assert!(root.to_string_lossy().contains("obsidian_full_test"));
        assert!(commit.to_string_lossy().contains("FullTest"));
        assert_eq!(date, "%Y/%m/%d.md");
        assert_eq!(datetime, "%Y-%m-%d %H:%M:%S");
    }

    #[test]
    fn test_set_obsidian_vars_complete_workflow() {
        let mut config = Ini::new();
        config.set(
            "obsidian",
            "root_path_dir",
            Some("~/test/obsidian".to_string()),
        );
        config.set(
            "obsidian",
            "commit_path",
            Some("~/test/commits".to_string()),
        );
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y/%m/%d.md".to_string()),
        );
        config.set(
            "templates",
            "commit_datetime",
            Some("%Y-%m-%d %H:%M:%S".to_string()),
        );

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        // This exercises the full set_obsidian_vars logic
        global_vars.set_obsidian_vars();

        // Verify all paths were expanded
        let root = global_vars.get_obsidian_root_path_dir();
        let commit = global_vars.get_obsidian_commit_path();

        // Both should have ~ expanded
        assert!(!root.to_string_lossy().contains('~'));
        assert!(!commit.to_string_lossy().contains('~'));
        assert!(root.to_string_lossy().contains("obsidian"));
        assert!(commit.to_string_lossy().contains("commits"));
    }
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod user_input_tests {
    use super::*;
    use clap::Parser;
    use std::sync::{Mutex, MutexGuard, PoisonError};

    /// `RUSTY_COMMIT_SAVER_CONFIG` is process-global, and several tests here
    /// both write and read it. Under `cargo test` they share one process and
    /// race: a test reading the var can see the value another test just set.
    /// (`cargo nextest`, which the gate uses, runs each test in its own
    /// process and never sees this.)
    static CONFIG_ENV: Mutex<()> = Mutex::new(());

    /// Takes the lock above, ignoring poisoning - several of these tests panic
    /// deliberately, and a poisoned lock is not a reason to fail the rest.
    fn lock_config_env() -> MutexGuard<'static, ()> {
        CONFIG_ENV.lock().unwrap_or_else(PoisonError::into_inner)
    }

    #[test]
    fn test_user_input_parse_with_config() {
        let args = vec!["test_program", "--config-ini", "/path/to/config.ini"];
        let user_input = UserInput::try_parse_from(args).unwrap();

        assert_eq!(
            user_input.config_ini,
            Some("/path/to/config.ini".to_string())
        );
    }

    #[test]
    fn test_user_input_parse_without_config() {
        let args = vec!["test_program"];
        let user_input = UserInput::try_parse_from(args).unwrap();

        assert_eq!(user_input.config_ini, None);
    }

    #[test]
    fn test_user_input_parse_short_flag() {
        let args = vec!["test_program", "-c", "/short/path/config.ini"];
        let user_input = UserInput::try_parse_from(args).unwrap();

        assert_eq!(
            user_input.config_ini,
            Some("/short/path/config.ini".to_string())
        );
    }

    #[test]
    fn test_set_proper_home_dir_with_tilde() {
        let input = "~/test/path/file.ini";
        let result = set_proper_home_dir(input);

        // Should replace ~ with actual home directory
        assert!(!result.contains('~'));
        assert!(result.ends_with("/test/path/file.ini"));
    }

    #[test]
    fn test_set_proper_home_dir_without_tilde() {
        let input = "/absolute/path/file.ini";
        let result = set_proper_home_dir(input);

        // Should remain unchanged
        assert_eq!(result, input);
    }

    #[test]
    fn test_set_proper_home_dir_multiple_tildes() {
        let input = "~/path/~/file.ini";
        let result = set_proper_home_dir(input);

        // Should replace ALL tildes
        assert!(!result.contains('~'));
    }

    #[test]
    fn test_get_default_ini_path() {
        let result = get_default_ini_path();

        // Should end with the expected config path
        assert!(result.ends_with(".config/rusty-commit-saver/rusty-commit-saver.ini"));

        // Should NOT contain literal tilde
        assert!(!result.contains('~'));

        // Should be an absolute path
        assert!(result.starts_with('/'));
    }

    #[test]
    fn test_get_or_default_config_ini_path_with_config_and_tilde() {
        // Simulate CLI args: --config-ini ~/my/config.ini
        let args = vec!["test", "--config-ini", "~/my/config.ini"];
        let user_input = UserInput::try_parse_from(args).unwrap();

        // We can't directly call get_or_default_config_ini_path() because it parses env args
        // Instead, test that UserInput correctly parses the config path
        assert_eq!(user_input.config_ini, Some("~/my/config.ini".to_string()));
    }

    #[test]
    fn test_get_or_default_config_ini_path_with_config_absolute_path() {
        // Simulate CLI args: --config-ini /absolute/path/config.ini
        let args = vec!["test", "--config-ini", "/absolute/path/config.ini"];
        let user_input = UserInput::try_parse_from(args).unwrap();

        assert_eq!(
            user_input.config_ini,
            Some("/absolute/path/config.ini".to_string())
        );
    }

    #[test]
    fn test_get_or_default_config_ini_path_without_config() {
        // Simulate CLI args with no config specified
        let args = vec!["test"];
        let user_input = UserInput::try_parse_from(args).unwrap();

        // Should default to None, and get_or_default_config_ini_path() will use get_default_ini_path()
        assert_eq!(user_input.config_ini, None);
    }

    #[test]
    fn test_parse_ini_content_valid() {
        let content = r"
[obsidian]
root_path_dir=~/Documents/Obsidian
commit_path=Diaries/Commits

[templates]
commit_date_path=%Y/%m-%B/%F.md
commit_datetime=%Y-%m-%d
";

        let result = parse_ini_content(content);
        assert!(result.is_ok());

        let ini = result.unwrap();
        assert_eq!(
            ini.get("obsidian", "root_path_dir"),
            Some("~/Documents/Obsidian".to_string())
        );
        assert_eq!(
            ini.get("templates", "commit_date_path"),
            Some("%Y/%m-%B/%F.md".to_string())
        );
    }

    #[test]
    fn test_parse_ini_content_invalid() {
        let content = "this is not valid ini format [[[";

        let result = parse_ini_content(content);
        // Should succeed because configparser is very lenient, but let's verify it doesn't panic
        assert!(result.is_ok() || result.is_err());
    }

    #[test]
    fn test_parse_ini_content_empty() {
        let content = "";

        let result = parse_ini_content(content);
        assert!(result.is_ok());

        let ini = result.unwrap();
        assert_eq!(ini.sections().len(), 0);
    }

    #[test]
    fn test_retrieve_config_file_path_with_temp_file() {
        use std::io::Write;
        use tempfile::NamedTempFile;

        // Create a temporary config file
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "[obsidian]").unwrap();
        writeln!(temp_file, "root_path_dir=/tmp/test").unwrap();
        writeln!(temp_file, "commit_path=commits").unwrap();
        writeln!(temp_file, "[templates]").unwrap();
        writeln!(temp_file, "commit_date_path=%Y-%m-%d.md").unwrap();
        writeln!(temp_file, "commit_datetime=%Y-%m-%d").unwrap();
        temp_file.flush().unwrap();

        // Set CLI args to point to our temp file
        // We need to simulate CLI args via environment
        let path = temp_file.path().to_str().unwrap();

        // Instead of testing retrieve_config_file_path directly (which reads from CLI),
        // test that we can read and parse a config file
        let content = std::fs::read_to_string(path).unwrap();
        let result = parse_ini_content(&content);

        assert!(result.is_ok());
        let ini = result.unwrap();
        assert_eq!(
            ini.get("obsidian", "root_path_dir"),
            Some("/tmp/test".to_string())
        );
    }

    #[test]
    fn test_ini_parsing_integration() {
        let content = r"
[obsidian]
root_path_dir=~/Documents/Obsidian
commit_path=Diaries/Commits

[templates]
commit_date_path=%Y/%m-%B/%F.md
commit_datetime=%Y-%m-%d %H:%M:%S
";

        let ini = parse_ini_content(content).unwrap();

        // Verify all expected keys exist
        assert!(ini.get("obsidian", "root_path_dir").is_some());
        assert!(ini.get("obsidian", "commit_path").is_some());
        assert!(ini.get("templates", "commit_date_path").is_some());
        assert!(ini.get("templates", "commit_datetime").is_some());

        // Verify sections count
        assert_eq!(ini.sections().len(), 2);
    }

    // #[test]
    // fn debug_ini_sections_behavior() {
    //     let mut config = Ini::new();
    //     config.set("only_one_section", "key", Some("value".to_string()));
    //
    //     let sections = config.sections();
    //     println!("Sections count: {}", sections.len());
    //     println!("Sections: {:?}", sections);
    //
    //     // Force fail to see output
    //     assert!(false, "Debug: sections = {:?}", sections);
    // }

    #[test]
    fn test_missing_required_sections_panic_message() {
        use std::panic;

        let mut config = Ini::new();
        config.set("only_one_section", "key", Some("value".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let result = panic::catch_unwind(|| global_vars.get_sections_from_config());

        assert!(result.is_err(), "Should have panicked");
    }

    #[test]
    fn test_set_all_loads_config_and_sets_vars() {
        use std::env;
        use std::fs;
        use tempfile::NamedTempFile;

        let temp_file = NamedTempFile::new().expect("Failed to create temp file");
        let config_content = r"[obsidian]
root_path_dir = /tmp/test_obsidian
commit_path = Commits

[templates]
commit_date_path = %Y/%m/%d.md
commit_datetime = %Y-%m-%d %H:%M:%S
";
        fs::write(temp_file.path(), config_content).expect("Failed to write temp config");

        let _guard = lock_config_env();
        env::set_var(
            "RUSTY_COMMIT_SAVER_CONFIG",
            temp_file.path().to_str().unwrap(),
        );

        let global_vars = GlobalVars::new();
        let result = global_vars.set_all();

        // Verify method chaining
        assert!(std::ptr::eq(result, &raw const global_vars));

        // Verify config was set
        assert!(global_vars.config.get().is_some());

        env::remove_var("RUSTY_COMMIT_SAVER_CONFIG");
    }

    #[test]
    #[should_panic(expected = "config_path DOES NOT exists")]
    fn test_retrieve_config_file_path_panics_on_missing_file() {
        let _guard = lock_config_env();
        std::env::set_var("RUSTY_COMMIT_SAVER_CONFIG", "/nonexistent/path/config.ini");
        let _ = retrieve_config_file_path();
    }

    #[test]
    fn test_get_or_default_config_ini_path_env_var_with_tilde() {
        use std::env;

        let _guard = lock_config_env();
        let var_name = "RUSTY_COMMIT_SAVER_CONFIG";
        let original = env::var(var_name).ok();

        env::set_var(var_name, "~/some/config/path.ini");

        let result = get_or_default_config_ini_path();

        // Restore
        match original {
            Some(val) => env::set_var(var_name, val),
            None => env::remove_var(var_name),
        }

        // Should have expanded ~ to home dir
        assert!(!result.contains('~'), "Tilde should be expanded");
        assert!(result.ends_with("/some/config/path.ini"));
    }

    #[test]
    fn test_resolve_config_path_cli_with_tilde() {
        let result = resolve_config_path(Some("~/my/config.ini".to_string()), None);
        assert!(!result.contains('~'));
        assert!(result.ends_with("/my/config.ini"));
    }

    #[test]
    fn test_resolve_config_path_cli_without_tilde() {
        let result = resolve_config_path(Some("/absolute/path.ini".to_string()), None);
        assert_eq!(result, "/absolute/path.ini");
    }

    #[test]
    fn test_resolve_config_path_default() {
        let result = resolve_config_path(None, None);
        assert!(result.contains("rusty-commit-saver.ini"));
    }

    #[test]
    fn test_resolve_config_path_env_takes_precedence() {
        let result = resolve_config_path(
            Some("/cli/path.ini".to_string()),
            Some("/env/path.ini".to_string()),
        );
        assert_eq!(result, "/env/path.ini");
    }

    #[test]
    fn test_get_or_default_config_ini_path_with_no_env_calls_cli_parser() {
        let parser_called = std::cell::Cell::new(false);

        let result = get_or_default_config_ini_path_with(None, || {
            parser_called.set(true);
            Some("/mock/cli/path.ini".to_string())
        });

        assert!(
            parser_called.get(),
            "CLI parser should be called when no env var"
        );
        assert_eq!(result, "/mock/cli/path.ini");
    }

    #[test]
    fn test_get_or_default_config_ini_path_with_env_skips_cli_parser() {
        let parser_called = std::cell::Cell::new(false);

        let result = get_or_default_config_ini_path_with(Some("/env/path.ini".to_string()), || {
            parser_called.set(true);
            Some("/should/not/be/used.ini".to_string())
        });

        assert!(
            !parser_called.get(),
            "CLI parser should NOT be called when env var is set"
        );
        assert_eq!(result, "/env/path.ini");
    }

    #[test]
    fn test_get_or_default_config_ini_path_with_cli_returns_default_when_none() {
        let result = get_or_default_config_ini_path_with(None, || None);

        // Should fall back to default path
        assert!(result.contains("rusty-commit-saver.ini"));
    }

    #[test]
    fn test_get_or_default_config_ini_path_with_cli_tilde_expansion() {
        let result =
            get_or_default_config_ini_path_with(None, || Some("~/custom/config.ini".to_string()));

        assert!(!result.contains('~'), "Tilde should be expanded");
        assert!(result.ends_with("/custom/config.ini"));
    }

    #[test]
    fn test_parse_ini_content_find_invalid_case() {
        let cases = [
            "[unclosed",
            "no_section_key = value", // might actually work (goes to default section)
            "[section]\nweird line without equals",
        ];

        for case in cases {
            let result = parse_ini_content(case);
            println!("{case:?} => {result:?}");
        }
    }

    #[test]
    fn test_parse_ini_content_invalid_syntax() {
        let result = parse_ini_content("[unclosed");

        assert!(result.is_err(), "Should fail on unclosed bracket");
        let err = result.unwrap_err();
        assert!(
            err.contains("Failed to parse INI"),
            "Error should contain expected prefix: {err}"
        );
    }

    #[test]
    #[should_panic(expected = "Should have been able to read the file")]
    fn test_retrieve_config_file_path_panics_on_unreadable_file() {
        use std::fs::{self, File};
        use std::os::unix::fs::PermissionsExt;
        use tempfile::tempdir;

        let dir = tempdir().unwrap();
        let file_path = dir.path().join("unreadable.ini");

        // Create file with no read permissions
        File::create(&file_path).unwrap();
        fs::set_permissions(&file_path, fs::Permissions::from_mode(0o000)).unwrap();

        let _guard = lock_config_env();
        std::env::set_var("RUSTY_COMMIT_SAVER_CONFIG", file_path.to_str().unwrap());

        // This should panic because file exists but can't be read
        let _ = retrieve_config_file_path();

        // Cleanup (won't run due to panic, but good practice)
        fs::set_permissions(&file_path, fs::Permissions::from_mode(0o644)).unwrap();
    }

    #[test]
    fn test_get_ini_file_reads_the_configured_path() {
        use std::io::Write;
        use tempfile::NamedTempFile;

        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "[obsidian]").unwrap();
        writeln!(temp_file, "root_path_dir=/tmp/test").unwrap();
        writeln!(temp_file, "commit_path=commits").unwrap();
        writeln!(temp_file, "[templates]").unwrap();
        writeln!(temp_file, "commit_date_path=%Y-%m-%d.md").unwrap();
        writeln!(temp_file, "commit_datetime=%H:%M:%S").unwrap();
        temp_file.flush().unwrap();

        let _guard = lock_config_env();
        std::env::set_var("RUSTY_COMMIT_SAVER_CONFIG", temp_file.path());

        // The convenience wrapper must resolve the path the same way
        // set_all() does, now that set_all() resolves it itself.
        let config = get_ini_file();

        std::env::remove_var("RUSTY_COMMIT_SAVER_CONFIG");

        assert_eq!(
            config.get("obsidian", "commit_path"),
            Some("commits".to_string())
        );
    }

    #[test]
    fn test_parse_exclude_repos_basic() {
        assert_eq!(
            parse_exclude_repos("claude-src, other-repo"),
            vec!["claude-src".to_string(), "other-repo".to_string()]
        );
    }

    #[test]
    fn test_parse_exclude_repos_trims_and_drops_empties() {
        // Extra spaces, trailing comma, and an empty middle entry are all cleaned.
        assert_eq!(
            parse_exclude_repos("  claude-src , , foo,"),
            vec!["claude-src".to_string(), "foo".to_string()]
        );
    }

    #[test]
    fn test_parse_exclude_repos_empty_input() {
        assert!(parse_exclude_repos("   ").is_empty());
        assert!(parse_exclude_repos("").is_empty());
    }

    #[test]
    fn test_parse_exclude_repos_single_entry() {
        assert_eq!(
            parse_exclude_repos("claude-src"),
            vec!["claude-src".to_string()]
        );
    }

    #[test]
    fn test_get_excluded_repos_defaults_empty_when_unset() {
        // No [exclude] section set: getter yields an empty list, not a panic.
        let global_vars = GlobalVars::new();
        assert!(global_vars.get_excluded_repos().is_empty());
    }

    #[test]
    fn test_set_and_get_excluded_repos() {
        let mut config = Ini::new();
        config.set("exclude", "repos", Some("claude-src, foo".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_excluded_repos("exclude");

        assert_eq!(
            global_vars.get_excluded_repos(),
            vec!["claude-src".to_string(), "foo".to_string()]
        );
    }

    #[test]
    fn test_set_excluded_repos_missing_key_is_empty() {
        // [exclude] present but no `repos` key -> empty list, no panic.
        let mut config = Ini::new();
        config.set("exclude", "unrelated", Some("value".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_excluded_repos("exclude");

        assert!(global_vars.get_excluded_repos().is_empty());
    }

    #[test]
    fn test_get_sections_accepts_optional_exclude_section() {
        // obsidian + templates + exclude is now valid (exclude is optional).
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set("templates", "commit_date_path", Some("%Y.md".to_string()));
        config.set("exclude", "repos", Some("claude-src".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let sections = global_vars.get_sections_from_config();
        assert_eq!(sections.len(), 3);
        assert!(sections.contains(&"exclude".to_string()));
    }

    #[test]
    fn test_set_obsidian_vars_populates_exclude_section() {
        // Full set_obsidian_vars path with all three sections present.
        let mut config = Ini::new();
        config.set(
            "obsidian",
            "root_path_dir",
            Some("/home/user/Obsidian".to_string()),
        );
        config.set(
            "obsidian",
            "commit_path",
            Some("Diaries/Commits".to_string()),
        );
        config.set(
            "templates",
            "commit_date_path",
            Some("%Y-%m-%d.md".to_string()),
        );
        config.set("templates", "commit_datetime", Some("%H:%M:%S".to_string()));
        config.set("exclude", "repos", Some("claude-src".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        global_vars.set_obsidian_vars();

        assert_eq!(
            global_vars.get_excluded_repos(),
            vec!["claude-src".to_string()]
        );
    }

    #[test]
    fn test_get_sections_tolerates_an_unknown_section() {
        // A config written for a newer release must not brick an older binary:
        // an unrecognised section is ignored, not fatal. This is what made the
        // pre-4.17.0 binaries panic once [exclude] was added to the shared ini.
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));
        config.set("templates", "commit_date_path", Some("%Y.md".to_string()));
        config.set("from_a_future_release", "key", Some("value".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();

        let sections = global_vars.get_sections_from_config();
        assert!(sections.contains(&"obsidian".to_string()));
        assert!(sections.contains(&"templates".to_string()));
    }

    #[test]
    #[should_panic(expected = "must have [obsidian] and [templates]")]
    fn test_get_sections_rejects_obsidian_without_templates() {
        // The mirror of the case below: [obsidian] alone is just as fatal.
        let mut config = Ini::new();
        config.set("obsidian", "root_path_dir", Some("/tmp/test".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        let _ = global_vars.get_sections_from_config();
    }

    #[test]
    #[should_panic(expected = "must have [obsidian] and [templates]")]
    fn test_get_sections_rejects_missing_required_section() {
        // exclude alone (no obsidian/templates) is still invalid.
        let mut config = Ini::new();
        config.set("exclude", "repos", Some("claude-src".to_string()));
        config.set("templates", "commit_date_path", Some("%Y.md".to_string()));

        let global_vars = GlobalVars::new();
        global_vars.config.set(config).unwrap();
        let _ = global_vars.get_sections_from_config();
    }
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod since_tests {
    use super::*;

    #[test]
    fn a_date_becomes_midnight_utc() {
        let floor = parse_since("2026-08-01").expect("a real date");

        assert_eq!(floor.to_rfc3339(), "2026-08-01T00:00:00+00:00");
    }

    #[test]
    fn surrounding_whitespace_is_tolerated() {
        // A timer unit's ExecStart is edited by hand; a stray space must not
        // turn into a backfill of everything HEAD can reach.
        assert_eq!(
            parse_since("  2026-08-01 ").expect("a real date"),
            parse_since("2026-08-01").expect("a real date")
        );
    }

    #[test]
    fn an_unreadable_value_names_itself_and_the_shape() {
        let error = parse_since("yesterday").expect_err("not a date");

        assert!(error.contains("YYYY-MM-DD"), "must name the shape: {error}");
        assert!(error.contains("yesterday"), "must quote the value: {error}");
    }

    #[test]
    fn a_date_that_does_not_exist_is_refused() {
        assert!(parse_since("2026-02-30").is_err());
    }
}