#![allow(dead_code)]
#[path = "../../../os-handles/peer/handles.rs"]
mod handles;

use handles::{Error, PeerChannel, PeerReceive};

#[test]
fn peer_death_drains_then_closed() {
    let mut channel = PeerChannel::<u64, 2, 4>::new(10, 20).unwrap();
    channel.send(10, b"A").unwrap();
    channel.send(20, b"BYE").unwrap();
    assert_eq!(channel.close(20), Ok(()));
    let snapshot = channel.snapshot();
    assert_eq!(snapshot.alive, [true, false]);
    assert_eq!(snapshot.lens, [1, 0]);
    assert!(snapshot.slots[1].iter().all(Option::is_none));
    assert_eq!(channel.send(10, b"LATE"), Err(Error::PeerClosed));
    assert_eq!(channel.snapshot(), snapshot);
    assert_eq!(channel.peek(10).unwrap(),
        PeerReceive::Message(channel_message(b"BYE")));
    assert_eq!(channel.snapshot(), snapshot);
    let PeerReceive::Message(message) = channel.receive(10).unwrap() else {
        panic!("queued message lost after peer death");
    };
    assert_eq!(message.as_slice(), b"BYE");
    assert_eq!(channel.receive(10), Ok(PeerReceive::Closed));
    let closed = channel.snapshot();
    assert_eq!(channel.receive(10), Ok(PeerReceive::Closed));
    assert_eq!(channel.snapshot(), closed);
    assert_eq!(channel.close(10), Ok(()));
    assert_eq!(channel.snapshot().alive, [false, false]);
    assert!(channel.snapshot().slots.iter().flatten().all(Option::is_none));
}

fn channel_message(bytes: &[u8]) -> handles::Message<4> {
    let mut channel = PeerChannel::<u64, 1, 4>::new(1, 2).unwrap();
    channel.send(2, bytes).unwrap();
    let PeerReceive::Message(message) = channel.receive(1).unwrap() else {
        panic!("message missing");
    };
    message
}

#[test]
fn peer_denials_and_copy_fault_rollback() {
    let mut channel = PeerChannel::<u64, 1, 4>::new(10, 20).unwrap();
    assert_eq!(PeerChannel::<u64, 1, 4>::new(10, 10)
        .err(), Some(Error::Access));
    let before = channel.snapshot();
    assert_eq!(channel.send(30, b"A"), Err(Error::BadFd));
    assert_eq!(channel.send(10, b"ABCDE"), Err(Error::MessageTooLarge));
    assert_eq!(channel.send_from(10, 4, |destination| {
        destination[..2].copy_from_slice(b"AB");
        Err(Error::Fault)
    }), Err(Error::Fault));
    assert_eq!(channel.snapshot(), before);
    channel.send(10, b"ABCD").unwrap();
    let full = channel.snapshot();
    assert_eq!(channel.send(10, b"Z"), Err(Error::WouldBlock));
    assert_eq!(channel.snapshot(), full);
    assert_eq!(channel.close(10), Ok(()));
    assert_eq!(channel.close(10), Err(Error::BadFd));
    assert_eq!(channel.send(10, b"Z"), Err(Error::BadFd));
    let PeerReceive::Message(message) = channel.receive(20).unwrap() else {
        panic!("live peer lost queued message");
    };
    assert_eq!(message.as_slice(), b"ABCD");
    assert_eq!(channel.receive(20), Ok(PeerReceive::Closed));
}

#[test]
fn new_peer_channel_is_healthy_after_old_closes() {
    let mut old = PeerChannel::<u64, 1, 4>::new(10, 20).unwrap();
    old.close(10).unwrap();
    old.close(20).unwrap();
    let mut fresh = PeerChannel::<u64, 1, 4>::new(11, 21).unwrap();
    fresh.send(11, b"NEW").unwrap();
    let PeerReceive::Message(message) = fresh.receive(21).unwrap() else {
        panic!("fresh channel did not deliver");
    };
    assert_eq!(message.as_slice(), b"NEW");
    assert_eq!(fresh.receive(21), Ok(PeerReceive::Empty));
}