coderlib 0.1.0

//! Enhanced MCP transport abstractions and implementations
//!
//! This module provides enhanced transport patterns inspired by rust-sdk,
//! including WebSocket, TCP, and custom transport support with bidirectional
//! communication capabilities.

use std::marker::PhantomData;
use std::pin::Pin;
use std::task::{Context, Poll};

use futures::{Sink, Stream};
use pin_project_lite::pin_project;
// Removed unused import

#[cfg(feature = "mcp")]
use rmcp::service::ServiceRole;

/// Transport configuration for enhanced transports
#[derive(Debug, Clone)]
pub enum EnhancedTransportConfig {
    /// WebSocket transport configuration
    WebSocket {
        /// WebSocket URL
        url: String,
        /// Optional headers for connection
        headers: std::collections::HashMap<String, String>,
    },
    /// TCP transport configuration
    Tcp {
        /// Host address
        host: String,
        /// Port number
        port: u16,
    },
    /// Unix socket transport configuration (Unix only)
    #[cfg(unix)]
    UnixSocket {
        /// Socket path
        path: std::path::PathBuf,
    },
    /// Named pipe transport configuration (Windows only)
    #[cfg(windows)]
    NamedPipe {
        /// Pipe name
        name: String,
    },
}

/// Enhanced transport trait for custom transport implementations
pub trait EnhancedTransport<R>: Send + Sync {
    /// Get a description of the transport
    fn description(&self) -> String;

    /// Check if the transport is connected
    fn is_connected(&self) -> bool;

    /// Get transport statistics
    fn stats(&self) -> TransportStats;
}

/// Transport statistics
#[derive(Debug, Clone, Default)]
pub struct TransportStats {
    /// Number of messages sent
    pub messages_sent: u64,
    /// Number of messages received
    pub messages_received: u64,
    /// Number of connection errors
    pub connection_errors: u64,
    /// Last error message
    pub last_error: Option<String>,
}

/// Generic transport wrapper that implements the enhanced transport pattern
pin_project! {
    pub struct GenericTransport<R, S, E> {
        #[pin]
        stream: S,
        stats: TransportStats,
        description: String,
        marker: PhantomData<(fn() -> E, fn() -> R)>,
    }
}

impl<R, S, E> GenericTransport<R, S, E> {
    /// Create a new generic transport
    pub fn new(stream: S, description: String) -> Self {
        Self {
            stream,
            stats: TransportStats::default(),
            description,
            marker: PhantomData,
        }
    }
    
    /// Get mutable reference to stats
    fn stats_mut(&mut self) -> &mut TransportStats {
        &mut self.stats
    }
}

impl<R, S, E> EnhancedTransport<R> for GenericTransport<R, S, E>
where
    R: Send + Sync,
    S: Send + Sync,
    E: Send + Sync,
{
    fn description(&self) -> String {
        self.description.clone()
    }

    fn is_connected(&self) -> bool {
        // This is a simplified implementation
        // In a real implementation, you'd check the underlying stream state
        true
    }

    fn stats(&self) -> TransportStats {
        self.stats.clone()
    }
}

// Stream and Sink implementations removed for simplicity
// In a full implementation, these would be properly implemented
// with correct error handling and type bounds

/// Transport factory for creating enhanced transports
pub struct TransportFactory;

impl TransportFactory {
    /// Create a transport from configuration
    pub async fn create_transport<R>(
        config: &EnhancedTransportConfig,
    ) -> Result<Box<dyn EnhancedTransport<R>>, TransportError>
    where
        R: Send + Sync + 'static + rmcp::service::ServiceRole,
    {
        match config {
            EnhancedTransportConfig::WebSocket { url, headers: _ } => {
                #[cfg(feature = "websocket")]
                {
                    let transport = super::websocket::WebSocketTransport::connect(url).await?;
                    Ok(Box::new(transport) as Box<dyn EnhancedTransport<R>>)
                }
                #[cfg(not(feature = "websocket"))]
                {
                    Err(TransportError::UnsupportedTransport("WebSocket feature not enabled".to_string()))
                }
            }
            EnhancedTransportConfig::Tcp { host: _, port: _ } => {
                // TCP transport implementation would go here
                Err(TransportError::UnsupportedTransport("TCP transport not yet implemented".to_string()))
            }
            #[cfg(unix)]
            EnhancedTransportConfig::UnixSocket { path } => {
                let transport = UnixSocketTransport::connect(path).await?;
                Ok(Box::new(transport))
            }
            #[cfg(windows)]
            EnhancedTransportConfig::NamedPipe { name: _ } => {
                // Named pipe implementation would go here
                Err(TransportError::UnsupportedTransport("Named pipe transport not yet implemented".to_string()))
            }
        }
    }
}

/// Transport error types
#[derive(Debug, thiserror::Error)]
pub enum TransportError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    
    #[error("WebSocket error: {0}")]
    #[cfg(feature = "websocket")]
    WebSocket(#[from] tokio_tungstenite::tungstenite::Error),
    
    #[error("Serialization error: {0}")]
    Serialization(#[from] serde_json::Error),
    
    #[error("Unsupported transport: {0}")]
    UnsupportedTransport(String),
    
    #[error("Connection failed: {0}")]
    ConnectionFailed(String),
}

/// TCP transport implementation
pub struct TcpTransport<R> {
    inner: GenericTransport<R, tokio::net::TcpStream, std::io::Error>,
}

impl<R> TcpTransport<R>
where
    R: ServiceRole,
{
    /// Connect to a TCP server
    pub async fn connect(host: &str, port: u16) -> Result<Self, TransportError> {
        let addr = format!("{}:{}", host, port);
        let stream = tokio::net::TcpStream::connect(&addr).await?;
        let description = format!("TCP connection to {}", addr);
        
        // Note: This is a simplified implementation
        // In practice, you'd need to implement proper framing for TCP
        todo!("TCP transport implementation needs proper framing")
    }
}

/// WebSocket transport implementation
#[cfg(feature = "websocket")]
pub struct WebSocketTransport<R> {
    inner: GenericTransport<R, tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>, tokio_tungstenite::tungstenite::Error>,
}

#[cfg(feature = "websocket")]
impl<R> WebSocketTransport<R>
where
    R: ServiceRole,
{
    /// Connect to a WebSocket server
    pub async fn connect(url: &str) -> Result<Self, TransportError> {
        let (stream, _) = tokio_tungstenite::connect_async(url).await?;
        let description = format!("WebSocket connection to {}", url);
        
        // Note: This is a simplified implementation
        // The actual implementation would need proper message handling
        todo!("WebSocket transport implementation needs proper message handling")
    }
}

/// Unix socket transport implementation
#[cfg(unix)]
pub struct UnixSocketTransport<R> {
    inner: GenericTransport<R, tokio::net::UnixStream, std::io::Error>,
}

#[cfg(unix)]
impl<R> UnixSocketTransport<R>
where
    R: ServiceRole,
{
    /// Connect to a Unix socket
    pub async fn connect(path: &std::path::Path) -> Result<Self, TransportError> {
        let stream = tokio::net::UnixStream::connect(path).await?;
        let description = format!("Unix socket connection to {}", path.display());
        
        // Note: This is a simplified implementation
        todo!("Unix socket transport implementation needs proper framing")
    }
}

/// Named pipe transport implementation
#[cfg(windows)]
pub struct NamedPipeTransport<R> {
    // Implementation would use Windows named pipes
    _marker: PhantomData<R>,
}

#[cfg(windows)]
impl<R> NamedPipeTransport<R>
where
    R: ServiceRole,
{
    /// Connect to a named pipe
    pub async fn connect(name: &str) -> Result<Self, TransportError> {
        // Implementation would use Windows named pipes
        todo!("Named pipe transport implementation")
    }
}

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

    #[test]
    fn test_transport_config() {
        let config = EnhancedTransportConfig::WebSocket {
            url: "ws://localhost:8080".to_string(),
            headers: std::collections::HashMap::new(),
        };
        
        match config {
            EnhancedTransportConfig::WebSocket { url, .. } => {
                assert_eq!(url, "ws://localhost:8080");
            }
            _ => panic!("Expected WebSocket config"),
        }
    }

    #[test]
    fn test_transport_stats() {
        let stats = TransportStats::default();
        assert_eq!(stats.messages_sent, 0);
        assert_eq!(stats.messages_received, 0);
        assert_eq!(stats.connection_errors, 0);
        assert!(stats.last_error.is_none());
    }
}