cfgmatic-source 2.2.0

//! Source coordinator for managing multiple configuration sources.
//!
//! This module provides the [`SourceCoordinator`] service which coordinates
//! multiple configuration sources with priorities and merge strategies.
//!
//! # Example
//!
//! ```rust,ignore
//! use cfgmatic_source::application::SourceCoordinator;
//! use cfgmatic_source::infrastructure::{FileSource, EnvSource};
//!
//! let coordinator = SourceCoordinator::builder()
//!     .add_source(file_source, 10)
//!     .add_source(env_source, 20)
//!     .build();
//!
//! let result = coordinator.load()?;
//! println!("Loaded from {} sources", result.loaded_count());
//! ```

use std::collections::BTreeMap;

use serde::de::DeserializeOwned;

use crate::config::{LoadOptions, MergeStrategy};
use crate::domain::{ParsedContent, Result, Source, SourceError};

/// Result of loading configuration from multiple sources.
#[derive(Debug, Clone)]
pub struct LoadResult {
    /// Merged configuration content.
    pub content: ParsedContent,

    /// Number of sources that were successfully loaded.
    pub loaded_count: usize,

    /// Names of sources that were loaded.
    pub loaded_sources: Vec<String>,

    /// Names of sources that failed (if not fail-fast).
    pub failed_sources: Vec<(String, String)>,

    /// Total processing time in milliseconds.
    pub processing_time_ms: u64,
}

impl LoadResult {
    /// Create a new load result.
    #[must_use]
    pub fn new(content: ParsedContent) -> Self {
        Self {
            content,
            loaded_count: 0,
            loaded_sources: Vec::new(),
            failed_sources: Vec::new(),
            processing_time_ms: 0,
        }
    }

    /// Get the merged configuration content.
    #[must_use]
    pub fn content(&self) -> &ParsedContent {
        &self.content
    }

    /// Get the number of successfully loaded sources.
    #[must_use]
    pub fn loaded_count(&self) -> usize {
        self.loaded_count
    }

    /// Check if any sources failed.
    #[must_use]
    pub fn has_failures(&self) -> bool {
        !self.failed_sources.is_empty()
    }

    /// Convert to a specific type.
    ///
    /// # Errors
    ///
    /// Returns an error if deserialization fails.
    pub fn to_type<T: DeserializeOwned>(&self) -> Result<T> {
        self.content.to_type()
    }
}

/// A boxed source with its priority.
type BoxedSource = Box<dyn Source>;

/// Entry in the source registry.
struct SourceEntry {
    source: BoxedSource,
    priority: i32,
    order: usize,
}

impl std::fmt::Debug for SourceEntry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SourceEntry")
            .field("priority", &self.priority)
            .field("order", &self.order)
            .field("display_name", &self.source.display_name())
            .finish()
    }
}

/// Service for coordinating multiple configuration sources.
///
/// The SourceCoordinator manages multiple sources, loads them according
/// to their priorities, and merges the results.
pub struct SourceCoordinator {
    /// Registered sources with their priorities.
    sources: Vec<SourceEntry>,

    /// Loading options.
    options: LoadOptions,

    /// Cache for loaded content.
    cache: BTreeMap<String, ParsedContent>,

    /// Whether caching is enabled.
    cache_enabled: bool,
}

impl SourceCoordinator {
    /// Create a new empty coordinator.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Create a builder for constructing a SourceCoordinator.
    #[must_use]
    pub fn builder() -> SourceCoordinatorBuilder {
        SourceCoordinatorBuilder::new()
    }

    /// Add a source with a priority.
    ///
    /// Higher priority sources override lower priority ones.
    pub fn add_source<S: Source + 'static>(&mut self, source: S, priority: i32) -> &mut Self {
        let entry = SourceEntry {
            source: Box::new(source),
            priority,
            order: self.sources.len(),
        };
        self.sources.push(entry);
        self
    }

    /// Get the number of registered sources.
    #[must_use]
    pub fn source_count(&self) -> usize {
        self.sources.len()
    }

    /// Check if there are any sources registered.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.sources.is_empty()
    }

    /// Clear all sources.
    pub fn clear(&mut self) {
        self.sources.clear();
        self.cache.clear();
    }

    /// Clear the cache.
    pub fn clear_cache(&mut self) {
        self.cache.clear();
    }

    /// Load configuration from all sources.
    ///
    /// Sources are loaded in priority order (highest first) and merged.
    ///
    /// # Errors
    ///
    /// Returns an error if a required source fails and fail_fast is enabled.
    pub fn load(&mut self) -> Result<LoadResult> {
        let start = std::time::Instant::now();

        // Sort sources by priority (descending)
        let mut sorted_sources: Vec<_> = self.sources.iter().collect();
        sorted_sources.sort_by(|a, b| {
            b.priority
                .cmp(&a.priority)
                .then_with(|| a.order.cmp(&b.order))
        });

        let mut contents = Vec::new();
        let mut loaded_sources = Vec::new();
        let mut failed_sources = Vec::new();
        let mut loaded_count = 0;

        for entry in sorted_sources {
            let name = entry.source.display_name();

            // Check cache first
            if self.cache_enabled {
                if let Some(cached) = self.cache.get(&name) {
                    contents.push(cached.clone());
                    loaded_sources.push(name.clone());
                    loaded_count += 1;
                    continue;
                }
            }

            // Load from source
            match self.load_source(&*entry.source) {
                Ok(content) => {
                    if self.cache_enabled {
                        self.cache.insert(name.clone(), content.clone());
                    }
                    contents.push(content);
                    loaded_sources.push(name.clone());
                    loaded_count += 1;
                }
                Err(e) => {
                    if entry.source.is_optional() && self.options.ignore_optional_missing {
                        continue;
                    }
                    if self.options.fail_fast {
                        return Err(e);
                    }
                    failed_sources.push((name, e.to_string()));
                }
            }
        }

        // Check if all sources failed
        if contents.is_empty() && !failed_sources.is_empty() {
            let error_messages: Vec<String> = failed_sources
                .iter()
                .map(|(name, e)| format!("{}: {}", name, e))
                .collect();
            return Err(SourceError::custom(&error_messages.join(", ")));
        }

        // Merge contents
        let merged = self.merge_contents(contents);

        Ok(LoadResult {
            content: merged,
            loaded_count,
            loaded_sources,
            failed_sources,
            processing_time_ms: start.elapsed().as_millis() as u64,
        })
    }

    /// Load from a single source.
    fn load_source(&self, source: &dyn Source) -> Result<ParsedContent> {
        source.validate()?;
        let raw = source.load_raw()?;

        // Try to detect format
        let format = source.detect_format();
        if let Some(fmt) = format {
            let content = raw.as_str()?;
            return fmt.parse(content.as_ref());
        }

        // Try to detect from content
        let content = raw.as_str()?;
        if let Some(fmt) = crate::domain::Format::from_content(content.as_ref()) {
            return fmt.parse(content.as_ref());
        }

        Err(SourceError::unsupported("cannot detect format"))
    }

    /// Merge multiple contents according to the merge strategy.
    fn merge_contents(&self, contents: Vec<ParsedContent>) -> ParsedContent {
        if contents.is_empty() {
            return ParsedContent::Null;
        }

        let strategy = self.options.merge_strategy;

        contents
            .into_iter()
            .reduce(|acc, content| match strategy {
                MergeStrategy::Replace => content,
                MergeStrategy::Deep | MergeStrategy::Shallow | MergeStrategy::Strict => {
                    acc.merge(&content)
                }
            })
            .unwrap_or(ParsedContent::Null)
    }

    /// Load and convert to a specific type.
    ///
    /// # Errors
    ///
    /// Returns an error if loading or deserialization fails.
    pub fn load_as<T: DeserializeOwned>(&mut self) -> Result<T> {
        let result = self.load()?;
        result.to_type()
    }

    /// Reload all sources, clearing the cache.
    ///
    /// # Errors
    ///
    /// Returns an error if loading fails.
    pub fn reload(&mut self) -> Result<LoadResult> {
        self.clear_cache();
        self.load()
    }
}

impl Default for SourceCoordinator {
    fn default() -> Self {
        Self {
            sources: Vec::new(),
            options: LoadOptions::default(),
            cache: BTreeMap::new(),
            cache_enabled: true,
        }
    }
}

impl std::fmt::Debug for SourceCoordinator {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SourceCoordinator")
            .field("source_count", &self.sources.len())
            .field("options", &self.options)
            .field("cache_enabled", &self.cache_enabled)
            .finish()
    }
}

/// Builder for [`SourceCoordinator`].
#[derive(Default)]
pub struct SourceCoordinatorBuilder {
    sources: Vec<SourceEntry>,
    options: Option<LoadOptions>,
    cache_enabled: Option<bool>,
}

impl SourceCoordinatorBuilder {
    /// Create a new builder.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Add a source with a priority.
    #[must_use]
    pub fn add_source<S: Source + 'static>(mut self, source: S, priority: i32) -> Self {
        let entry = SourceEntry {
            source: Box::new(source),
            priority,
            order: self.sources.len(),
        };
        self.sources.push(entry);
        self
    }

    /// Set the load options.
    #[must_use]
    pub fn options(mut self, options: LoadOptions) -> Self {
        self.options = Some(options);
        self
    }

    /// Set the merge strategy.
    #[must_use]
    pub fn merge_strategy(mut self, strategy: MergeStrategy) -> Self {
        let mut options = self.options.unwrap_or_default();
        options.merge_strategy = strategy;
        self.options = Some(options);
        self
    }

    /// Set whether to fail fast on errors.
    #[must_use]
    pub fn fail_fast(mut self, fail_fast: bool) -> Self {
        let mut options = self.options.unwrap_or_default();
        options.fail_fast = fail_fast;
        self.options = Some(options);
        self
    }

    /// Set whether to enable caching.
    #[must_use]
    pub fn cache_enabled(mut self, enabled: bool) -> Self {
        self.cache_enabled = Some(enabled);
        self
    }

    /// Build the SourceCoordinator.
    #[must_use]
    pub fn build(self) -> SourceCoordinator {
        SourceCoordinator {
            sources: self.sources,
            options: self.options.unwrap_or_default(),
            cache: BTreeMap::new(),
            cache_enabled: self.cache_enabled.unwrap_or(true),
        }
    }
}

impl std::fmt::Debug for SourceCoordinatorBuilder {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SourceCoordinatorBuilder")
            .field("source_count", &self.sources.len())
            .field("options", &self.options)
            .field("cache_enabled", &self.cache_enabled)
            .finish()
    }
}

#[cfg(feature = "async")]
mod async_impl {
    use super::*;

    impl SourceCoordinator {
        /// Load configuration from all sources asynchronously.
        ///
        /// # Errors
        ///
        /// Returns an error if a required source fails and fail_fast is enabled.
        pub async fn load_async(&mut self) -> Result<LoadResult> {
            // Async implementation would use tokio::spawn for parallel loading
            // This is a placeholder that delegates to sync version
            self.load()
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::domain::{Format, RawContent, SourceKind, SourceMetadata};

    /// Test source implementation.
    struct TestSource {
        content: String,
        format: Format,
        optional: bool,
        name: String,
        priority_val: i32,
    }

    impl TestSource {
        fn new(name: &str, content: &str, format: Format) -> Self {
            Self {
                name: name.to_string(),
                content: content.to_string(),
                format,
                optional: false,
                priority_val: 0,
            }
        }

        fn with_optional(mut self, optional: bool) -> Self {
            self.optional = optional;
            self
        }
    }

    impl Source for TestSource {
        fn kind(&self) -> SourceKind {
            SourceKind::Memory
        }

        fn metadata(&self) -> SourceMetadata {
            SourceMetadata::new(&self.name)
        }

        fn load_raw(&self) -> Result<RawContent> {
            Ok(RawContent::from_string(&self.content))
        }

        fn detect_format(&self) -> Option<Format> {
            if self.format == Format::Unknown {
                None
            } else {
                Some(self.format)
            }
        }

        fn is_optional(&self) -> bool {
            self.optional
        }
    }

    #[test]
    fn test_load_result_new() {
        let result = LoadResult::new(ParsedContent::Null);
        assert!(result.content().is_null());
        assert_eq!(result.loaded_count(), 0);
        assert!(!result.has_failures());
    }

    #[test]
    fn test_source_coordinator_new() {
        let coordinator = SourceCoordinator::new();
        assert!(coordinator.is_empty());
        assert_eq!(coordinator.source_count(), 0);
    }

    #[test]
    fn test_source_coordinator_builder() {
        let coordinator = SourceCoordinator::builder()
            .merge_strategy(MergeStrategy::Deep)
            .fail_fast(false)
            .cache_enabled(false)
            .build();

        assert_eq!(coordinator.source_count(), 0);
        assert!(!coordinator.cache_enabled);
    }

    #[test]
    fn test_source_coordinator_add_source() {
        let source = TestSource::new("test", r#"{"key": "value"}"#, Format::Json);
        let mut coordinator = SourceCoordinator::new();

        coordinator.add_source(source, 10);
        assert_eq!(coordinator.source_count(), 1);
    }

    #[test]
    fn test_source_coordinator_load_single() {
        let source = TestSource::new("test", r#"{"key": "value"}"#, Format::Json);

        let mut coordinator = SourceCoordinator::builder().add_source(source, 10).build();

        let result = coordinator.load().unwrap();
        assert!(result.content().is_object());
        assert_eq!(result.loaded_count(), 1);
        assert!(!result.has_failures());
    }

    #[test]
    fn test_source_coordinator_load_multiple() {
        let source1 = TestSource::new("low", r#"{"a": 1}"#, Format::Json);
        let source2 = TestSource::new("high", r#"{"b": 2}"#, Format::Json);

        let mut coordinator = SourceCoordinator::builder()
            .add_source(source1, 1)
            .add_source(source2, 10)
            .merge_strategy(MergeStrategy::Deep)
            .build();

        let result = coordinator.load().unwrap();
        assert!(result.content().get("a").is_some());
        assert!(result.content().get("b").is_some());
    }

    #[test]
    fn test_source_coordinator_priority() {
        // Higher priority should override lower priority values
        let source1 = TestSource::new("low", r#"{"key": "low"}"#, Format::Json);
        let source2 = TestSource::new("high", r#"{"key": "high"}"#, Format::Json);

        let mut coordinator = SourceCoordinator::builder()
            .add_source(source1, 1)
            .add_source(source2, 10)
            .merge_strategy(MergeStrategy::Deep)
            .build();

        let result = coordinator.load().unwrap();
        // Higher priority source is applied last, so it wins
        assert_eq!(result.content().get("key").unwrap().as_str(), Some("high"));
    }

    #[test]
    fn test_source_coordinator_optional_source() {
        let required =
            TestSource::new("required", r#"{"a": 1}"#, Format::Json).with_optional(false);

        let optional =
            TestSource::new("optional", r#"invalid"#, Format::Unknown).with_optional(true);

        let mut coordinator = SourceCoordinator::builder()
            .add_source(required, 1)
            .add_source(optional, 2)
            .build();

        // Should succeed because optional source failure is ignored
        let result = coordinator.load().unwrap();
        assert!(result.content().get("a").is_some());
    }

    #[test]
    fn test_source_coordinator_cache() {
        let source = TestSource::new("test", r#"{"key": "value"}"#, Format::Json);

        let mut coordinator = SourceCoordinator::builder()
            .add_source(source, 10)
            .cache_enabled(true)
            .build();

        // First load
        let result1 = coordinator.load().unwrap();
        assert_eq!(result1.loaded_count(), 1);

        // Second load should use cache
        let result2 = coordinator.load().unwrap();
        assert_eq!(result2.loaded_count(), 1);
    }

    #[test]
    fn test_source_coordinator_clear_cache() {
        let source = TestSource::new("test", r#"{"key": "value"}"#, Format::Json);

        let mut coordinator = SourceCoordinator::builder()
            .add_source(source, 10)
            .cache_enabled(true)
            .build();

        coordinator.load().unwrap();
        coordinator.clear_cache();
        // Cache should be cleared
        assert!(coordinator.cache.is_empty());
    }

    #[test]
    fn test_source_coordinator_reload() {
        let source = TestSource::new("test", r#"{"key": "value"}"#, Format::Json);

        let mut coordinator = SourceCoordinator::builder()
            .add_source(source, 10)
            .cache_enabled(true)
            .build();

        // First load
        coordinator.load().unwrap();

        // Reload should clear cache and reload
        let result = coordinator.reload().unwrap();
        assert_eq!(result.loaded_count(), 1);
    }

    #[test]
    fn test_source_coordinator_to_type() {
        use serde::Deserialize;

        #[derive(Debug, Deserialize, PartialEq)]
        struct Config {
            key: String,
        }

        let source = TestSource::new("test", r#"{"key": "value"}"#, Format::Json);

        let mut coordinator = SourceCoordinator::builder().add_source(source, 10).build();

        let config: Config = coordinator.load_as().unwrap();
        assert_eq!(config.key, "value");
    }

    #[test]
    fn test_source_coordinator_empty() {
        let mut coordinator = SourceCoordinator::new();

        // Loading empty coordinator should return Null
        let result = coordinator.load().unwrap();
        assert!(result.content().is_null());
    }

    #[test]
    fn test_source_coordinator_clear() {
        let source = TestSource::new("test", r#"{"key": "value"}"#, Format::Json);
        let mut coordinator = SourceCoordinator::builder().add_source(source, 10).build();

        assert_eq!(coordinator.source_count(), 1);

        coordinator.clear();
        assert!(coordinator.is_empty());
    }

    #[test]
    fn test_load_result_to_type() {
        use serde::Deserialize;

        #[derive(Debug, Deserialize, PartialEq)]
        struct Config {
            key: String,
        }

        let mut obj = std::collections::BTreeMap::new();
        obj.insert(
            "key".to_string(),
            ParsedContent::String("value".to_string()),
        );
        let content = ParsedContent::Object(obj);

        let result = LoadResult::new(content);
        let config: Config = result.to_type().unwrap();
        assert_eq!(config.key, "value");
    }
}