CommonLibrary/Transport/Registry/

mod.rs

#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
//! # Transport Registry
//!
//! The Transport Registry enables dynamic transport selection and management,
//! allowing components to register, select, and switch between transports at
//! runtime.

use std::{
	collections::{HashMap, HashSet},
	sync::Arc,
	time::Duration,
};

use super::{
	Common::{DefaultTransportTypeDetector, TransportType, TransportTypeDetector},
	TransportError::TransportError,
	TransportStrategy::{TransportMetrics, TransportStrategy as CommonTransportStrategy},
};

/// Selection strategy for automatic transport selection.
pub struct TransportSelector {
	/// Environment detector for auto-selection
	#[allow(dead_code)]
	EnvironmentDetector:Box<dyn TransportTypeDetector + Send + Sync>,
	/// Priority order for fallback chain
	PriorityOrder:Vec<TransportType>,
}

impl TransportSelector {
	/// Creates a new `TransportSelector` with default settings.
	pub fn New() -> Self {
		Self {
			EnvironmentDetector:Box::new(DefaultTransportTypeDetector),
			PriorityOrder:Self::DefaultPriorityOrder(),
		}
	}

	/// Creates a new `TransportSelector` with custom environment detector.
	pub fn WithDetector(Detector:Box<dyn TransportTypeDetector + Send + Sync>) -> Self {
		Self { EnvironmentDetector:Detector, PriorityOrder:Self::DefaultPriorityOrder() }
	}

	/// Gets the default priority order based on environment.
	fn DefaultPriorityOrder() -> Vec<TransportType> {
		let mut Order = Vec::new();

		#[cfg(target_arch = "wasm32")]
		{
			Order.push(TransportType::Wasm);
			Order.push(TransportType::Grpc);
		}

		#[cfg(not(target_arch = "wasm32"))]
		{
			Order.push(TransportType::Ipc);
			Order.push(TransportType::Grpc);
		}

		Order
	}

	/// Selects the best transport based on context and capabilities.
	pub fn SelectBest(&self, Context:&TransportContext) -> Result<String, TransportError> {
		let mut Candidates = Vec::new();

		for TransportKind in self.PriorityOrder.iter() {
			if !Context.TransportAvailable(*TransportKind) {
				continue;
			}

			if !Context.IsAllowed(*TransportKind) {
				continue;
			}

			let Score = self.CalculateScore(*TransportKind, Context);
			Candidates.push((*TransportKind, Score));
		}

		Candidates.sort_by(|Left, Right| Right.1.total_cmp(&Left.1));

		Candidates
			.first()
			.map(|(TransportKind, _)| TransportKind.AsString().to_string())
			.ok_or_else(|| TransportError::NotFound("No suitable transport available for current context"))
	}

	/// Calculates a suitability score for a transport given the context.
	fn CalculateScore(&self, TransportKind:TransportType, Context:&TransportContext) -> f64 {
		let mut Score = 0.0;

		if let Some(Position) = self.PriorityOrder.iter().position(|Kind| *Kind == TransportKind) {
			Score += (self.PriorityOrder.len() - Position) as f64 * 10.0;
		}

		let Environment = Context.Environment();
		match (Environment.IsWeb, TransportKind) {
			(true, TransportType::Wasm) => Score += 50.0,
			(false, TransportType::Ipc) => Score += 40.0,
			_ => {},
		}

		let Requirements = Context.Requirements();
		if Requirements.StreamingRequired {
			match TransportKind {
				TransportType::Grpc => Score += 30.0,
				TransportType::Wasm => Score += 20.0,
				TransportType::Ipc => Score -= 20.0,
				TransportType::Unknown => {},
			}
		}

		if Requirements.CrossNetwork {
			match TransportKind {
				TransportType::Grpc => Score += 50.0,
				TransportType::Ipc => Score -= 50.0,
				TransportType::Wasm => Score += 10.0,
				TransportType::Unknown => {},
			}
		}

		Score += match Requirements.Performance {
			PerformanceLevel::Critical => {
				match TransportKind {
					TransportType::Ipc => 40.0,
					TransportType::Grpc => 20.0,
					TransportType::Wasm => 0.0,
					TransportType::Unknown => 0.0,
				}
			},
			PerformanceLevel::High => {
				match TransportKind {
					TransportType::Ipc => 30.0,
					TransportType::Grpc => 20.0,
					TransportType::Wasm => 10.0,
					TransportType::Unknown => 0.0,
				}
			},
			PerformanceLevel::Medium => 10.0,
			PerformanceLevel::Low => 0.0,
		};

		if let Some(MaximumLatency) = Requirements.MaximumLatencyMilliseconds {
			let EstimatedLatency = self.EstimateLatencyMilliseconds(TransportKind);
			if EstimatedLatency <= MaximumLatency {
				Score += 20.0;
			} else {
				Score -= 30.0;
			}
		}

		Score
	}

	/// Estimates typical latency for a transport type in milliseconds.
	fn EstimateLatencyMilliseconds(&self, TransportKind:TransportType) -> u64 {
		match TransportKind {
			TransportType::Ipc => 1,
			TransportType::Grpc => 5,
			TransportType::Wasm => 20,
			TransportType::Unknown => u64::MAX,
		}
	}
}

impl Default for TransportSelector {
	fn default() -> Self { Self::New() }
}

/// Context information for transport selection.
#[derive(Debug, Clone)]
pub struct TransportContext {
	EnvironmentInfo:EnvironmentInfo,
	RequirementsInfo:TransportRequirements,
	ConstraintsInfo:TransportConstraints,
	AvailableTransports:HashSet<TransportType>,
}

impl TransportContext {
	/// Creates a new transport selection context.
	pub fn New(
		EnvironmentInfo:EnvironmentInfo,
		RequirementsInfo:TransportRequirements,
		ConstraintsInfo:TransportConstraints,
	) -> Self {
		let AvailableTransports = DefaultTransportTypeDetector::list_available_transports().into_iter().collect();

		Self { EnvironmentInfo, RequirementsInfo, ConstraintsInfo, AvailableTransports }
	}

	/// Detects the current environment and creates a context with default
	/// requirements.
	pub fn Detect() -> Self {
		let EnvironmentInfo = DefaultTransportTypeDetector::DetectEnvironment();
		let RequirementsInfo = TransportRequirements::default();
		let ConstraintsInfo = TransportConstraints::default();

		Self::New(EnvironmentInfo, RequirementsInfo, ConstraintsInfo)
	}

	/// Gets the environment information.
	pub fn Environment(&self) -> &EnvironmentInfo { &self.EnvironmentInfo }

	/// Gets the transport requirements.
	pub fn Requirements(&self) -> &TransportRequirements { &self.RequirementsInfo }

	/// Gets the transport constraints.
	pub fn Constraints(&self) -> &TransportConstraints { &self.ConstraintsInfo }

	/// Checks if a transport type is available in this environment.
	pub fn TransportAvailable(&self, TransportKind:TransportType) -> bool {
		self.AvailableTransports.contains(&TransportKind)
	}

	/// Checks if a transport type is allowed by constraints.
	pub fn IsAllowed(&self, TransportKind:TransportType) -> bool {
		if self.ConstraintsInfo.ForbiddenTransports.contains(&TransportKind) {
			return false;
		}

		if self.ConstraintsInfo.AllowedTransports.is_empty() {
			true
		} else {
			self.ConstraintsInfo.AllowedTransports.contains(&TransportKind)
		}
	}

	/// Sets custom available transports (for testing or override).
	pub fn WithAvailableTransports(mut self, Transports:Vec<TransportType>) -> Self {
		self.AvailableTransports = Transports.into_iter().collect();
		self
	}
}

/// Environment information for transport selection.
#[derive(Debug, Clone)]
pub struct EnvironmentInfo {
	/// Operating system platform
	pub Platform:Platform,
	/// Whether running in a web browser
	pub IsWeb:bool,
	/// Whether running as a desktop application
	pub IsDesktop:bool,
	/// Browser capability information (if in browser)
	pub BrowserCapabilities:Option<BrowserCapabilities>,
}

impl EnvironmentInfo {
	/// Creates a new environment info.
	pub fn New(Platform:Platform, IsWeb:bool, IsDesktop:bool, BrowserCapabilities:Option<BrowserCapabilities>) -> Self {
		Self { Platform, IsWeb, IsDesktop, BrowserCapabilities }
	}
}

/// Platform enumeration.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Platform {
	Windows,
	MacOS,
	Linux,
	Browser,
	Mobile,
	Unknown,
}

impl Platform {
	/// Gets the current platform.
	pub fn Current() -> Self {
		#[cfg(target_os = "windows")]
		return Self::Windows;
		#[cfg(target_os = "macos")]
		return Self::MacOS;
		#[cfg(target_os = "linux")]
		return Self::Linux;
		#[cfg(all(not(target_os = "windows"), not(target_os = "macos"), not(target_os = "linux")))]
		return Self::Unknown;
	}
}

/// Browser capabilities detection.
#[derive(Debug, Clone)]
pub struct BrowserCapabilities {
	pub WasmSupported:bool,
	pub WebWorkerSupported:bool,
	pub WebSocketSupported:bool,
	pub SharedArrayBufferSupported:bool,
}

impl Default for BrowserCapabilities {
	fn default() -> Self {
		Self {
			WasmSupported:cfg!(target_arch = "wasm32"),
			WebWorkerSupported:false,
			WebSocketSupported:false,
			SharedArrayBufferSupported:false,
		}
	}
}

/// Transport requirements for selection.
#[derive(Debug, Clone)]
pub struct TransportRequirements {
	/// Whether bidirectional streaming is required
	pub StreamingRequired:bool,
	/// Whether cross-process communication is needed
	pub CrossProcess:bool,
	/// Whether cross-network communication is needed
	pub CrossNetwork:bool,
	/// Performance requirement level
	pub Performance:PerformanceLevel,
	/// Reliability requirement level
	pub Reliability:ReliabilityLevel,
	/// Maximum acceptable latency in milliseconds (optional)
	pub MaximumLatencyMilliseconds:Option<u64>,
}

impl Default for TransportRequirements {
	fn default() -> Self {
		Self {
			StreamingRequired:false,
			CrossProcess:false,
			CrossNetwork:false,
			Performance:PerformanceLevel::Medium,
			Reliability:ReliabilityLevel::Medium,
			MaximumLatencyMilliseconds:None,
		}
	}
}

/// Performance requirement level.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum PerformanceLevel {
	Low = 1,
	Medium = 2,
	High = 3,
	Critical = 4,
}

/// Reliability requirement level.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum ReliabilityLevel {
	Low = 1,
	Medium = 2,
	High = 3,
	Critical = 4,
}

/// Transport selection constraints.
#[derive(Debug, Clone)]
pub struct TransportConstraints {
	/// Allowed transport types (empty means all allowed)
	pub AllowedTransports:Vec<TransportType>,
	/// Forbidden transport types
	pub ForbiddenTransports:Vec<TransportType>,
	/// Maximum allowed latency in milliseconds
	pub MaximumLatencyMilliseconds:Option<u64>,
	/// Maximum allowed bandwidth in bytes per second
	pub MaximumBandwidthBytesPerSecond:Option<u64>,
}

impl Default for TransportConstraints {
	fn default() -> Self {
		Self {
			AllowedTransports:Vec::new(),
			ForbiddenTransports:Vec::new(),
			MaximumLatencyMilliseconds:None,
			MaximumBandwidthBytesPerSecond:None,
		}
	}
}

/// Central registry for managing transport strategies.
pub struct TransportRegistry {
	/// Registered transports (name -> Arc\<dyn CommonTransportStrategy\>)
	Transports:HashMap<String, Arc<dyn CommonTransportStrategy>>,
	/// Currently active transport name
	Active:Option<String>,
	/// Transport selector for auto-selection
	Selector:TransportSelector,
}

impl TransportRegistry {
	/// Creates a new, empty transport registry.
	pub fn New() -> Self { Self { Transports:HashMap::new(), Active:None, Selector:TransportSelector::New() } }

	/// Creates a new registry with a custom selector.
	pub fn WithSelector(Selector:TransportSelector) -> Self {
		Self { Transports:HashMap::new(), Active:None, Selector }
	}

	/// Registers a new transport with the registry.
	pub fn Register(&mut self, Name:String, Transport:Arc<dyn CommonTransportStrategy>) {
		log::info!("Registering transport: {}", Name);
		self.Transports.insert(Name, Transport);
	}

	/// Unregisters a transport from the registry.
	pub async fn Unregister(&mut self, Name:&str) -> Result<(), TransportError> {
		let TransportOption = self.Transports.remove(Name);

		if let Some(_Transport) = TransportOption {
			// Arc<dyn CommonTransportStrategy> does not expose mutable disconnect here;
			// callers should disconnect before unregistering if needed.
			log::info!("Unregistered transport: {}", Name);
			Ok(())
		} else {
			Err(TransportError::NotFound(format!("Transport '{}' not found", Name)))
		}
	}

	/// Selects a transport by name as the active transport.
	pub async fn Select(&mut self, Name:&str) -> Result<(), TransportError> {
		if !self.Transports.contains_key(Name) {
			return Err(TransportError::NotFound(format!("Transport '{}' not found", Name)));
		}

		log::info!("Selecting transport: {}", Name);
		self.Active = Some(Name.to_string());
		Ok(())
	}

	/// Automatically selects the best transport based on the provided context.
	pub async fn AutoSelect(&mut self, Context:&TransportContext) -> Result<String, TransportError> {
		let SelectedName = self.Selector.SelectBest(Context)?;
		self.Select(&SelectedName).await?;
		Ok(SelectedName)
	}

	/// Gets the currently active transport, if any.
	pub fn GetActive(&self) -> Option<Arc<dyn CommonTransportStrategy>> {
		self.Active.as_ref().and_then(|Name| self.Transports.get(Name)).cloned()
	}

	/// Gets a specific transport by name.
	pub fn Get(&self, Name:&str) -> Option<Arc<dyn CommonTransportStrategy>> { self.Transports.get(Name).cloned() }

	/// Lists all registered transport names.
	pub fn List(&self) -> Vec<String> { self.Transports.keys().cloned().collect() }

	/// Checks if a transport with the given name is registered.
	pub fn Has(&self, Name:&str) -> bool { self.Transports.contains_key(Name) }

	/// Gets metrics for all registered transports.
	pub fn GetAllMetrics(&self) -> HashMap<String, TransportMetrics> {
		let mut Metrics = HashMap::new();
		for (Name, Transport) in &self.Transports {
			Metrics.insert(Name.clone(), Transport.Metrics());
		}
		Metrics
	}

	/// Gets health status (connected/not connected) for all transports.
	pub fn GetHealthStatus(&self) -> HashMap<String, bool> {
		let mut Status = HashMap::new();
		for (Name, Transport) in &self.Transports {
			Status.insert(Name.clone(), Transport.IsConnected());
		}
		Status
	}

	/// Gets the name of the currently active transport.
	pub fn ActiveName(&self) -> Option<&str> { self.Active.as_deref() }

	/// Sets the selector to use for auto-selection.
	pub fn SetSelector(&mut self, Selector:TransportSelector) { self.Selector = Selector; }

	/// Waits for a transport to be ready (connected) with timeout.
	pub async fn WaitForReady(&self, Name:&str, Timeout:Duration) -> Result<(), TransportError> {
		use tokio::time::Instant;

		let Start = Instant::now();
		let Transport = self
			.Get(Name)
			.ok_or_else(|| TransportError::NotFound(format!("Transport '{}' not found", Name)))?;

		loop {
			if Transport.IsConnected() {
				return Ok(());
			}

			if Start.elapsed() >= Timeout {
				return Err(TransportError::Timeout("Transport did not become ready within timeout"));
			}

			tokio::time::sleep(Duration::from_millis(50)).await;
		}
	}
}

impl Default for TransportRegistry {
	fn default() -> Self { Self::New() }
}

/// Provides environment detection for DefaultTransportTypeDetector.
impl DefaultTransportTypeDetector {
	/// Detects the current environment information.
	pub fn DetectEnvironment() -> EnvironmentInfo {
		let CurrentPlatform = Platform::Current();
		let IsDesktop = !cfg!(target_arch = "wasm32");

		let Environment =
			EnvironmentInfo { Platform:CurrentPlatform, IsWeb:false, IsDesktop, BrowserCapabilities:None };

		#[cfg(target_arch = "wasm32")]
		{
			EnvironmentInfo {
				IsWeb:true,
				IsDesktop:false,
				BrowserCapabilities:Some(BrowserCapabilities::default()),
				..Environment
			}
		}

		#[cfg(not(target_arch = "wasm32"))]
		{
			Environment
		}
	}
}

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

	use super::{
		super::{
			TransportConfig::TransportConfig,
			TransportError::TransportError,
			TransportStrategy::{TransportCapabilities, TransportMetrics},
			UnifiedRequest::UnifiedRequest,
			UnifiedResponse::UnifiedResponse,
		},
		*,
	};

	#[test]
	fn TestTransportSelectorCreation() {
		let Selector = TransportSelector::New();
		assert!(!Selector.PriorityOrder.is_empty());
	}

	#[test]
	fn TestTransportContextCreation() {
		let Environment = EnvironmentInfo::New(Platform::Linux, false, true, None);
		let Requirements = TransportRequirements::default();
		let Constraints = TransportConstraints::default();

		let Context = TransportContext::New(Environment, Requirements, Constraints);
		// Without real detector injection, available transports come from
		// DefaultTransportTypeDetector
		assert!(Context.TransportAvailable(TransportType::Grpc));
	}

	#[test]
	fn TestTransportRegistryCreation() {
		let Registry = TransportRegistry::New();
		assert!(Registry.List().is_empty());
		assert!(Registry.ActiveName().is_none());
	}

	#[tokio::test]
	async fn TestRegistryRegisterUnregister() {
		let mut Registry = TransportRegistry::New();

		let MockTransportInstance = Arc::new(MockTransport::New());
		Registry.Register("mock".to_string(), MockTransportInstance);

		assert!(Registry.Has("mock"));
		assert_eq!(Registry.List().len(), 1);

		Registry.Unregister("mock").await.unwrap();
		assert!(!Registry.Has("mock"));
	}

	/// Mock transport for testing
	#[derive(Debug, Clone)]
	struct MockTransport;

	impl MockTransport {
		fn New() -> Self { Self }
	}

	#[async_trait]
	impl CommonTransportStrategy for MockTransport {
		async fn Connect(&mut self) -> Result<(), TransportError> { Ok(()) }

		async fn Disconnect(&mut self) -> Result<(), TransportError> { Ok(()) }

		async fn SendRequest(&mut self, Request:UnifiedRequest) -> Result<UnifiedResponse, TransportError> {
			Ok(UnifiedResponse::Success(
				Request.CorrelationIdentifier.clone().unwrap_or_default(),
				Vec::new(),
			))
		}

		async fn SendNotification(&mut self, _Notification:UnifiedRequest) -> Result<(), TransportError> { Ok(()) }

		fn StreamEvents(
			&self,
		) -> std::result::Result<futures::stream::BoxStream<'static, UnifiedResponse>, TransportError> {
			Err(TransportError::NotSupported("Streaming not supported"))
		}

		fn IsConnected(&self) -> bool { true }

		fn LatencyMilliseconds(&self) -> u64 { 0 }

		fn TransportKind(&self) -> TransportType { TransportType::Grpc }

		fn Configuration(&self) -> &TransportConfig {
			static CONFIG:std::sync::OnceLock<TransportConfig> = std::sync::OnceLock::new();
			CONFIG.get_or_init(TransportConfig::default)
		}

		fn Capabilities(&self) -> TransportCapabilities { TransportCapabilities::default() }

		fn Metrics(&self) -> TransportMetrics { TransportMetrics::New() }

		fn SupportsStreaming(&self) -> bool { false }
	}
}