cull-gmail 0.1.8

//! Rules management for Gmail message retention and cleanup.
//!
//! This module provides the [`Rules`] struct which manages a collection of end-of-life (EOL)
//! rules for automatically processing Gmail messages. Rules define when and how messages
//! should be processed based on their age and labels.
//!
//! # Overview
//!
//! The rules system allows you to:
//! - Create rules with specific retention periods (days, weeks, months, years)
//! - Target specific Gmail labels or apply rules globally
//! - Choose between moving to trash or permanent deletion
//! - Save and load rule configurations from disk
//! - Manage rules individually by ID or label
//!
//! # Usage
//!
//! ```
//! use cull_gmail::{Rules, Retention, MessageAge, EolAction};
//!
//! // Create a new rule set
//! let mut rules = Rules::new();
//!
//! // Add a rule to delete old newsletters after 6 months
//! let newsletter_retention = Retention::new(MessageAge::Months(6), true);
//! rules.add_rule(newsletter_retention, Some("newsletter"), true);
//!
//! // Add a rule to trash spam after 30 days
//! let spam_retention = Retention::new(MessageAge::Days(30), false);
//! rules.add_rule(spam_retention, Some("spam"), false);
//!
//! // Save the rules to disk
//! rules.save().expect("Failed to save rules");
//!
//! // List all configured rules
//! rules.list_rules().expect("Failed to list rules");
//! ```
//!
//! # Persistence
//!
//! Rules are automatically saved to `~/.cull-gmail/rules.toml` and can be loaded
//! using [`Rules::load()`]. The configuration uses TOML format for human readability.

use std::{
    collections::BTreeMap,
    env, fmt,
    fs::{self, read_to_string},
    path::Path,
};

use serde::{Deserialize, Serialize};

mod eol_rule;

pub use eol_rule::EolRule;

use crate::{EolAction, Error, MessageAge, Result, Retention};

/// A collection of end-of-life rules for Gmail message processing.
///
/// `Rules` manages a set of end-of-life rule instances that define how Gmail messages
/// should be processed based on their age and labels. Rules can move messages to
/// trash or delete them permanently when they exceed specified retention periods.
///
/// # Structure
///
/// Each rule has:
/// - A unique ID for identification
/// - A retention period (age threshold)
/// - Optional target labels
/// - An action (trash or delete)
///
/// # Default Rules
///
/// When created with [`Rules::new()`] or [`Rules::default()`], the following
/// default rules are automatically added:
/// - 1 year retention with auto-generated label
/// - 1 week retention with auto-generated label  
/// - 1 month retention with auto-generated label
/// - 5 year retention with auto-generated label
///
/// # Examples
///
/// ```
/// use cull_gmail::{Rules, Retention, MessageAge};
///
/// let rules = Rules::new();
/// // Default rules are automatically created
/// assert!(!rules.labels().is_empty());
/// ```
///
/// # Serialization
///
/// Rules can be serialized to and from TOML format for persistence.
#[derive(Debug, Serialize, Deserialize)]
pub struct Rules {
    rules: BTreeMap<String, EolRule>,
}

impl Default for Rules {
    fn default() -> Self {
        let rules = BTreeMap::new();

        let mut cfg = Self { rules };

        cfg.add_rule(Retention::new(MessageAge::Years(1), true), None, false)
            .add_rule(Retention::new(MessageAge::Weeks(1), true), None, false)
            .add_rule(Retention::new(MessageAge::Months(1), true), None, false)
            .add_rule(Retention::new(MessageAge::Years(5), true), None, false);

        cfg
    }
}

impl Rules {
    /// Creates a new Rules instance with default retention rules.
    ///
    /// This creates the same configuration as [`Rules::default()`], including
    /// several pre-configured rules with common retention periods.
    ///
    /// # Examples
    ///
    /// ```
    /// use cull_gmail::Rules;
    ///
    /// let rules = Rules::new();
    /// // Default rules are automatically created
    /// let labels = rules.labels();
    /// assert!(!labels.is_empty());
    /// ```
    pub fn new() -> Self {
        Rules::default()
    }

    /// Retrieves a rule by its unique ID.
    ///
    /// Returns a cloned copy of the rule if found, or `None` if no rule
    /// exists with the specified ID.
    ///
    /// # Arguments
    ///
    /// * `id` - The unique identifier of the rule to retrieve
    ///
    /// # Examples
    ///
    /// ```
    /// use cull_gmail::{Rules, Retention, MessageAge};
    ///
    /// let mut rules = Rules::new();
    /// let retention = Retention::new(MessageAge::Days(30), false);
    /// rules.add_rule(retention, None, false);
    ///
    /// // Retrieve a rule (exact ID depends on existing rules)
    /// if let Some(rule) = rules.get_rule(1) {
    ///     println!("Found rule: {}", rule.describe());
    /// }
    /// ```
    pub fn get_rule(&self, id: usize) -> Option<EolRule> {
        self.rules.get(&id.to_string()).cloned()
    }

    /// Adds a new rule to the rule set with the specified retention settings.
    ///
    /// Creates a new rule with an automatically assigned unique ID. If a label
    /// is specified and another rule already targets that label, a warning is
    /// logged and the rule is not added.
    ///
    /// # Arguments
    ///
    /// * `retention` - The retention configuration (age and label generation)
    /// * `label` - Optional label that this rule should target
    /// * `delete` - If `true`, messages are permanently deleted; if `false`, moved to trash
    ///
    /// # Returns
    ///
    /// Returns a mutable reference to self for method chaining.
    ///
    /// # Examples
    ///
    /// ```
    /// use cull_gmail::{Rules, Retention, MessageAge, EolAction};
    ///
    /// let mut rules = Rules::new();
    ///
    /// // Add a rule to trash newsletters after 3 months
    /// let retention = Retention::new(MessageAge::Months(3), false);
    /// rules.add_rule(retention, Some("newsletter"), false);
    ///
    /// // Add a rule to delete spam after 7 days
    /// let spam_retention = Retention::new(MessageAge::Days(7), false);
    /// rules.add_rule(spam_retention, Some("spam"), true);
    /// ```
    pub fn add_rule(
        &mut self,
        retention: Retention,
        label: Option<&str>,
        delete: bool,
    ) -> &mut Self {
        let current_labels: Vec<String> =
            self.rules.values().flat_map(|rule| rule.labels()).collect();

        if let Some(label_ref) = label
            && current_labels.iter().any(|l| l == label_ref)
        {
            log::warn!("a rule already applies to label {label_ref}");
            return self;
        }

        let id = if let Some((_, max)) = self.rules.iter().max_by_key(|(_, r)| r.id()) {
            max.id() + 1
        } else {
            1
        };

        let mut rule = EolRule::new(id);
        rule.set_retention(retention);
        if let Some(l) = label {
            rule.add_label(l);
        }
        if delete {
            rule.set_action(&EolAction::Delete);
        }
        log::info!("added rule: {rule}");
        self.rules.insert(rule.id().to_string(), rule);
        self
    }

    /// Returns all labels targeted by the current rules.
    ///
    /// This method collects labels from all rules in the set and returns
    /// them as a single vector. Duplicate labels are not removed.
    ///
    /// # Examples
    ///
    /// ```
    /// use cull_gmail::{Rules, Retention, MessageAge};
    ///
    /// let mut rules = Rules::new();
    /// let retention = Retention::new(MessageAge::Days(30), false);
    /// rules.add_rule(retention, Some("test-label"), false);
    ///
    /// let labels = rules.labels();
    /// assert!(labels.len() > 0);
    /// println!("Configured labels: {:?}", labels);
    /// ```
    pub fn labels(&self) -> Vec<String> {
        self.rules.values().flat_map(|rule| rule.labels()).collect()
    }

    /// Find the ids of the rules that contains a label
    ///
    /// A label may have a `trash` and `delete` rule applied to return a
    /// maximum of two rules.
    ///
    /// If a label has more than one `trash` or `delete` rules only the id
    /// for the last rule will be returned.
    fn find_label(&self, label: &str) -> Vec<usize> {
        let mut rwl = Vec::new();

        if let Some(t) = self.find_label_for_action(label, EolAction::Trash) {
            rwl.push(t);
        }

        if let Some(d) = self.find_label_for_action(label, EolAction::Delete) {
            rwl.push(d);
        }

        rwl
    }

    /// Find the id of the rule that contains a label
    fn find_label_for_action(&self, label: &str, action: EolAction) -> Option<usize> {
        let rules_by_label = self.get_rules_by_label_for_action(action);

        rules_by_label.get(label).map(|r| r.id())
    }

    /// Removes a rule from the set by its unique ID.
    ///
    /// If the rule exists, it is removed and a confirmation message is printed.
    /// If the rule doesn't exist, the operation completes successfully without error.
    ///
    /// # Arguments
    ///
    /// * `id` - The unique identifier of the rule to remove
    ///
    /// # Examples
    ///
    /// ```
    /// use cull_gmail::{Rules, Retention, MessageAge};
    ///
    /// let mut rules = Rules::new();
    /// // Assume rule ID 1 exists from defaults
    /// rules.remove_rule_by_id(1).expect("Failed to remove rule");
    /// ```
    ///
    /// # Errors
    ///
    /// This method currently always returns `Ok(())`, but the return type
    /// is `Result<()>` for future extensibility.
    pub fn remove_rule_by_id(&mut self, id: usize) -> crate::Result<()> {
        self.rules.remove(&id.to_string());
        println!("Rule `{id}` has been removed.");
        Ok(())
    }

    /// Removes a rule from the set by targeting one of its labels.
    ///
    /// Finds the rule that contains the specified label and removes it.
    /// If multiple rules target the same label, only one is removed.
    ///
    /// # Arguments
    ///
    /// * `label` - The label to search for in existing rules
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use cull_gmail::{Rules, Retention, MessageAge};
    ///
    /// let mut rules = Rules::new();
    /// let retention = Retention::new(MessageAge::Days(30), false);
    /// rules.add_rule(retention, Some("newsletter"), false);
    ///
    /// // Remove the rule targeting the newsletter label
    /// rules.remove_rule_by_label("newsletter")
    ///      .expect("Failed to remove rule");
    /// ```
    ///
    /// # Errors
    ///
    /// * [`Error::LabelNotFoundInRules`] if no rule contains the specified label
    /// * [`Error::NoRuleFoundForLabel`] if the label exists but no rule is found
    ///   (should not happen under normal conditions)
    pub fn remove_rule_by_label(&mut self, label: &str) -> crate::Result<()> {
        let labels = self.labels();

        if !labels.iter().any(|l| l == label) {
            return Err(Error::LabelNotFoundInRules(label.to_string()));
        }

        let rule_ids = self.find_label(label);
        if rule_ids.is_empty() {
            return Err(Error::NoRuleFoundForLabel(label.to_string()));
        }

        for id in rule_ids {
            self.rules.remove(&id.to_string());
        }

        log::info!("Rule containing the label `{label}` has been removed.");
        Ok(())
    }

    /// Returns a mapping from labels to rules that target them.
    ///
    /// Creates a `BTreeMap` where each key is a label and each value is a cloned
    /// copy of the rule that targets that label. If multiple rules target the
    /// same label, only one will be present in the result (the last one processed).
    ///
    /// # Examples
    ///
    /// ```
    /// use cull_gmail::{Rules, Retention, MessageAge, EolAction};
    ///
    /// let mut rules = Rules::new();
    /// let retention = Retention::new(MessageAge::Days(30), false);
    /// rules.add_rule(retention, Some("test"), false);
    ///
    /// let label_map = rules.get_rules_by_label_for_action(EolAction::Trash);
    /// if let Some(rule) = label_map.get("test") {
    ///     println!("Rule for 'test' label: {}", rule.describe());
    /// }
    /// ```
    pub fn get_rules_by_label_for_action(&self, action: EolAction) -> BTreeMap<String, EolRule> {
        let mut rbl = BTreeMap::new();

        for rule in self.rules.values() {
            if rule.action() == Some(action) {
                for label in rule.labels() {
                    rbl.insert(label, rule.clone());
                }
            }
        }

        rbl
    }

    /// Adds a label to an existing rule and saves the configuration.
    ///
    /// Finds the rule with the specified ID and adds the given label to it.
    /// The configuration is automatically saved to disk after the change.
    ///
    /// # Arguments
    ///
    /// * `id` - The unique identifier of the rule to modify
    /// * `label` - The label to add to the rule
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use cull_gmail::Rules;
    ///
    /// let mut rules = Rules::load().expect("Failed to load rules");
    /// rules.add_label_to_rule(1, "new-label")
    ///      .expect("Failed to add label");
    /// ```
    ///
    /// # Errors
    ///
    /// * [`Error::RuleNotFound`] if no rule exists with the specified ID
    /// * IO errors from saving the configuration file
    pub fn add_label_to_rule(&mut self, id: usize, label: &str) -> Result<()> {
        let Some(rule) = self.rules.get_mut(id.to_string().as_str()) else {
            return Err(Error::RuleNotFound(id));
        };
        rule.add_label(label);
        self.save()?;
        println!("Label `{label}` added to rule `#{id}`");

        Ok(())
    }

    /// Removes a label from an existing rule and saves the configuration.
    ///
    /// Finds the rule with the specified ID and removes the given label from it.
    /// The configuration is automatically saved to disk after the change.
    ///
    /// # Arguments
    ///
    /// * `id` - The unique identifier of the rule to modify
    /// * `label` - The label to remove from the rule
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use cull_gmail::Rules;
    ///
    /// let mut rules = Rules::load().expect("Failed to load rules");
    /// rules.remove_label_from_rule(1, "old-label")
    ///      .expect("Failed to remove label");
    /// ```
    ///
    /// # Errors
    ///
    /// * [`Error::RuleNotFound`] if no rule exists with the specified ID
    /// * IO errors from saving the configuration file
    pub fn remove_label_from_rule(&mut self, id: usize, label: &str) -> Result<()> {
        let Some(rule) = self.rules.get_mut(id.to_string().as_str()) else {
            return Err(Error::RuleNotFound(id));
        };
        rule.remove_label(label);
        self.save()?;
        println!("Label `{label}` removed from rule `#{id}`");

        Ok(())
    }

    /// Sets the action for an existing rule and saves the configuration.
    ///
    /// Finds the rule with the specified ID and updates its action (trash or delete).
    /// The configuration is automatically saved to disk after the change.
    ///
    /// # Arguments
    ///
    /// * `id` - The unique identifier of the rule to modify
    /// * `action` - The new action to set (`Trash` or `Delete`)
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use cull_gmail::{Rules, EolAction};
    ///
    /// let mut rules = Rules::load().expect("Failed to load rules");
    /// rules.set_action_on_rule(1, &EolAction::Delete)
    ///      .expect("Failed to set action");
    /// ```
    ///
    /// # Errors
    ///
    /// * [`Error::RuleNotFound`] if no rule exists with the specified ID
    /// * IO errors from saving the configuration file
    pub fn set_action_on_rule(&mut self, id: usize, action: &EolAction) -> Result<()> {
        let Some(rule) = self.rules.get_mut(id.to_string().as_str()) else {
            return Err(Error::RuleNotFound(id));
        };
        rule.set_action(action);
        self.save()?;
        println!("Action set to `{action}` on rule `#{id}`");

        Ok(())
    }

    /// Saves the current rule configuration to disk.
    ///
    /// The configuration is saved as TOML format to `~/.cull-gmail/rules.toml`.
    /// The directory is created if it doesn't exist.
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use cull_gmail::{Rules, Retention, MessageAge};
    ///
    /// let mut rules = Rules::new();
    /// let retention = Retention::new(MessageAge::Days(30), false);
    /// rules.add_rule(retention, Some("test"), false);
    ///
    /// rules.save().expect("Failed to save configuration");
    /// ```
    ///
    /// # Errors
    ///
    /// * TOML serialization errors
    /// * IO errors when writing to the file system
    /// * File system permission errors
    pub fn save(&self) -> Result<()> {
        self.save_to(None)
    }

    /// Saves the current rule configuration to a specified path.
    ///
    /// If no path is provided, defaults to `~/.cull-gmail/rules.toml`.
    /// The directory is created if it doesn't exist.
    ///
    /// # Arguments
    ///
    /// * `path` - Optional path where the rules should be saved
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use cull_gmail::Rules;
    /// use std::path::Path;
    ///
    /// let rules = Rules::new();
    /// rules.save_to(Some(Path::new("/custom/path/rules.toml")))
    ///      .expect("Failed to save");
    /// ```
    ///
    /// # Errors
    ///
    /// * TOML serialization errors
    /// * IO errors when writing to the file system
    /// * File system permission errors
    pub fn save_to(&self, path: Option<&Path>) -> Result<()> {
        let save_path = if let Some(p) = path {
            p.to_path_buf()
        } else {
            let home_dir = env::home_dir().ok_or_else(|| {
                Error::HomeExpansionFailed("~/.cull-gmail/rules.toml".to_string())
            })?;
            home_dir.join(".cull-gmail/rules.toml")
        };

        // Ensure directory exists
        if let Some(parent) = save_path.parent() {
            fs::create_dir_all(parent)?;
        }

        let res = toml::to_string(self);
        log::trace!("toml conversion result: {res:#?}");

        if let Ok(output) = res {
            fs::write(&save_path, output)?;
            log::trace!("Config saved to {}", save_path.display());
        }

        Ok(())
    }

    /// Loads rule configuration from disk.
    ///
    /// Reads the configuration from `~/.cull-gmail/rules.toml` and deserializes
    /// it into a `Rules` instance.
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use cull_gmail::Rules;
    ///
    /// match Rules::load() {
    ///     Ok(rules) => {
    ///         println!("Loaded {} rules", rules.labels().len());
    ///         rules.list_rules().expect("Failed to list rules");
    ///     }
    ///     Err(e) => println!("Failed to load rules: {}", e),
    /// }
    /// ```
    ///
    /// # Errors
    ///
    /// * IO errors when reading from the file system
    /// * TOML parsing errors if the file is malformed
    /// * File not found errors if the configuration doesn't exist
    pub fn load() -> Result<Rules> {
        Self::load_from(None)
    }

    /// Loads rule configuration from a specified path.
    ///
    /// If no path is provided, defaults to `~/.cull-gmail/rules.toml`.
    ///
    /// # Arguments
    ///
    /// * `path` - Optional path to load rules from
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use cull_gmail::Rules;
    /// use std::path::Path;
    ///
    /// let rules = Rules::load_from(Some(Path::new("/custom/path/rules.toml")))
    ///     .expect("Failed to load rules");
    /// ```
    ///
    /// # Errors
    ///
    /// * IO errors when reading from the file system
    /// * TOML parsing errors if the file is malformed
    /// * File not found errors if the configuration doesn't exist
    pub fn load_from(path: Option<&Path>) -> Result<Rules> {
        let load_path = if let Some(p) = path {
            p.to_path_buf()
        } else {
            let home_dir = env::home_dir().ok_or_else(|| {
                Error::HomeExpansionFailed("~/.cull-gmail/rules.toml".to_string())
            })?;
            home_dir.join(".cull-gmail/rules.toml")
        };

        log::trace!("Loading config from {}", load_path.display());

        let input = read_to_string(load_path)?;
        let config = toml::from_str::<Rules>(&input)?;
        Ok(config)
    }

    /// Prints all configured rules to standard output.
    ///
    /// Each rule is printed on a separate line with its description,
    /// including the rule ID, action, and age criteria.
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use cull_gmail::Rules;
    ///
    /// let rules = Rules::new();
    /// rules.list_rules().expect("Failed to list rules");
    /// // Output:
    /// // Rule #1 is active on `retention/1-years` to move the message to trash if it is more than 1 years old.
    /// // Rule #2 is active on `retention/1-weeks` to move the message to trash if it is more than 1 weeks old.
    /// // ...
    /// ```
    ///
    /// # Errors
    ///
    /// This method currently always returns `Ok(())`, but the return type
    /// is `Result<()>` for consistency with other methods and future extensibility.
    pub fn list_rules(&self) -> Result<()> {
        for rule in self.rules.values() {
            println!("{rule}");
        }
        Ok(())
    }

    /// Validates all rules in the set and returns a list of issues found.
    ///
    /// Checks each rule for:
    /// - Non-empty label set
    /// - Valid retention period string (parseable as a `MessageAge`)
    /// - Valid action string (parseable as an `EolAction`)
    ///
    /// Also checks across rules for duplicate labels (the same label appearing
    /// in more than one rule).
    ///
    /// Returns an empty `Vec` if all rules are valid.
    ///
    /// # Examples
    ///
    /// ```
    /// use cull_gmail::Rules;
    ///
    /// let rules = Rules::new();
    /// let issues = rules.validate();
    /// assert!(issues.is_empty(), "Default rules should all be valid");
    /// ```
    pub fn validate(&self) -> Vec<ValidationIssue> {
        let mut issues = Vec::new();
        // Key: (label, action_str) — the same label in a Trash and a Delete rule is
        // intentional two-stage processing and must not be flagged as a duplicate.
        let mut seen_label_actions: BTreeMap<(String, String), usize> = BTreeMap::new();

        for rule in self.rules.values() {
            let id = rule.id();

            if rule.labels().is_empty() {
                issues.push(ValidationIssue::EmptyLabels { rule_id: id });
            }

            if MessageAge::parse(rule.retention()).is_none() {
                issues.push(ValidationIssue::InvalidRetention {
                    rule_id: id,
                    retention: rule.retention().to_string(),
                });
            }

            if rule.action().is_none() {
                issues.push(ValidationIssue::InvalidAction {
                    rule_id: id,
                    action: rule.action_str().to_string(),
                });
            }

            for label in rule.labels() {
                let key = (label.clone(), rule.action_str().to_lowercase());
                if let Some(&other_id) = seen_label_actions.get(&key) {
                    if other_id != id {
                        issues.push(ValidationIssue::DuplicateLabel {
                            label: label.clone(),
                        });
                    }
                } else {
                    seen_label_actions.insert(key, id);
                }
            }
        }

        issues
    }
}

/// An issue found during rules validation.
#[derive(Debug, PartialEq)]
pub enum ValidationIssue {
    /// A rule has no labels configured.
    EmptyLabels {
        /// The ID of the offending rule.
        rule_id: usize,
    },
    /// A rule has a retention string that cannot be parsed as a `MessageAge`.
    InvalidRetention {
        /// The ID of the offending rule.
        rule_id: usize,
        /// The unparseable retention string.
        retention: String,
    },
    /// A rule has an action string that cannot be parsed as an `EolAction`.
    InvalidAction {
        /// The ID of the offending rule.
        rule_id: usize,
        /// The unparseable action string.
        action: String,
    },
    /// The same label appears in more than one rule.
    DuplicateLabel {
        /// The duplicated label.
        label: String,
    },
}

impl fmt::Display for ValidationIssue {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ValidationIssue::EmptyLabels { rule_id } => {
                write!(f, "Rule #{rule_id}: no labels configured")
            }
            ValidationIssue::InvalidRetention { rule_id, retention } => {
                write!(f, "Rule #{rule_id}: invalid retention '{retention}'")
            }
            ValidationIssue::InvalidAction { rule_id, action } => {
                write!(f, "Rule #{rule_id}: invalid action '{action}'")
            }
            ValidationIssue::DuplicateLabel { label } => {
                write!(f, "Label '{label}' is used in multiple rules")
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test_utils::get_test_logger;
    use std::fs;

    fn setup_test_environment() {
        get_test_logger();
        // Clean up any existing test files
        let Some(home_dir) = env::home_dir() else {
            // Skip cleanup if home directory cannot be determined
            return;
        };
        let test_config_dir = home_dir.join(".cull-gmail");
        let test_rules_file = test_config_dir.join("rules.toml");
        if test_rules_file.exists() {
            let _ = fs::remove_file(&test_rules_file);
        }
    }

    #[test]
    fn test_rules_new_creates_default_rules() {
        setup_test_environment();

        let rules = Rules::new();

        // Should have some default rules
        let labels = rules.labels();
        assert!(
            !labels.is_empty(),
            "Default rules should create some labels"
        );

        // Should contain the expected retention labels
        assert!(labels.iter().any(|l| l.contains("retention/1-years")));
        assert!(labels.iter().any(|l| l.contains("retention/1-weeks")));
        assert!(labels.iter().any(|l| l.contains("retention/1-months")));
        assert!(labels.iter().any(|l| l.contains("retention/5-years")));
    }

    #[test]
    fn test_rules_default_same_as_new() {
        setup_test_environment();

        let rules_new = Rules::new();
        let rules_default = Rules::default();

        // Both should have the same number of rules
        assert_eq!(rules_new.labels().len(), rules_default.labels().len());
    }

    #[test]
    fn test_add_rule_with_label() {
        setup_test_environment();

        let mut rules = Rules::new();
        let initial_label_count = rules.labels().len();

        let retention = Retention::new(MessageAge::Days(30), false);
        rules.add_rule(retention, Some("test-label"), false);

        let labels = rules.labels();
        assert!(labels.contains(&"test-label".to_string()));
        assert_eq!(labels.len(), initial_label_count + 1);
    }

    #[test]
    fn test_add_rule_without_label() {
        setup_test_environment();

        let mut rules = Rules::new();
        let initial_label_count = rules.labels().len();

        let retention = Retention::new(MessageAge::Days(30), false);
        rules.add_rule(retention, None, false);

        // Should not add any new labels since no label specified and generate_label is false
        let labels = rules.labels();
        assert_eq!(labels.len(), initial_label_count);
    }

    #[test]
    fn test_add_rule_with_delete_action() {
        setup_test_environment();

        let mut rules = Rules::new();
        let retention = Retention::new(MessageAge::Days(7), false);
        rules.add_rule(retention, Some("delete-test"), true);

        let rules_by_label = rules.get_rules_by_label_for_action(EolAction::Delete);
        let rule = rules_by_label.get("delete-test").unwrap();
        assert_eq!(rule.action(), Some(EolAction::Delete));
    }

    #[test]
    fn test_add_duplicate_label_warns_and_skips() {
        setup_test_environment();

        let mut rules = Rules::new();
        let retention1 = Retention::new(MessageAge::Days(30), false);
        let retention2 = Retention::new(MessageAge::Days(60), false);

        rules.add_rule(retention1, Some("duplicate"), false);
        let initial_count = rules.labels().len();

        // Try to add another rule with the same label
        rules.add_rule(retention2, Some("duplicate"), false);

        // Should not increase the count of labels
        assert_eq!(rules.labels().len(), initial_count);
    }

    #[test]
    fn test_get_rule_existing() {
        setup_test_environment();

        let rules = Rules::new();

        // Default rules should have ID 1
        let rule = rules.get_rule(1);
        assert!(rule.is_some());
        assert_eq!(rule.unwrap().id(), 1);
    }

    #[test]
    fn test_get_rule_nonexistent() {
        setup_test_environment();

        let rules = Rules::new();

        // ID 999 should not exist
        let rule = rules.get_rule(999);
        assert!(rule.is_none());
    }

    #[test]
    fn test_labels_returns_all_labels() {
        setup_test_environment();

        let mut rules = Rules::new();
        let retention = Retention::new(MessageAge::Days(30), false);
        rules.add_rule(retention, Some("custom-label"), false);

        let labels = rules.labels();
        assert!(labels.contains(&"custom-label".to_string()));
    }

    #[test]
    fn test_get_rules_by_label() {
        setup_test_environment();

        let mut rules = Rules::new();
        let retention = Retention::new(MessageAge::Days(30), false);
        rules.add_rule(retention, Some("mapped-label"), false);

        let label_map = rules.get_rules_by_label_for_action(EolAction::Trash);
        let rule = label_map.get("mapped-label");
        assert!(rule.is_some());
        assert!(rule.unwrap().labels().contains(&"mapped-label".to_string()));
    }

    #[test]
    fn test_remove_rule_by_id_existing() {
        setup_test_environment();

        let mut rules = Rules::new();

        // Remove a default rule (assuming ID 1 exists)
        let result = rules.remove_rule_by_id(1);
        assert!(result.is_ok());

        // Rule should no longer exist
        assert!(rules.get_rule(1).is_none());
    }

    #[test]
    fn test_remove_rule_by_id_nonexistent() {
        setup_test_environment();

        let mut rules = Rules::new();

        // Removing non-existent rule should still succeed
        let result = rules.remove_rule_by_id(999);
        assert!(result.is_ok());
    }

    #[test]
    fn test_remove_rule_by_label_existing() {
        setup_test_environment();

        let mut rules = Rules::new();
        let retention = Retention::new(MessageAge::Days(30), false);
        rules.add_rule(retention, Some("remove-me"), false);

        let result = rules.remove_rule_by_label("remove-me");
        assert!(result.is_ok());

        // Label should no longer exist
        let labels = rules.labels();
        assert!(!labels.contains(&"remove-me".to_string()));
    }

    #[test]
    fn test_remove_rule_by_label_nonexistent() {
        setup_test_environment();

        let mut rules = Rules::new();

        let result = rules.remove_rule_by_label("nonexistent-label");
        assert!(result.is_err());

        match result.unwrap_err() {
            Error::LabelNotFoundInRules(label) => {
                assert_eq!(label, "nonexistent-label");
            }
            _ => panic!("Expected LabelNotFoundInRules error"),
        }
    }

    #[test]
    fn test_add_label_to_rule_existing_rule() {
        setup_test_environment();

        let mut rules = Rules::new();

        // Add label to existing rule (ID 1)
        let result = rules.add_label_to_rule(1, "new-label");
        assert!(result.is_ok());

        let rule = rules.get_rule(1).unwrap();
        assert!(rule.labels().contains(&"new-label".to_string()));
    }

    #[test]
    fn test_add_label_to_rule_nonexistent_rule() {
        setup_test_environment();

        let mut rules = Rules::new();

        let result = rules.add_label_to_rule(999, "new-label");
        assert!(result.is_err());

        match result.unwrap_err() {
            Error::RuleNotFound(id) => {
                assert_eq!(id, 999);
            }
            _ => panic!("Expected RuleNotFound error"),
        }
    }

    #[test]
    fn test_remove_label_from_rule_existing() {
        setup_test_environment();

        let mut rules = Rules::new();

        // First add a label
        let result = rules.add_label_to_rule(1, "temp-label");
        assert!(result.is_ok());

        // Then remove it
        let result = rules.remove_label_from_rule(1, "temp-label");
        assert!(result.is_ok());

        let rule = rules.get_rule(1).unwrap();
        assert!(!rule.labels().contains(&"temp-label".to_string()));
    }

    #[test]
    fn test_remove_label_from_rule_nonexistent_rule() {
        setup_test_environment();

        let mut rules = Rules::new();

        let result = rules.remove_label_from_rule(999, "any-label");
        assert!(result.is_err());

        match result.unwrap_err() {
            Error::RuleNotFound(id) => {
                assert_eq!(id, 999);
            }
            _ => panic!("Expected RuleNotFound error"),
        }
    }

    #[test]
    fn test_set_action_on_rule_existing() {
        setup_test_environment();

        let mut rules = Rules::new();

        // Set action to Delete
        let result = rules.set_action_on_rule(1, &EolAction::Delete);
        assert!(result.is_ok());

        let rule = rules.get_rule(1).unwrap();
        assert_eq!(rule.action(), Some(EolAction::Delete));
    }

    #[test]
    fn test_set_action_on_rule_nonexistent() {
        setup_test_environment();

        let mut rules = Rules::new();

        let result = rules.set_action_on_rule(999, &EolAction::Delete);
        assert!(result.is_err());

        match result.unwrap_err() {
            Error::RuleNotFound(id) => {
                assert_eq!(id, 999);
            }
            _ => panic!("Expected RuleNotFound error"),
        }
    }

    #[test]
    fn test_list_rules_succeeds() {
        setup_test_environment();

        let rules = Rules::new();

        // Should not panic or return error
        let result = rules.list_rules();
        assert!(result.is_ok());
    }

    // --- validate() tests ---

    #[test]
    fn test_validate_default_rules_are_valid() {
        setup_test_environment();
        let rules = Rules::new();
        let issues = rules.validate();
        assert!(
            issues.is_empty(),
            "Default rules should be valid, got: {issues:?}"
        );
    }

    #[test]
    fn test_validate_empty_labels_reported() {
        setup_test_environment();
        let toml_str = r#"
[rules."1"]
id = 1
retention = "d:30"
labels = []
action = "Trash"
"#;
        let rules: Rules = toml::from_str(toml_str).unwrap();
        let issues = rules.validate();
        assert!(
            issues
                .iter()
                .any(|i| matches!(i, ValidationIssue::EmptyLabels { rule_id: 1 })),
            "Expected EmptyLabels for rule #1, got: {issues:?}"
        );
    }

    #[test]
    fn test_validate_invalid_retention_reported() {
        setup_test_environment();
        let toml_str = r#"
[rules."1"]
id = 1
retention = "invalid"
labels = ["some-label"]
action = "Trash"
"#;
        let rules: Rules = toml::from_str(toml_str).unwrap();
        let issues = rules.validate();
        assert!(
            issues
                .iter()
                .any(|i| matches!(i, ValidationIssue::InvalidRetention { rule_id: 1, .. })),
            "Expected InvalidRetention for rule #1, got: {issues:?}"
        );
    }

    #[test]
    fn test_validate_empty_retention_reported() {
        setup_test_environment();
        let toml_str = r#"
[rules."1"]
id = 1
retention = ""
labels = ["some-label"]
action = "Trash"
"#;
        let rules: Rules = toml::from_str(toml_str).unwrap();
        let issues = rules.validate();
        assert!(
            issues
                .iter()
                .any(|i| matches!(i, ValidationIssue::InvalidRetention { rule_id: 1, .. })),
            "Expected InvalidRetention for empty retention in rule #1, got: {issues:?}"
        );
    }

    #[test]
    fn test_validate_invalid_action_reported() {
        setup_test_environment();
        let toml_str = r#"
[rules."1"]
id = 1
retention = "d:30"
labels = ["some-label"]
action = "invalid-action"
"#;
        let rules: Rules = toml::from_str(toml_str).unwrap();
        let issues = rules.validate();
        assert!(
            issues
                .iter()
                .any(|i| matches!(i, ValidationIssue::InvalidAction { rule_id: 1, .. })),
            "Expected InvalidAction for rule #1, got: {issues:?}"
        );
    }

    #[test]
    fn test_validate_duplicate_label_reported() {
        setup_test_environment();
        let toml_str = r#"
[rules."1"]
id = 1
retention = "d:30"
labels = ["shared-label"]
action = "Trash"

[rules."2"]
id = 2
retention = "d:60"
labels = ["shared-label"]
action = "Trash"
"#;
        let rules: Rules = toml::from_str(toml_str).unwrap();
        let issues = rules.validate();
        assert!(
            issues.iter().any(|i| matches!(
                i,
                ValidationIssue::DuplicateLabel { label }
                if label == "shared-label"
            )),
            "Expected DuplicateLabel for 'shared-label', got: {issues:?}"
        );
    }

    #[test]
    fn test_validate_same_label_different_actions_not_duplicate() {
        setup_test_environment();
        // A label in a Trash rule AND a Delete rule is intentional two-stage processing.
        let toml_str = r#"
[rules."1"]
id = 1
retention = "w:1"
labels = ["Development/Notifications"]
action = "Trash"

[rules."2"]
id = 2
retention = "w:2"
labels = ["Development/Notifications"]
action = "Delete"
"#;
        let rules: Rules = toml::from_str(toml_str).unwrap();
        let issues = rules.validate();
        assert!(
            !issues
                .iter()
                .any(|i| matches!(i, ValidationIssue::DuplicateLabel { .. })),
            "Same label with different actions should NOT be flagged as duplicate, got: {issues:?}"
        );
    }

    #[test]
    fn test_validate_multiple_issues_collected() {
        setup_test_environment();
        let toml_str = r#"
[rules."1"]
id = 1
retention = ""
labels = []
action = "bad"
"#;
        let rules: Rules = toml::from_str(toml_str).unwrap();
        let issues = rules.validate();
        // All three issues should be present for the one rule
        assert!(
            issues
                .iter()
                .any(|i| matches!(i, ValidationIssue::EmptyLabels { .. })),
            "Expected EmptyLabels"
        );
        assert!(
            issues
                .iter()
                .any(|i| matches!(i, ValidationIssue::InvalidRetention { .. })),
            "Expected InvalidRetention"
        );
        assert!(
            issues
                .iter()
                .any(|i| matches!(i, ValidationIssue::InvalidAction { .. })),
            "Expected InvalidAction"
        );
    }

    // Integration tests for save/load would require file system setup
    // These are marked as ignore to avoid interference with actual config files
    #[test]
    #[ignore = "Integration test that modifies file system"]
    fn test_save_and_load_roundtrip() {
        setup_test_environment();

        let mut rules = Rules::new();
        let retention = Retention::new(MessageAge::Days(30), false);
        rules.add_rule(retention, Some("save-test"), false);

        // Save to disk
        let save_result = rules.save();
        assert!(save_result.is_ok());

        // Load from disk
        let loaded_rules = Rules::load();
        assert!(loaded_rules.is_ok());

        let loaded_rules = loaded_rules.unwrap();
        let labels = loaded_rules.labels();
        assert!(labels.contains(&"save-test".to_string()));
    }
}