use std::io;
use std::os::fd::{AsFd, OwnedFd};

use lazaret_core::codec::{decode, encode};
use rustix::net::{
    AddressFamily, RecvFlags, SendFlags, SocketFlags, SocketType, recv, send, socketpair,
};

const MAX_PRIVATE_PACKET: usize = 64 * 1024;

/// # Errors
/// Returns an error when the private sequenced-packet pair cannot be created.
pub fn private_seqpacket_pair() -> std::io::Result<(OwnedFd, OwnedFd)> {
    socketpair(
        AddressFamily::UNIX,
        SocketType::SEQPACKET,
        SocketFlags::CLOEXEC,
        None,
    )
    .map_err(Into::into)
}

/// # Errors
/// Returns an error when the private stream pair cannot be created.
pub fn private_stream_pair() -> std::io::Result<(OwnedFd, OwnedFd)> {
    socketpair(
        AddressFamily::UNIX,
        SocketType::STREAM,
        SocketFlags::CLOEXEC,
        None,
    )
    .map_err(Into::into)
}

/// # Errors
/// Returns an error when a typed private packet is oversized or cannot be sent atomically.
pub fn send_packet<T: serde::Serialize>(descriptor: impl AsFd, message: &T) -> io::Result<()> {
    let encoded = encode(message).map_err(|error| io::Error::other(error.to_string()))?;
    if encoded.is_empty() || encoded.len() > MAX_PRIVATE_PACKET {
        return Err(io::Error::other("private packet has invalid size"));
    }
    let sent = send(descriptor.as_fd(), &encoded, SendFlags::empty())?;
    if sent == encoded.len() {
        Ok(())
    } else {
        Err(io::Error::other("private packet send was incomplete"))
    }
}

/// # Errors
/// Returns an error when a private packet is empty, oversized, malformed, or unknown-version.
pub fn receive_packet<T>(descriptor: impl AsFd) -> io::Result<T>
where
    T: serde::de::DeserializeOwned + serde::Serialize,
{
    let mut encoded = vec![0_u8; MAX_PRIVATE_PACKET + 1];
    let (_, received) = recv(descriptor.as_fd(), &mut encoded, RecvFlags::empty())?;
    if received == 0 || received > MAX_PRIVATE_PACKET {
        return Err(io::Error::other("private packet has invalid size"));
    }
    decode(&encoded[..received]).map_err(|error| io::Error::other(error.to_string()))
}

#[cfg(test)]
mod tests {
    use std::os::fd::AsFd;

    use rustix::net::{RecvFlags, SendFlags, recv, send};

    use super::private_seqpacket_pair;

    #[test]
    fn preserves_message_boundaries() {
        let (left, right) = private_seqpacket_pair().unwrap();
        send(left.as_fd(), b"first", SendFlags::empty()).unwrap();
        send(left.as_fd(), b"second", SendFlags::empty()).unwrap();
        let mut buffer = [0_u8; 16];
        let (_, first) = recv(right.as_fd(), &mut buffer, RecvFlags::empty()).unwrap();
        assert_eq!(&buffer[..first], b"first");
        let (_, second) = recv(right.as_fd(), &mut buffer, RecvFlags::empty()).unwrap();
        assert_eq!(&buffer[..second], b"second");
    }
}