AirLibrary/ApplicationState/

mod.rs

//! # Application State Management
//!
//! This module provides comprehensive application state management for the Air
//! daemon, including configuration, service status, resource tracking, and
//! connection management.
//!
//! ## Architecture Overview
//!
//! The ApplicationState acts as the central coordination point for the Air
//! daemon, tracking all active connections, service states, requests, and
//! system resources. It follows the VSCode daemon state management pattern with
//! thread-safe, async-friendly data structures.
//!
//! ## Core Responsibilities
//!
//! 1. **Connection Management**
//!    - Track all connected clients (Mountain, Cocoon, Wind, etc.)
//!    - Heartbeat monitoring and validation
//!    - Connection pooling for Mountain clients
//!    - Graceful disconnection handling
//!    - Stale connection cleanup
//!
//! 2. **Service Status Tracking**
//!    - Monitor authentication service
//!    - Track update service state
//!    - Monitor indexing service
//!    - Track downloader service
//!    - gRPC service status
//!
//! 3. **Request Management**
//!    - Active request tracking
//!    - Request lifecycle management
//!    - Progress monitoring
//!    - Request cancellation support
//!
//! 4. **Resource Monitoring**
//!    - Memory usage tracking
//!    - CPU usage monitoring
//!    - Disk usage tracking
//!    - Network usage monitoring
//!    - Resource limit enforcement
//!
//! 5. **Performance Metrics**
//!    - Request count tracking
//!    - Success/failure rates
//!    - Average response time calculation
//!    - Uptime tracking
//!
//! ## Connection Types
//!
//! - **MountainMain**: Main editor process connection
//! - **MountainWorker**: Background worker processes
//! - **Cocoon**: Deployment and build system
//! - **Wind**: Communication layer
//! - **External**: Third-party integrations
//!
//! ## TODO Items
//!
//! - [ ] Implement connection pooling for Mountain clients with load balancing
//! - [ ] Add connection encryption and authentication
//! - [ ] Implement connection rate limiting
//! - [ ] Add connection-based resource quotas
//! - [ ] Implement connection health checks with automatic recovery
//! - [ ] Add connection-based feature flags
//! - [ ] Implement connection audit logging
//! - [ ] Add connection-based request prioritization
//! - [ ] Implement connection state persistence across restarts
//! - [ ] Add distributed connection support for multi-node deployments
//!
//! ## Thread Safety
//!
//! All state access is protected by async-friendly locks:
//! - `RwLock<T>` for read-heavy data (configuration, metrics, connections)
//! - `Mutex<T>` for write-heavy data (active requests, background tasks)
//!
//! This ensures concurrent access from multiple async tasks and threads
//! is safe and efficient.
//!
//! ## Performance Considerations
//!
//! - Use read locks where possible to allow concurrent access
//! - Minimize lock duration
//! - Use async-friendly lock types to avoid blocking runtime
//! - Consider lock-free alternatives for high-frequency updates
//!
//! ## Error Handling
//!
//! All methods return `Result<T>` with comprehensive error types:
//! - `Configuration`: Invalid configuration values
//! - `ResourceLimit`: Resource limits exceeded
//! - `Internal`: Internal state inconsistencies

use std::{collections::HashMap, sync::Arc};

use serde::{Deserialize, Serialize};
use tokio::sync::{Mutex, RwLock};
use systemstat::{Platform, System};

use crate::{AirError, Configuration::AirConfiguration, Result, Utility};

/// Application state structure
#[derive(Debug)]
pub struct ApplicationState {
	/// Current configuration
	pub Configuration:Arc<AirConfiguration>,

	/// Service status tracking
	pub ServiceStatus:Arc<RwLock<HashMap<String, ServiceStatus>>>,

	/// Active requests tracking
	pub ActiveRequests:Arc<Mutex<HashMap<String, RequestStatus>>>,

	/// Performance metrics
	pub Metrics:Arc<RwLock<PerformanceMetrics>>,

	/// Resource usage tracking
	pub Resources:Arc<RwLock<ResourceUsage>>,

	/// Connection tracking for Mountain clients
	pub Connections:Arc<RwLock<HashMap<String, ConnectionInfo>>>,

	/// Background task management
	pub BackgroundTasks:Arc<Mutex<Vec<tokio::task::JoinHandle<()>>>>,
}

/// Service status enum
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ServiceStatus {
	Starting,
	Running,
	Stopping,
	Stopped,
	Error(String),
}

/// Request status tracking
#[derive(Debug, Clone)]
pub struct RequestStatus {
	pub RequestId:String,
	pub Service:String,
	pub StartedAt:u64,
	pub Status:RequestState,
	pub Progress:Option<f32>,
}

/// Request state enum
#[derive(Debug, Clone)]
pub enum RequestState {
	Pending,
	InProgress,
	Completed,
	Failed(String),
	Cancelled,
}

/// Performance metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceMetrics {
	pub TotalRequests:u64,
	pub SuccessfulRequests:u64,
	pub FailedRequests:u64,
	pub AverageResponseTime:f64,
	pub UptimeSeconds:u64,
	pub LastUpdated:u64,
}

/// Resource usage tracking
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceUsage {
	pub MemoryUsageMb:f64,
	pub CPUUsagePercent:f64,
	pub DiskUsageMb:f64,
	pub NetworkUsageMbps:f64,
	pub LastUpdated:u64,
}

/// Connection information for Mountain clients
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConnectionInfo {
	pub ConnectionId:String,
	pub ClientId:String,
	pub ClientVersion:String,
	pub ProtocolVersion:u32,
	pub LastHeartbeat:u64,
	pub IsActive:bool,
	pub ConnectionType:ConnectionType,
}

/// Connection type enum
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ConnectionType {
	MountainMain,
	MountainWorker,
	Cocoon,
	Wind,
	External,
}

/// Connection health report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConnectionHealthReport {
	pub TotalConnections:usize,
	pub HealthyConnections:usize,
	pub StaleConnections:usize,
	pub ConnectionsByType:HashMap<String, usize>,
	pub LastChecked:u64,
}

impl ApplicationState {
	/// Create a new ApplicationState instance
	pub async fn New(Configuration:Arc<AirConfiguration>) -> Result<Self> {
		let State = Self {
			Configuration,
			ServiceStatus:Arc::new(RwLock::new(HashMap::new())),
			ActiveRequests:Arc::new(Mutex::new(HashMap::new())),
			Metrics:Arc::new(RwLock::new(PerformanceMetrics {
				TotalRequests:0,
				SuccessfulRequests:0,
				FailedRequests:0,
				AverageResponseTime:0.0,
				UptimeSeconds:0,
				LastUpdated:Utility::CurrentTimestamp(),
			})),
			Resources:Arc::new(RwLock::new(ResourceUsage {
				MemoryUsageMb:0.0,
				CPUUsagePercent:0.0,
				DiskUsageMb:0.0,
				NetworkUsageMbps:0.0,
				LastUpdated:Utility::CurrentTimestamp(),
			})),
			Connections:Arc::new(RwLock::new(HashMap::new())),
			BackgroundTasks:Arc::new(Mutex::new(Vec::new())),
		};

		// Initialize service status
		State.InitializeServiceStatus().await?;

		Ok(State)
	}

	/// Initialize service status tracking
	async fn InitializeServiceStatus(&self) -> Result<()> {
		let mut Status = self.ServiceStatus.write().await;

		Status.insert("authentication".to_string(), ServiceStatus::Starting);
		Status.insert("updates".to_string(), ServiceStatus::Starting);
		Status.insert("downloader".to_string(), ServiceStatus::Starting);
		Status.insert("indexing".to_string(), ServiceStatus::Starting);
		Status.insert("grpc".to_string(), ServiceStatus::Starting);
		Status.insert("connections".to_string(), ServiceStatus::Starting);

		Ok(())
	}

	/// Register a new connection with comprehensive validation
	/// Supports connection pooling for Mountain clients
	pub async fn RegisterConnection(
		&self,
		ConnectionId:String,
		ClientId:String,
		ClientVersion:String,
		ProtocolVersion:u32,
		ConnectionType:ConnectionType,
	) -> Result<()> {
		// Validate connection ID
		if ConnectionId.is_empty() {
			return Err(AirError::Configuration("Connection ID cannot be empty".to_string()));
		}

		// Validate client ID
		if ClientId.is_empty() {
			return Err(AirError::Configuration("Client ID cannot be empty".to_string()));
		}

		// Validate protocol version
		if ProtocolVersion == 0 {
			return Err(AirError::Configuration("Protocol version must be greater than 0".to_string()));
		}

		let mut Connections = self.Connections.write().await;

		// Check for duplicate connections
		if Connections.contains_key(&ConnectionId) {
			return Err(AirError::Configuration(format!("Connection {} already exists", ConnectionId)));
		}

		// Implement connection pooling for Mountain clients
		if matches!(ConnectionType, ConnectionType::MountainMain | ConnectionType::MountainWorker) {
			// Check if client has too many connections
			let ClientConnCount = Connections
				.values()
				.filter(|c| {
					c.ClientId == ClientId
						&& matches!(c.ConnectionType, ConnectionType::MountainMain | ConnectionType::MountainWorker)
				})
				.count();

			const MAX_CONN_PER_CLIENT:usize = 10;
			if ClientConnCount >= MAX_CONN_PER_CLIENT {
				return Err(AirError::ResourceLimit(format!(
					"Client {} exceeds maximum connection limit ({})",
					ClientId, MAX_CONN_PER_CLIENT
				)));
			}
		}

		Connections.insert(
			ConnectionId.clone(),
			ConnectionInfo {
				ConnectionId:ConnectionId.clone(),
				ClientId:ClientId.clone(),
				ClientVersion,
				ProtocolVersion,
				LastHeartbeat:Utility::CurrentTimestamp(),
				IsActive:true,
				ConnectionType:ConnectionType.clone(),
			},
		);

		log::info!("Connection registered: {} - {} ({:?})", ConnectionId, ClientId, ConnectionType);
		Ok(())
	}

	/// Update connection heartbeat with validation
	/// Validates heartbeat timing and connection state
	pub async fn UpdateHeartbeat(&self, ConnectionId:&str) -> Result<()> {
		if ConnectionId.is_empty() {
			return Err(AirError::Configuration("Connection ID cannot be empty".to_string()));
		}

		let mut Connections = self.Connections.write().await;

		if let Some(Connection) = Connections.get_mut(ConnectionId) {
			let CurrentTime = Utility::CurrentTimestamp();
			const MAX_HEARTBEAT_INTERVAL:u64 = 120000; // 2 minutes

			// Validate heartbeat timing
			if CurrentTime - Connection.LastHeartbeat > MAX_HEARTBEAT_INTERVAL {
				log::warn!(
					"Long heartbeat interval for connection {}: {}ms",
					ConnectionId,
					CurrentTime - Connection.LastHeartbeat
				);
			}

			Connection.LastHeartbeat = CurrentTime;
			Connection.IsActive = true;

			log::debug!(
				"Heartbeat updated for connection: {} (client: {})",
				ConnectionId,
				Connection.ClientId
			);
		} else {
			return Err(AirError::Internal(format!("Connection {} not found", ConnectionId)));
		}

		Ok(())
	}

	/// Remove connection with proper cleanup and validation
	/// Ensures all resources associated with the connection are cleaned up
	pub async fn RemoveConnection(&self, ConnectionId:&str) -> Result<()> {
		if ConnectionId.is_empty() {
			return Err(AirError::Configuration("Connection ID cannot be empty".to_string()));
		}

		let mut Connections = self.Connections.write().await;

		if let Some(Connection) = Connections.remove(ConnectionId) {
			log::info!(
				"Connection removed: {} (client: {}, type: {:?})",
				ConnectionId,
				Connection.ClientId,
				Connection.ConnectionType
			);

			// TODO: Cleanup any resources associated with this connection
			// - Close any open file handles
			// - Cancel pending requests
			// - Release resources
		} else {
			log::warn!("Attempted to remove non-existent connection: {}", ConnectionId);
		}

		Ok(())
	}

	/// Get active connection count with optional filtering by type
	pub async fn GetActiveConnectionCount(&self) -> usize {
		let Connections = self.Connections.read().await;
		Connections.values().filter(|c| c.IsActive).count()
	}

	/// Get connection count by type
	pub async fn GetConnectionCountByType(&self, ConnectionType:ConnectionType) -> usize {
		let Connections = self.Connections.read().await;
		Connections
			.values()
			.filter(|c| c.ConnectionType == ConnectionType && c.IsActive)
			.count()
	}

	/// Get connections by type
	pub async fn GetConnectionsByType(&self, ConnectionType:ConnectionType) -> Vec<ConnectionInfo> {
		let Connections = self.Connections.read().await;
		Connections
			.values()
			.filter(|c| c.ConnectionType == ConnectionType)
			.cloned()
			.collect()
	}

	/// Get connection for load balancing from Mountain pool
	/// Implements simple round-robin selection for connection pooling
	pub async fn GetNextMountainConnection(&self) -> Result<ConnectionInfo> {
		let Connections = self.Connections.read().await;

		let MountainConnections:Vec<_> = Connections
			.values()
			.filter(|c| {
				matches!(c.ConnectionType, ConnectionType::MountainMain | ConnectionType::MountainWorker) && c.IsActive
			})
			.collect();

		if MountainConnections.is_empty() {
			return Err(AirError::ServiceUnavailable(
				"No active Mountain connections available".to_string(),
			));
		}

		// Simple round-robin selection - in production, consider:
		// - Connection load metrics
		// - Connection latency
		// - Connection health status
		// - Least busy connection strategy
		let Selected = MountainConnections[0].clone();

		Ok(Selected)
	}

	/// Clean up stale connections with comprehensive tracking
	/// Removes connections that haven't sent a heartbeat within the timeout
	/// period
	pub async fn CleanupStaleConnections(&self, TimeoutSeconds:u64) -> Result<usize> {
		let mut Connections = self.Connections.write().await;
		let CurrentTime = Utility::CurrentTimestamp();
		let TimeoutMs = TimeoutSeconds * 1000;

		let mut RemovedCount = 0;
		let mut RemovedByType:HashMap<String, usize> = HashMap::new();

		Connections.retain(|Id, Connection| {
			if CurrentTime - Connection.LastHeartbeat > TimeoutMs {
				log::warn!(
					"Removing stale connection: {} - {} ({:?}) - idle: {}ms",
					Id,
					Connection.ClientId,
					Connection.ConnectionType,
					CurrentTime - Connection.LastHeartbeat
				);

				*RemovedByType.entry(format!("{:?}", Connection.ConnectionType)).or_insert(0) += 1;

				RemovedCount += 1;
				false
			} else {
				true
			}
		});

		if RemovedCount > 0 {
			log::info!("Cleaned up {} stale connections", RemovedCount);
			for (ConnType, Count) in RemovedByType {
				log::info!("  - {} connections: {}", ConnType, Count);
			}
		}

		Ok(RemovedCount)
	}

	/// Register background task with tracking
	pub async fn RegisterBackgroundTask(&self, Task:tokio::task::JoinHandle<()>) -> Result<()> {
		let mut Tasks = self.BackgroundTasks.lock().await;
		Tasks.push(Task);
		log::debug!("Background task registered. Total tasks: {}", Tasks.len());
		Ok(())
	}

	/// Stop all background tasks with graceful shutdown
	pub async fn StopAllBackgroundTasks(&self) -> Result<()> {
		let mut Tasks = self.BackgroundTasks.lock().await;

		let TaskCount = Tasks.len();
		log::info!("Stopping {} background tasks", TaskCount);

		// Abort all tasks
		for Task in Tasks.drain(..) {
			Task.abort();
		}

		log::info!("Stopped all {} background tasks", TaskCount);
		Ok(())
	}

	/// Update service status with validation
	pub async fn UpdateServiceStatus(&self, Service:&str, Status:ServiceStatus) -> Result<()> {
		if Service.is_empty() {
			return Err(AirError::Configuration("Service name cannot be empty".to_string()));
		}

		let mut ServiceStatus = self.ServiceStatus.write().await;
		let StatusClone = Status.clone();
		ServiceStatus.insert(Service.to_string(), Status);
		log::debug!("Service status updated: {} -> {:?}", Service, StatusClone);
		Ok(())
	}

	/// Get service status
	pub async fn GetServiceStatus(&self, Service:&str) -> Option<ServiceStatus> {
		let ServiceStatus = self.ServiceStatus.read().await;
		ServiceStatus.get(Service).cloned()
	}

	/// Get all service statuses
	pub async fn GetAllServiceStatuses(&self) -> HashMap<String, ServiceStatus> {
		let ServiceStatus = self.ServiceStatus.read().await;
		ServiceStatus.clone()
	}

	/// Register a new request with validation
	pub async fn RegisterRequest(&self, RequestId:String, Service:String) -> Result<()> {
		if RequestId.is_empty() {
			return Err(AirError::Configuration("Request ID cannot be empty".to_string()));
		}

		if Service.is_empty() {
			return Err(AirError::Configuration("Service name cannot be empty".to_string()));
		}

		let mut Requests = self.ActiveRequests.lock().await;

		// Check for duplicate request IDs
		if Requests.contains_key(&RequestId) {
			return Err(AirError::Configuration(format!("Request {} already exists", RequestId)));
		}

		Requests.insert(
			RequestId.clone(),
			RequestStatus {
				RequestId:RequestId.clone(),
				Service,
				StartedAt:Utility::CurrentTimestamp(),
				Status:RequestState::Pending,
				Progress:None,
			},
		);

		log::debug!("Request registered: {}", RequestId);
		Ok(())
	}

	/// Update request status with validation
	pub async fn UpdateRequestStatus(&self, RequestId:&str, Status:RequestState, Progress:Option<f32>) -> Result<()> {
		if RequestId.is_empty() {
			return Err(AirError::Configuration("Request ID cannot be empty".to_string()));
		}

		// Validate progress value
		if let Some(p) = Progress {
			if !(0.0..=1.0).contains(&p) {
				return Err(AirError::Configuration("Progress must be between 0.0 and 1.0".to_string()));
			}
		}

		let mut Requests = self.ActiveRequests.lock().await;

		if let Some(Request) = Requests.get_mut(RequestId) {
			Request.Status = Status;
			Request.Progress = Progress;
		} else {
			return Err(AirError::Internal(format!("Request {} not found", RequestId)));
		}

		Ok(())
	}

	/// Remove completed request with validation
	pub async fn RemoveRequest(&self, RequestId:&str) -> Result<()> {
		if RequestId.is_empty() {
			return Err(AirError::Configuration("Request ID cannot be empty".to_string()));
		}

		let mut requests = self.ActiveRequests.lock().await;

		if requests.remove(RequestId).is_some() {
			log::debug!("Request removed: {}", RequestId);
		}

		Ok(())
	}

	/// Update performance metrics with validation
	pub async fn UpdateMetrics(&self, Success:bool, ResponseTime:u64) -> Result<()> {
		let mut Metrics = self.Metrics.write().await;

		Metrics.TotalRequests += 1;
		if Success {
			Metrics.SuccessfulRequests += 1;
		} else {
			Metrics.FailedRequests += 1;
		}

		// Update average response time using exponential moving average
		let Alpha = 0.1; // Smoothing factor
		Metrics.AverageResponseTime = Alpha * (ResponseTime as f64) + (1.0 - Alpha) * Metrics.AverageResponseTime;

		Metrics.LastUpdated = Utility::CurrentTimestamp();

		Ok(())
	}

	/// Update resource usage with error handling
	pub async fn UpdateResourceUsage(&self) -> Result<()> {
		let Sys = System::new();

		// Memory usage - collect outside lock
		let MemoryUsage = if let Ok(Memory) = Sys.memory() {
			(Memory.total.as_u64() - Memory.free.as_u64()) as f64 / 1024.0 / 1024.0
		} else {
			log::warn!("Failed to get memory usage");
			0.0
		};

		// CPU usage - requires sampling, do this outside lock
		let CPUUsage = if let Ok(CPU) = Sys.cpu_load_aggregate() {
			tokio::time::sleep(std::time::Duration::from_secs(1)).await;
			if let Ok(CPU) = CPU.done() {
				(CPU.user + CPU.nice + CPU.system) as f64 * 100.0
			} else {
				log::warn!("Failed to get CPU usage after sampling");
				0.0
			}
		} else {
			log::warn!("Failed to start CPU load sampling");
			0.0
		};

		// Update state with collected metrics
		let mut Resources = self.Resources.write().await;
		Resources.MemoryUsageMb = MemoryUsage;
		Resources.CPUUsagePercent = CPUUsage;
		Resources.LastUpdated = Utility::CurrentTimestamp();

		Ok(())
	}

	/// Get performance metrics
	pub async fn GetMetrics(&self) -> PerformanceMetrics {
		let metrics = self.Metrics.read().await;
		metrics.clone()
	}

	/// Get resource usage
	pub async fn GetResourceUsage(&self) -> ResourceUsage {
		let Resources = self.Resources.read().await;
		Resources.clone()
	}

	/// Get active request count
	pub async fn GetActiveRequestCount(&self) -> usize {
		let Requests = self.ActiveRequests.lock().await;
		Requests.len()
	}

	/// Check if a request is cancelled
	pub async fn IsRequestCancelled(&self, RequestId:&str) -> bool {
		let Requests = self.ActiveRequests.lock().await;
		if let Some(Request) = Requests.get(RequestId) {
			matches!(Request.Status, RequestState::Cancelled)
		} else {
			false
		}
	}

	/// Get current configuration
	pub async fn GetConfiguration(&self) -> Arc<AirConfiguration> { self.Configuration.clone() }

	/// Update configuration with validation and atomic operations
	pub async fn UpdateConfiguration(
		&self,
		Section:String,
		Updates:std::collections::HashMap<String, String>,
	) -> Result<()> {
		log::info!("[ApplicationState] Updating configuration section: {}", Section);

		// Validate section
		if Section.is_empty() {
			return Err(AirError::Configuration("Configuration section cannot be empty".to_string()));
		}

		// Validate updates
		if Updates.is_empty() {
			return Err(AirError::Configuration("Configuration updates cannot be empty".to_string()));
		}

		// For now, just log the update
		// In a real implementation, this would:
		// 1. Validate the updates against schema
		// 2. Create a temporary config file
		// 3. Atomic replace the old config
		// 4. Notify affected services to reload

		match Section.as_str() {
			"grpc" => {
				log::info!("Updating gRPC configuration: {:?}", Updates);
			},
			"updates" => {
				log::info!("Updating updates configuration: {:?}", Updates);
			},
			"downloader" => {
				log::info!("Updating downloader configuration: {:?}", Updates);
			},
			"indexing" => {
				log::info!("Updating indexing configuration: {:?}", Updates);
			},
			"daemon" => {
				log::info!("Updating daemon configuration: {:?}", Updates);
			},
			_ => {
				return Err(AirError::Configuration(format!("Unknown configuration section: {}", Section)));
			},
		}

		Ok(())
	}

	/// Set resource limits with validation and enforcement
	pub async fn SetResourceLimits(
		&self,
		MemoryLimitMb:Option<u64>,
		CPULimitPercent:Option<f64>,
		DiskLimitMb:Option<u64>,
	) -> Result<()> {
		log::info!(
			"[ApplicationState] Setting resource limits memory={:?}, CPU={:?}, disk={:?}",
			MemoryLimitMb,
			CPULimitPercent,
			DiskLimitMb
		);

		// Validate CPU limit
		if let Some(CPU) = CPULimitPercent {
			if !(0.0..=100.0).contains(&CPU) {
				return Err(AirError::ResourceLimit("CPU limit must be between 0 and 100".to_string()));
			}
		}

		// Validate memory limit
		if let Some(Memory) = MemoryLimitMb {
			if Memory == 0 {
				return Err(AirError::ResourceLimit("Memory limit must be greater than 0".to_string()));
			}
		}

		// Validate disk limit
		if let Some(Disk) = DiskLimitMb {
			if Disk == 0 {
				return Err(AirError::ResourceLimit("Disk limit must be greater than 0".to_string()));
			}
		}

		// Apply limits - this would affect how services operate
		// For now, just log and return success
		// In a real implementation, this would:
		// 1. Store limits in configuration
		// 2. Monitor resource usage against limits
		// 3. Throttle or stop services that exceed limits
		// 4. Alert on limit violations
		// 5. Implement graceful degradation

		if MemoryLimitMb.is_some() {
			log::info!("Memory limit set: {} MB", MemoryLimitMb.unwrap());
		}
		if CPULimitPercent.is_some() {
			log::info!("CPU limit set: {}%", CPULimitPercent.unwrap());
		}
		if DiskLimitMb.is_some() {
			log::info!("Disk limit set: {} MB", DiskLimitMb.unwrap());
		}

		Ok(())
	}

	/// Check if resource limits are exceeded
	pub async fn CheckResourceLimits(&self) -> Result<bool> {
		let _Resources = self.Resources.read().await;

		// In a real implementation, compare against configured limits
		// For now, just return false

		Ok(false)
	}

	/// Get connection health report
	pub async fn GetConnectionHealthReport(&self) -> ConnectionHealthReport {
		let Connections = self.Connections.read().await;
		let CurrentTime = Utility::CurrentTimestamp();

		let mut Healthy = 0;
		let mut Stale = 0;
		let mut ByType:HashMap<String, usize> = HashMap::new();

		for Connection in Connections.values() {
			let IsStale = CurrentTime - Connection.LastHeartbeat > 120000; // 2 minutes

			if IsStale {
				Stale += 1;
			} else if Connection.IsActive {
				Healthy += 1;
			}

			*ByType.entry(format!("{:?}", Connection.ConnectionType)).or_insert(0) += 1;
		}

		ConnectionHealthReport {
			TotalConnections:Connections.len(),
			HealthyConnections:Healthy,
			StaleConnections:Stale,
			ConnectionsByType:ByType,
			LastChecked:CurrentTime,
		}
	}
}