kegani 0.1.1

//! Service traits for Kegani
//!
//! Defines service layer contracts and dependency injection support.

use async_trait::async_trait;
use std::sync::Arc;

/// Service trait for business logic
#[async_trait]
pub trait Service: Send + Sync {
    /// Get service name
    fn name(&self) -> &str;
}

/// Dependency injection context
pub struct DependencyContext {
    services: std::collections::HashMap<String, Arc<dyn Service>>,
}

impl DependencyContext {
    /// Create a new dependency context
    pub fn new() -> Self {
        Self {
            services: std::collections::HashMap::new(),
        }
    }

    /// Register a service
    pub fn register<T: Service + 'static>(mut self, service: T) -> Self {
        self.services.insert(service.name().to_string(), Arc::new(service));
        self
    }

    /// Get a service by name
    pub fn get(&self, name: &str) -> Option<Arc<dyn Service>> {
        self.services.get(name).cloned()
    }

    /// Check if a service is registered
    pub fn contains(&self, name: &str) -> bool {
        self.services.contains_key(name)
    }
}

impl Default for DependencyContext {
    fn default() -> Self {
        Self::new()
    }
}

/// Service builder for cleaner registration
pub struct ServiceBuilder {
    context: DependencyContext,
}

impl ServiceBuilder {
    /// Create a new service builder
    pub fn new() -> Self {
        Self {
            context: DependencyContext::new(),
        }
    }

    /// Add a service
    pub fn add<T: Service + 'static>(mut self, service: T) -> Self {
        self.context = self.context.register(service);
        self
    }

    /// Build the dependency context
    pub fn build(self) -> DependencyContext {
        self.context
    }
}

impl Default for ServiceBuilder {
    fn default() -> Self {
        Self::new()
    }
}