//!

use {
    super::{message::Message, protocol::Protocol},
    crossbeam_queue::{ArrayQueue, SegQueue},
};
pub enum BufferTypes {
    Unbound(SegQueue<Message>),
    Bound(ArrayQueue<Message>),
}
/// Interproccess buffer
pub struct IpcBuffer {
    pub protocol: Protocol,
    pub buffer:   BufferTypes,
}

impl IpcBuffer {
    pub fn new(bounded: bool, length: u64) -> Self {
        log::debug!(
            "New IPCBuffer\r
    bounded: {}\r
    length: {:?}\r",
            bounded,
            length
        );
        match (bounded, length) {
            (false, a) => {
                let buftype = BufferTypes::Unbound(SegQueue::new());

                Self {
                    protocol: Protocol::void(),
                    buffer:   buftype,
                }
            }
            (true, length) => {
                let buftype = BufferTypes::Bound(ArrayQueue::new(length as usize));
                Self {
                    protocol: Protocol::void(),
                    buffer:   buftype,
                }
            }
        }
    }

    /// Validate a message to match the `IPC.protocol`
    pub fn validate_messages(&mut self) -> Result<(), IpcError> {
        Ok(())
    }
    pub fn push(&mut self, msg: Message) {
        match &self.buffer {
            BufferTypes::Unbound(buff) => buff.push(msg.clone()),
            BufferTypes::Bound(buff) => {
                let _ = buff.push(msg.clone());
            }
        };
    }
    pub fn pop(&mut self) -> Result<Message, IpcError> {
        let msg = match &self.buffer {
            BufferTypes::Unbound(buff) => buff.pop(),
            BufferTypes::Bound(buff) => buff.pop(),
        };
        match msg {
            Some(msg) => return Ok(msg),
            None => return Err(IpcError::NoMessagesInBuffer),
        }
    }
}
/// Interprocess Communication Errors
#[derive(Debug)]
pub enum IpcError {
    /// An invalid message error returned to the sender
    InvalidMessage,
    NoMessagesInBuffer,
}