domainstack 1.1.1

use crate::{Meta, Path, Violation};
use smallvec::SmallVec;
use std::collections::BTreeMap;

/// Represents a collection of validation violations.
///
/// This type aggregates all validation errors that occur during validation of a domain object.
/// It supports merging errors from multiple fields and nested structures.
///
/// # Examples
///
/// ```
/// use domainstack::{ValidationError, Path};
///
/// let mut err = ValidationError::new();
/// err.push("email", "invalid_email", "Invalid email format");
/// err.push("age", "out_of_range", "Must be between 18 and 120");
///
/// assert_eq!(err.violations.len(), 2);
/// assert!(!err.is_empty());
/// ```
///
/// ## Nested Errors
///
/// ```
/// use domainstack::{ValidationError, Path};
///
/// let mut child_err = ValidationError::new();
/// child_err.push("value", "invalid_email", "Invalid email format");
///
/// let mut parent_err = ValidationError::new();
/// parent_err.merge_prefixed("email", child_err);
///
/// // Error path becomes "email.value"
/// assert_eq!(parent_err.violations[0].path.to_string(), "email.value");
/// ```
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ValidationError {
    pub violations: SmallVec<[Violation; 4]>,
}

impl ValidationError {
    pub fn new() -> Self {
        Self {
            violations: SmallVec::new(),
        }
    }

    pub fn is_empty(&self) -> bool {
        self.violations.is_empty()
    }

    pub fn single(path: impl Into<Path>, code: &'static str, message: impl Into<String>) -> Self {
        let mut err = Self::new();
        err.push(path, code, message);
        err
    }

    pub fn push(&mut self, path: impl Into<Path>, code: &'static str, message: impl Into<String>) {
        self.violations.push(Violation {
            path: path.into(),
            code,
            message: message.into(),
            meta: Meta::default(),
        });
    }

    pub fn extend(&mut self, other: ValidationError) {
        self.violations.extend(other.violations);
    }

    /// Merges violations from another error with a path prefix.
    ///
    /// This is optimized to avoid cloning the prefix for each violation.
    /// The prefix segments are collected once and reused for all violations.
    ///
    /// # Performance
    /// - Old: O(n) prefix clones where n = number of violations
    /// - New: O(1) prefix collection + O(n * m) segment clones where m = avg segments per path
    ///
    /// For typical use cases (< 10 violations), this optimization reduces allocations significantly.
    pub fn merge_prefixed(&mut self, prefix: impl Into<Path>, other: ValidationError) {
        let prefix = prefix.into();

        // Collect prefix segments once to avoid repeated cloning
        let prefix_segments = prefix.segments().to_vec();

        for mut violation in other.violations {
            // Build new path from prefix segments + violation segments
            let mut new_path = Path::root();

            // Add prefix segments
            for seg in &prefix_segments {
                match seg {
                    crate::PathSegment::Field(name) => new_path.push_field(name.clone()),
                    crate::PathSegment::Index(idx) => new_path.push_index(*idx),
                }
            }

            // Add violation's original path segments
            for seg in violation.path.segments() {
                match seg {
                    crate::PathSegment::Field(name) => new_path.push_field(name.clone()),
                    crate::PathSegment::Index(idx) => new_path.push_index(*idx),
                }
            }

            violation.path = new_path;
            self.violations.push(violation);
        }
    }

    /// Returns a map of field paths to error messages.
    ///
    /// **⚠️ Warning**: This method only returns messages and **loses error codes and metadata**.
    /// For complete error information including codes (needed for proper error classification,
    /// client-side handling, and internationalization), use [`field_violations_map()`](Self::field_violations_map) instead.
    ///
    /// # Examples
    ///
    /// ```
    /// use domainstack::ValidationError;
    ///
    /// let mut err = ValidationError::new();
    /// err.push("email", "invalid_format", "Invalid email format");
    /// err.push("email", "too_long", "Email too long");
    ///
    /// let map = err.field_errors_map();
    /// assert_eq!(map.get("email").unwrap().len(), 2);
    /// // Note: Error codes "invalid_format" and "too_long" are lost!
    /// ```
    #[deprecated(
        since = "0.5.0",
        note = "Use `field_violations_map()` instead to preserve error codes and metadata. \
                This method only returns messages and loses important error information."
    )]
    pub fn field_errors_map(&self) -> BTreeMap<String, Vec<String>> {
        let mut map = BTreeMap::new();
        for violation in &self.violations {
            map.entry(violation.path.to_string())
                .or_insert_with(Vec::new)
                .push(violation.message.clone());
        }
        map
    }

    pub fn field_violations_map(&self) -> BTreeMap<String, Vec<&Violation>> {
        let mut map = BTreeMap::new();
        for violation in &self.violations {
            map.entry(violation.path.to_string())
                .or_insert_with(Vec::new)
                .push(violation);
        }
        map
    }

    /// Returns a new ValidationError with all paths prefixed.
    ///
    /// # Performance
    /// This method is optimized to collect prefix segments once and reuse them,
    /// avoiding repeated cloning of the prefix path.
    pub fn prefixed(self, prefix: impl Into<Path>) -> Self {
        let prefix = prefix.into();

        // Collect prefix segments once to avoid repeated cloning
        let prefix_segments: Vec<_> = prefix.segments().to_vec();

        let violations = self
            .violations
            .into_iter()
            .map(|mut v| {
                let mut new_path = Path::root();

                // Add prefix segments
                for seg in &prefix_segments {
                    match seg {
                        crate::PathSegment::Field(name) => new_path.push_field(name.clone()),
                        crate::PathSegment::Index(idx) => new_path.push_index(*idx),
                    }
                }

                // Add violation's original path segments
                for seg in v.path.segments() {
                    match seg {
                        crate::PathSegment::Field(name) => new_path.push_field(name.clone()),
                        crate::PathSegment::Index(idx) => new_path.push_index(*idx),
                    }
                }

                v.path = new_path;
                v
            })
            .collect();

        Self { violations }
    }

    /// Transform all violation messages using the provided function.
    ///
    /// This is useful for internationalization (i18n), message formatting,
    /// or any other message transformation needs.
    ///
    /// # Examples
    ///
    /// ```
    /// use domainstack::ValidationError;
    ///
    /// let mut err = ValidationError::new();
    /// err.push("email", "invalid", "Invalid email");
    /// err.push("age", "too_young", "Must be 18+");
    ///
    /// // Add prefix to all messages
    /// let err = err.map_messages(|msg| format!("Error: {}", msg));
    ///
    /// assert_eq!(err.violations[0].message, "Error: Invalid email");
    /// assert_eq!(err.violations[1].message, "Error: Must be 18+");
    /// ```
    ///
    /// ## Internationalization Example
    ///
    /// ```
    /// use domainstack::ValidationError;
    ///
    /// let mut err = ValidationError::new();
    /// err.push("email", "invalid_email", "Invalid email format");
    ///
    /// // Translate messages based on error code
    /// let err = err.map_messages(|msg| {
    ///     // In a real app, this would use error codes for translation
    ///     "Formato de email inválido".to_string()
    /// });
    ///
    /// assert_eq!(err.violations[0].message, "Formato de email inválido");
    /// ```
    pub fn map_messages<F>(mut self, f: F) -> Self
    where
        F: Fn(String) -> String,
    {
        for violation in &mut self.violations {
            let old_message = std::mem::take(&mut violation.message);
            violation.message = f(old_message);
        }
        self
    }

    /// Filter violations based on a predicate.
    ///
    /// This is useful for removing certain types of errors based on custom criteria.
    ///
    /// # Examples
    ///
    /// ```
    /// use domainstack::ValidationError;
    ///
    /// let mut err = ValidationError::new();
    /// err.push("email", "warning", "Email format questionable");
    /// err.push("age", "invalid", "Age is required");
    /// err.push("name", "warning", "Name seems unusual");
    ///
    /// // Remove all warnings, keep only errors
    /// let err = err.filter(|v| v.code != "warning");
    ///
    /// assert_eq!(err.violations.len(), 1);
    /// assert_eq!(err.violations[0].code, "invalid");
    /// ```
    pub fn filter<F>(self, f: F) -> Self
    where
        F: Fn(&Violation) -> bool,
    {
        let violations = self.violations.into_iter().filter(|v| f(v)).collect();
        Self { violations }
    }
}

impl std::fmt::Display for ValidationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if self.violations.is_empty() {
            write!(f, "No validation errors")
        } else if self.violations.len() == 1 {
            write!(f, "Validation error: {}", self.violations[0].message)
        } else {
            write!(f, "Validation failed with {} errors", self.violations.len())
        }
    }
}

impl std::error::Error for ValidationError {}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new() {
        let err = ValidationError::new();
        assert!(err.is_empty());
        assert_eq!(err.violations.len(), 0);
    }

    #[test]
    fn test_default() {
        let err = ValidationError::default();
        assert!(err.is_empty());
    }

    #[test]
    fn test_is_empty() {
        let mut err = ValidationError::new();
        assert!(err.is_empty());

        err.push("email", "invalid", "Invalid email");
        assert!(!err.is_empty());
    }

    #[test]
    fn test_single() {
        let err = ValidationError::single("email", "invalid_email", "Invalid email format");

        assert!(!err.is_empty());
        assert_eq!(err.violations.len(), 1);
        assert_eq!(err.violations[0].code, "invalid_email");
        assert_eq!(err.violations[0].message, "Invalid email format");
        assert_eq!(err.violations[0].path.to_string(), "email");
    }

    #[test]
    fn test_push() {
        let mut err = ValidationError::new();
        err.push("email", "invalid_email", "Invalid email");
        err.push("age", "out_of_range", "Age out of range");

        assert_eq!(err.violations.len(), 2);
        assert_eq!(err.violations[0].path.to_string(), "email");
        assert_eq!(err.violations[1].path.to_string(), "age");
    }

    #[test]
    fn test_extend() {
        let mut err1 = ValidationError::new();
        err1.push("email", "invalid", "Invalid email");

        let mut err2 = ValidationError::new();
        err2.push("age", "invalid", "Invalid age");

        err1.extend(err2);
        assert_eq!(err1.violations.len(), 2);
    }

    #[test]
    fn test_merge_prefixed() {
        let mut parent_err = ValidationError::new();

        let mut child_err = ValidationError::new();
        child_err.push("email", "invalid", "Invalid email");

        parent_err.merge_prefixed("guest", child_err);

        assert_eq!(parent_err.violations.len(), 1);
        assert_eq!(parent_err.violations[0].path.to_string(), "guest.email");
    }

    #[test]
    fn test_merge_prefixed_nested() {
        let mut root_err = ValidationError::new();

        let mut nested_err = ValidationError::new();
        nested_err.push(
            Path::root().field("guests").index(0).field("email"),
            "invalid",
            "Invalid email",
        );

        root_err.merge_prefixed("booking", nested_err);

        assert_eq!(root_err.violations.len(), 1);
        assert_eq!(
            root_err.violations[0].path.to_string(),
            "booking.guests[0].email"
        );
    }

    #[test]
    #[allow(deprecated)]
    fn test_field_errors_map() {
        let mut err = ValidationError::new();
        err.push("email", "invalid", "Invalid email");
        err.push("email", "too_long", "Email too long");
        err.push("age", "out_of_range", "Age out of range");

        let map = err.field_errors_map();

        assert_eq!(map.len(), 2);
        assert_eq!(map.get("email").unwrap().len(), 2);
        assert_eq!(map.get("age").unwrap().len(), 1);
        assert!(map
            .get("email")
            .unwrap()
            .contains(&"Invalid email".to_string()));
        assert!(map
            .get("email")
            .unwrap()
            .contains(&"Email too long".to_string()));
    }

    #[test]
    fn test_display_empty() {
        let err = ValidationError::new();
        assert_eq!(err.to_string(), "No validation errors");
    }

    #[test]
    fn test_display_single() {
        let err = ValidationError::single("email", "invalid", "Invalid email format");
        assert_eq!(err.to_string(), "Validation error: Invalid email format");
    }

    #[test]
    fn test_display_multiple() {
        let mut err = ValidationError::new();
        err.push("email", "invalid", "Invalid email");
        err.push("age", "invalid", "Invalid age");

        assert_eq!(err.to_string(), "Validation failed with 2 errors");
    }

    #[test]
    fn test_validation_error_equality() {
        let mut err1 = ValidationError::new();
        err1.push("email", "invalid", "Invalid email");
        err1.push("age", "out_of_range", "Age out of range");

        let mut err2 = ValidationError::new();
        err2.push("email", "invalid", "Invalid email");
        err2.push("age", "out_of_range", "Age out of range");

        assert_eq!(err1, err2);

        let mut err3 = ValidationError::new();
        err3.push("email", "invalid", "Invalid email");

        assert_ne!(err1, err3);
    }

    #[test]
    fn test_validation_error_equality_empty() {
        let err1 = ValidationError::new();
        let err2 = ValidationError::default();
        assert_eq!(err1, err2);
    }

    #[test]
    fn test_map_messages() {
        let mut err = ValidationError::new();
        err.push("email", "invalid", "Invalid email");
        err.push("age", "out_of_range", "Age out of range");

        let err = err.map_messages(|msg| format!("Error: {}", msg));

        assert_eq!(err.violations[0].message, "Error: Invalid email");
        assert_eq!(err.violations[1].message, "Error: Age out of range");
    }

    #[test]
    fn test_map_messages_preserves_other_fields() {
        let mut err = ValidationError::new();
        err.push("email", "invalid", "Invalid email");

        let err = err.map_messages(|msg| format!("Modified: {}", msg));

        assert_eq!(err.violations[0].code, "invalid");
        assert_eq!(err.violations[0].path.to_string(), "email");
        assert_eq!(err.violations[0].message, "Modified: Invalid email");
    }

    #[test]
    fn test_filter() {
        let mut err = ValidationError::new();
        err.push("email", "warning", "Email questionable");
        err.push("age", "invalid", "Age required");
        err.push("name", "warning", "Name unusual");

        let err = err.filter(|v| v.code != "warning");

        assert_eq!(err.violations.len(), 1);
        assert_eq!(err.violations[0].code, "invalid");
        assert_eq!(err.violations[0].path.to_string(), "age");
    }

    #[test]
    fn test_filter_all() {
        let mut err = ValidationError::new();
        err.push("email", "warning", "Email questionable");
        err.push("name", "warning", "Name unusual");

        let err = err.filter(|v| v.code != "warning");

        assert!(err.is_empty());
    }

    #[test]
    fn test_filter_none() {
        let mut err = ValidationError::new();
        err.push("email", "invalid", "Invalid email");
        err.push("age", "out_of_range", "Age out of range");

        let err = err.filter(|_| true);

        assert_eq!(err.violations.len(), 2);
    }
}