quantrs2-device 0.1.3

//! Quantum Transport Layer Protocols
//!
//! This module provides the transport layer for quantum internet protocols,
//! handling reliable quantum data transmission, flow control, and quantum-specific
//! transport services.

use super::*;

/// Quantum transport layer
pub struct QuantumTransportLayer {
    config: QuantumTransportConfig,
    tcp_manager: Arc<RwLock<QuantumTCPManager>>,
    udp_manager: Arc<RwLock<QuantumUDPManager>>,
    sctp_manager: Arc<RwLock<QuantumSCTPManager>>,
    active_connections: Arc<RwLock<HashMap<String, TransportConnection>>>,
    port_manager: Arc<RwLock<PortManager>>,
}

/// Quantum transport configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumTransportConfig {
    pub default_protocol: TransportProtocol,
    pub tcp_config: QuantumTCPConfig,
    pub udp_config: QuantumUDPConfig,
    pub sctp_config: QuantumSCTPConfig,
    pub port_range: (u16, u16),
    pub max_connections: usize,
    pub connection_timeout: Duration,
    pub quantum_reliability: QuantumReliabilityConfig,
}

/// Transport protocols
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum TransportProtocol {
    QuantumTCP,
    QuantumUDP,
    QuantumSCTP,
    HybridProtocol,
    Custom(String),
}

/// Quantum reliability configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumReliabilityConfig {
    pub error_detection: bool,
    pub error_correction: bool,
    pub entanglement_verification: bool,
    pub quantum_checksums: bool,
    pub adaptive_redundancy: bool,
    pub fidelity_monitoring: bool,
}

/// Quantum UDP configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumUDPConfig {
    pub max_packet_size: usize,
    pub quantum_fragmentation: bool,
    pub entanglement_based_routing: bool,
    pub multicast_support: bool,
    pub reliability_layer: ReliabilityLayer,
}

/// Reliability layer options
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ReliabilityLayer {
    None,
    BestEffort,
    ReliableUDP,
    QuantumReliable,
    EntanglementBased,
}

/// Quantum SCTP configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumSCTPConfig {
    pub multi_homing: bool,
    pub quantum_streams: usize,
    pub partial_reliability: bool,
    pub quantum_heartbeat: Duration,
    pub entanglement_monitoring: bool,
}

/// Transport connection
#[derive(Debug, Clone)]
pub struct TransportConnection {
    pub connection_id: String,
    pub protocol: TransportProtocol,
    pub local_address: String,
    pub remote_address: String,
    pub local_port: u16,
    pub remote_port: u16,
    pub state: ConnectionState,
    pub quantum_state: TransportQuantumState,
    pub statistics: TransportStatistics,
    pub created_at: SystemTime,
    pub last_activity: SystemTime,
}

/// Connection states
#[derive(Debug, Clone, PartialEq)]
pub enum ConnectionState {
    Closed,
    Listening,
    Connecting,
    Connected,
    Disconnecting,
    Error,
}

/// Transport quantum state
#[derive(Debug, Clone)]
pub struct TransportQuantumState {
    pub entanglement_active: bool,
    pub quantum_channel_quality: f64,
    pub fidelity_average: f64,
    pub coherence_time: Duration,
    pub quantum_error_rate: f64,
    pub entanglement_consumption_rate: f64,
}

/// Transport statistics
#[derive(Debug, Clone)]
pub struct TransportStatistics {
    pub bytes_sent: u64,
    pub bytes_received: u64,
    pub packets_sent: u64,
    pub packets_received: u64,
    pub quantum_bits_transmitted: u64,
    pub entanglement_pairs_consumed: u64,
    pub error_count: u64,
    pub retransmission_count: u64,
}

/// Port manager for transport layer
#[derive(Debug)]
pub struct PortManager {
    allocated_ports: HashSet<u16>,
    port_range: (u16, u16),
    next_port: u16,
}

/// Quantum UDP manager
pub struct QuantumUDPManager {
    config: QuantumUDPConfig,
    sockets: HashMap<u16, QuantumUDPSocket>,
    multicast_groups: HashMap<String, MulticastGroup>,
}

/// Quantum UDP socket
#[derive(Debug, Clone)]
pub struct QuantumUDPSocket {
    pub port: u16,
    pub local_address: String,
    pub quantum_enabled: bool,
    pub entanglement_pool: Vec<String>,
    pub packet_queue: VecDeque<QuantumUDPPacket>,
    pub statistics: UDPStatistics,
}

/// Quantum UDP packet
#[derive(Debug, Clone)]
pub struct QuantumUDPPacket {
    pub header: UDPHeader,
    pub payload: QuantumPayload,
    pub quantum_metadata: Option<QuantumMetadata>,
    pub timestamp: SystemTime,
}

/// UDP header
#[derive(Debug, Clone)]
pub struct UDPHeader {
    pub source_port: u16,
    pub destination_port: u16,
    pub length: u16,
    pub checksum: u16,
    pub quantum_checksum: Option<QuantumChecksum>,
}

/// Quantum metadata for packets
#[derive(Debug, Clone)]
pub struct QuantumMetadata {
    pub entanglement_id: Option<String>,
    pub fidelity: f64,
    pub coherence_time: Duration,
    pub measurement_basis: String,
    pub error_correction_info: Option<ErrorCorrectionInfo>,
}

/// UDP statistics
#[derive(Debug, Clone)]
pub struct UDPStatistics {
    pub packets_sent: u64,
    pub packets_received: u64,
    pub bytes_sent: u64,
    pub bytes_received: u64,
    pub quantum_packets: u64,
    pub entanglement_used: u64,
    pub checksum_errors: u64,
    pub quantum_errors: u64,
}

/// Multicast group
#[derive(Debug, Clone)]
pub struct MulticastGroup {
    pub group_address: String,
    pub members: HashSet<String>,
    pub quantum_enabled: bool,
    pub entanglement_distribution: bool,
}

/// Quantum SCTP manager
pub struct QuantumSCTPManager {
    config: QuantumSCTPConfig,
    associations: HashMap<String, QuantumSCTPAssociation>,
    stream_manager: StreamManager,
}

/// Quantum SCTP association
#[derive(Debug, Clone)]
pub struct QuantumSCTPAssociation {
    pub association_id: String,
    pub local_addresses: Vec<String>,
    pub remote_addresses: Vec<String>,
    pub streams: HashMap<u16, QuantumStream>,
    pub state: SCTPState,
    pub quantum_heartbeat: Duration,
    pub reliability_settings: ReliabilitySettings,
}

/// SCTP states
#[derive(Debug, Clone, PartialEq)]
pub enum SCTPState {
    Closed,
    CookieWait,
    CookieEchoed,
    Established,
    ShutdownPending,
    ShutdownSent,
    ShutdownReceived,
    ShutdownAckSent,
}

/// Quantum stream
#[derive(Debug, Clone)]
pub struct QuantumStream {
    pub stream_id: u16,
    pub sequence_number: u32,
    pub reliability_type: ReliabilityType,
    pub quantum_properties: StreamQuantumProperties,
    pub buffer: VecDeque<StreamChunk>,
}

/// Reliability types for SCTP streams
#[derive(Debug, Clone, PartialEq)]
pub enum ReliabilityType {
    Reliable,
    PartiallyReliable,
    Unreliable,
    QuantumReliable,
    EntanglementProtected,
}

/// Stream quantum properties
#[derive(Debug, Clone)]
pub struct StreamQuantumProperties {
    pub entanglement_required: bool,
    pub min_fidelity: f64,
    pub coherence_requirement: Duration,
    pub quantum_encoding: Option<String>,
}

/// Stream chunk
#[derive(Debug, Clone)]
pub struct StreamChunk {
    pub chunk_id: u32,
    pub data: Vec<u8>,
    pub quantum_data: Option<QuantumData>,
    pub timestamp: SystemTime,
    pub reliability_level: u8,
}

/// Reliability settings
#[derive(Debug, Clone)]
pub struct ReliabilitySettings {
    pub max_retransmissions: u32,
    pub retransmission_timeout: Duration,
    pub quantum_verification: bool,
    pub entanglement_backup: bool,
}

/// Stream manager
#[derive(Debug)]
pub struct StreamManager {
    next_stream_id: u16,
    stream_priorities: HashMap<u16, u8>,
    quantum_streams: HashSet<u16>,
}

impl QuantumTransportLayer {
    /// Create a new quantum transport layer
    pub async fn new(config: &QuantumTransportConfig) -> DeviceResult<Self> {
        let tcp_manager = Arc::new(RwLock::new(QuantumTCPManager::new(config.tcp_config.clone())));
        let udp_manager = Arc::new(RwLock::new(QuantumUDPManager::new(&config.udp_config)?));
        let sctp_manager = Arc::new(RwLock::new(QuantumSCTPManager::new(&config.sctp_config)?));
        let active_connections = Arc::new(RwLock::new(HashMap::new()));
        let port_manager = Arc::new(RwLock::new(PortManager::new(config.port_range)));

        Ok(Self {
            config: config.clone(),
            tcp_manager,
            udp_manager,
            sctp_manager,
            active_connections,
            port_manager,
        })
    }

    /// Initialize the transport layer
    pub async fn initialize(&mut self) -> DeviceResult<()> {
        // Initialize all transport protocol managers
        Ok(())
    }

    /// Create a new connection
    pub async fn create_connection(&self, connection_id: &str) -> DeviceResult<()> {
        let connection = TransportConnection {
            connection_id: connection_id.to_string(),
            protocol: self.config.default_protocol.clone(),
            local_address: "127.0.0.1".to_string(),
            remote_address: "0.0.0.0".to_string(),
            local_port: 0,
            remote_port: 0,
            state: ConnectionState::Closed,
            quantum_state: TransportQuantumState {
                entanglement_active: false,
                quantum_channel_quality: 0.0,
                fidelity_average: 0.0,
                coherence_time: Duration::from_millis(0),
                quantum_error_rate: 0.0,
                entanglement_consumption_rate: 0.0,
            },
            statistics: TransportStatistics::default(),
            created_at: SystemTime::now(),
            last_activity: SystemTime::now(),
        };

        self.active_connections.write().await.insert(connection_id.to_string(), connection);
        Ok(())
    }

    /// Send data using the transport layer
    pub async fn send_data(&self, connection_id: &str, data: QuantumData) -> DeviceResult<QuantumData> {
        let mut connections = self.active_connections.write().await;
        let connection = connections.get_mut(connection_id)
            .ok_or_else(|| DeviceError::InvalidInput(format!("Connection {} not found", connection_id)))?;

        match connection.protocol {
            TransportProtocol::QuantumTCP => {
                self.tcp_manager.read().await.send(connection_id, &data.payload).await?;
            }
            TransportProtocol::QuantumUDP => {
                self.send_udp_data(connection, &data).await?;
            }
            TransportProtocol::QuantumSCTP => {
                self.send_sctp_data(connection, &data).await?;
            }
            _ => {
                return Err(DeviceError::UnsupportedOperation("Protocol not implemented".to_string()));
            }
        }

        // Update statistics
        connection.statistics.bytes_sent += data.payload.len() as u64;
        connection.statistics.packets_sent += 1;
        connection.last_activity = SystemTime::now();

        Ok(data)
    }

    /// Receive data from the transport layer
    pub async fn receive_data(&self, connection_id: &str, _data: QuantumData) -> DeviceResult<QuantumData> {
        let mut connections = self.active_connections.write().await;
        let connection = connections.get_mut(connection_id)
            .ok_or_else(|| DeviceError::InvalidInput(format!("Connection {} not found", connection_id)))?;

        let received_data = match connection.protocol {
            TransportProtocol::QuantumTCP => {
                let mut buffer = vec![0u8; 1024];
                let bytes_read = self.tcp_manager.read().await.receive(connection_id, &mut buffer).await?;
                buffer.truncate(bytes_read);
                QuantumData {
                    data_type: QuantumDataType::QuantumMessage,
                    payload: buffer,
                    metadata: HashMap::new(),
                    entanglement_requirements: None,
                }
            }
            TransportProtocol::QuantumUDP => {
                self.receive_udp_data(connection).await?
            }
            TransportProtocol::QuantumSCTP => {
                self.receive_sctp_data(connection).await?
            }
            _ => {
                return Err(DeviceError::UnsupportedOperation("Protocol not implemented".to_string()));
            }
        };

        // Update statistics
        connection.statistics.bytes_received += received_data.payload.len() as u64;
        connection.statistics.packets_received += 1;
        connection.last_activity = SystemTime::now();

        Ok(received_data)
    }

    /// Cleanup connection
    pub async fn cleanup_connection(&self, connection_id: &str) -> DeviceResult<()> {
        self.active_connections.write().await.remove(connection_id);

        // Cleanup protocol-specific resources
        match self.config.default_protocol {
            TransportProtocol::QuantumTCP => {
                self.tcp_manager.read().await.close(connection_id).await?;
            }
            TransportProtocol::QuantumUDP => {
                // UDP is connectionless, minimal cleanup needed
            }
            TransportProtocol::QuantumSCTP => {
                self.cleanup_sctp_association(connection_id).await?;
            }
            _ => {}
        }

        Ok(())
    }

    /// Shutdown the transport layer
    pub async fn shutdown(&self) -> DeviceResult<()> {
        // Close all connections
        let connection_ids: Vec<String> = self.active_connections.read().await.keys().cloned().collect();
        for connection_id in connection_ids {
            self.cleanup_connection(&connection_id).await?;
        }

        Ok(())
    }

    // Helper methods for UDP
    async fn send_udp_data(&self, _connection: &TransportConnection, data: &QuantumData) -> DeviceResult<()> {
        let udp_manager = self.udp_manager.read().await;

        // Create UDP packet
        let packet = QuantumUDPPacket {
            header: UDPHeader {
                source_port: 8080, // Simplified
                destination_port: 8081,
                length: data.payload.len() as u16,
                checksum: self.calculate_udp_checksum(&data.payload),
                quantum_checksum: Some(QuantumChecksum {
                    classical_checksum: 0,
                    quantum_parity: vec![],
                    entanglement_witness: Some(0.95),
                    fidelity_estimate: 0.95,
                }),
            },
            payload: QuantumPayload {
                data_type: data.data_type.clone(),
                data: data.payload.clone(),
                quantum_encoding: None,
                error_protection: ErrorProtectionScheme::HybridECC,
            },
            quantum_metadata: Some(QuantumMetadata {
                entanglement_id: None,
                fidelity: 0.95,
                coherence_time: Duration::from_millis(100),
                measurement_basis: "computational".to_string(),
                error_correction_info: None,
            }),
            timestamp: SystemTime::now(),
        };

        // Send packet (simplified)
        drop(udp_manager);
        Ok(())
    }

    async fn receive_udp_data(&self, _connection: &TransportConnection) -> DeviceResult<QuantumData> {
        // Simulate receiving UDP data
        Ok(QuantumData {
            data_type: QuantumDataType::QuantumMessage,
            payload: vec![1, 2, 3, 4],
            metadata: HashMap::new(),
            entanglement_requirements: None,
        })
    }

    // Helper methods for SCTP
    async fn send_sctp_data(&self, _connection: &TransportConnection, _data: &QuantumData) -> DeviceResult<()> {
        // Implement SCTP data sending
        Ok(())
    }

    async fn receive_sctp_data(&self, _connection: &TransportConnection) -> DeviceResult<QuantumData> {
        // Implement SCTP data receiving
        Ok(QuantumData::default())
    }

    async fn cleanup_sctp_association(&self, _connection_id: &str) -> DeviceResult<()> {
        // Cleanup SCTP association
        Ok(())
    }

    fn calculate_udp_checksum(&self, data: &[u8]) -> u16 {
        // Simple checksum calculation
        data.iter().map(|&b| b as u16).sum()
    }
}

impl QuantumUDPManager {
    fn new(config: &QuantumUDPConfig) -> DeviceResult<Self> {
        Ok(Self {
            config: config.clone(),
            sockets: HashMap::new(),
            multicast_groups: HashMap::new(),
        })
    }
}

impl QuantumSCTPManager {
    fn new(config: &QuantumSCTPConfig) -> DeviceResult<Self> {
        Ok(Self {
            config: config.clone(),
            associations: HashMap::new(),
            stream_manager: StreamManager::new(),
        })
    }
}

impl PortManager {
    fn new(port_range: (u16, u16)) -> Self {
        Self {
            allocated_ports: HashSet::new(),
            port_range,
            next_port: port_range.0,
        }
    }

    fn allocate_port(&mut self) -> Option<u16> {
        for _ in self.port_range.0..=self.port_range.1 {
            if !self.allocated_ports.contains(&self.next_port) {
                let port = self.next_port;
                self.allocated_ports.insert(port);
                self.next_port = if self.next_port >= self.port_range.1 {
                    self.port_range.0
                } else {
                    self.next_port + 1
                };
                return Some(port);
            }

            self.next_port = if self.next_port >= self.port_range.1 {
                self.port_range.0
            } else {
                self.next_port + 1
            };
        }
        None
    }

    fn deallocate_port(&mut self, port: u16) {
        self.allocated_ports.remove(&port);
    }
}

impl StreamManager {
    fn new() -> Self {
        Self {
            next_stream_id: 0,
            stream_priorities: HashMap::new(),
            quantum_streams: HashSet::new(),
        }
    }

    fn allocate_stream(&mut self, quantum_enabled: bool) -> u16 {
        let stream_id = self.next_stream_id;
        self.next_stream_id += 1;

        if quantum_enabled {
            self.quantum_streams.insert(stream_id);
        }

        stream_id
    }
}

// Default implementations
impl Default for QuantumTransportConfig {
    fn default() -> Self {
        Self {
            default_protocol: TransportProtocol::QuantumTCP,
            tcp_config: QuantumTCPConfig::default(),
            udp_config: QuantumUDPConfig::default(),
            sctp_config: QuantumSCTPConfig::default(),
            port_range: (49152, 65535),
            max_connections: 1000,
            connection_timeout: Duration::from_secs(300),
            quantum_reliability: QuantumReliabilityConfig {
                error_detection: true,
                error_correction: true,
                entanglement_verification: true,
                quantum_checksums: true,
                adaptive_redundancy: true,
                fidelity_monitoring: true,
            },
        }
    }
}

impl Default for QuantumUDPConfig {
    fn default() -> Self {
        Self {
            max_packet_size: 65507,
            quantum_fragmentation: true,
            entanglement_based_routing: false,
            multicast_support: true,
            reliability_layer: ReliabilityLayer::BestEffort,
        }
    }
}

impl Default for QuantumSCTPConfig {
    fn default() -> Self {
        Self {
            multi_homing: true,
            quantum_streams: 16,
            partial_reliability: true,
            quantum_heartbeat: Duration::from_secs(30),
            entanglement_monitoring: true,
        }
    }
}

impl Default for TransportStatistics {
    fn default() -> Self {
        Self {
            bytes_sent: 0,
            bytes_received: 0,
            packets_sent: 0,
            packets_received: 0,
            quantum_bits_transmitted: 0,
            entanglement_pairs_consumed: 0,
            error_count: 0,
            retransmission_count: 0,
        }
    }
}

impl Default for UDPStatistics {
    fn default() -> Self {
        Self {
            packets_sent: 0,
            packets_received: 0,
            bytes_sent: 0,
            bytes_received: 0,
            quantum_packets: 0,
            entanglement_used: 0,
            checksum_errors: 0,
            quantum_errors: 0,
        }
    }
}