//! Test 1 — Unix socket SOCK_STREAM with Wayland-shaped messages.
//!
//! Wayland wire format (libwayland reference):
//! - Header: object_id (u32) + (size << 16 | opcode) (u32) = 8 bytes
//! - Payload: variable, 4-byte aligned
//!
//! This test:
//! 1. Creates a SOCK_STREAM socketpair (AF_UNIX)
//! 2. Side A sends a message with header + payload
//! 3. Side B reads it back, validates byte-for-byte
//! 4. Ensures partial reads don't corrupt the stream

use std::io::{Read, Write};
use std::os::unix::net::UnixStream;
use std::process::ExitCode;

const OBJECT_ID: u32 = 0x0000_0001;
const OPCODE: u16 = 0x000A;
const PAYLOAD: &[u8] = b"hello-wayland-on-redox-roundtrip";

fn main() -> ExitCode {
    println!("[test-01] Unix socket SOCK_STREAM Wayland-shaped roundtrip");

    let (mut a, mut b) = match UnixStream::pair() {
        Ok(pair) => pair,
        Err(e) => {
            eprintln!("[test-01] FAIL: UnixStream::pair: {e}");
            return ExitCode::FAILURE;
        }
    };

    let payload_len = PAYLOAD.len();
    let aligned_len = (payload_len + 3) & !3;
    let total_size = 8 + aligned_len;

    let mut msg = Vec::with_capacity(total_size);
    msg.extend_from_slice(&OBJECT_ID.to_ne_bytes());
    let size_op: u32 = ((total_size as u32) << 16) | (OPCODE as u32);
    msg.extend_from_slice(&size_op.to_ne_bytes());
    msg.extend_from_slice(PAYLOAD);
    msg.resize(total_size, 0);

    if let Err(e) = a.write_all(&msg) {
        eprintln!("[test-01] FAIL: write_all: {e}");
        return ExitCode::FAILURE;
    }
    println!("[test-01] sent {} bytes (header 8 + payload {} aligned to {})",
             total_size, payload_len, aligned_len);

    let mut header = [0u8; 8];
    if let Err(e) = b.read_exact(&mut header) {
        eprintln!("[test-01] FAIL: read header: {e}");
        return ExitCode::FAILURE;
    }
    let recv_oid = u32::from_ne_bytes(header[0..4].try_into().unwrap());
    let recv_so = u32::from_ne_bytes(header[4..8].try_into().unwrap());
    let recv_size = (recv_so >> 16) as usize;
    let recv_op = (recv_so & 0xFFFF) as u16;

    if recv_oid != OBJECT_ID || recv_op != OPCODE || recv_size != total_size {
        eprintln!("[test-01] FAIL: header mismatch oid={recv_oid:#x} op={recv_op:#x} size={recv_size}");
        return ExitCode::FAILURE;
    }

    let mut buf = vec![0u8; aligned_len];
    if let Err(e) = b.read_exact(&mut buf) {
        eprintln!("[test-01] FAIL: read payload: {e}");
        return ExitCode::FAILURE;
    }
    if &buf[..payload_len] != PAYLOAD {
        eprintln!("[test-01] FAIL: payload mismatch");
        return ExitCode::FAILURE;
    }

    println!("[test-01] PASS: roundtrip OK, {} bytes recv, oid={:#x} op={:#x}",
             total_size, recv_oid, recv_op);
    ExitCode::SUCCESS
}