robotrt-transport-local 0.1.0-beta.2

use std::collections::VecDeque;

use core_types::{ErrorCode, ErrorDomain, RtError, SessionId};
use data_model::Packet;
use transport_core::{SendReceipt, TransportSession};

pub struct LocalSession {
    session_id: SessionId,
    sequence: u64,
    inbox: VecDeque<Packet>,
    closed: bool,
}

impl LocalSession {
    pub fn new(session_id: SessionId) -> Self {
        Self {
            session_id,
            sequence: 0,
            inbox: VecDeque::new(),
            closed: false,
        }
    }
}

impl TransportSession for LocalSession {
    fn session_id(&self) -> SessionId {
        self.session_id
    }

    fn send(&mut self, packet: Packet) -> Result<SendReceipt, RtError> {
        if self.closed {
            return Err(RtError::new(
                ErrorCode::Disconnected,
                ErrorDomain::Transport,
                true,
                "local session is closed",
            ));
        }
        self.sequence += 1;
        self.inbox.push_back(packet);
        Ok(SendReceipt {
            session_id: self.session_id,
            sequence: self.sequence,
            accepted: true,
            duplicate: false,
            retry_count: 0,
            acked_sequence: None,
        })
    }

    fn recv(&mut self) -> Result<Option<Packet>, RtError> {
        if self.closed {
            return Ok(None);
        }
        Ok(self.inbox.pop_front())
    }

    fn tick_retransmit(
        &mut self,
        _now: core_types::Timestamp,
        _timeout: core_types::RtDuration,
    ) -> Result<usize, RtError> {
        Ok(0)
    }

    fn close(&mut self) -> Result<(), RtError> {
        self.closed = true;
        Ok(())
    }
}