servicepoint2 0.4.3

use crate::command_code::CommandCode;
use crate::compression::{into_compressed, into_decompressed};
use crate::{
    BitVec, ByteGrid, CompressionCode, Grid, Header, Packet, PixelGrid,
    TILE_SIZE,
};

/// An origin marks the top left position of a window sent to the display.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Origin(pub usize, pub usize);

impl std::ops::Add<Origin> for Origin {
    type Output = Origin;

    fn add(self, rhs: Origin) -> Self::Output {
        let Origin(x1, y1) = self;
        let Origin(x2, y2) = rhs;
        Origin(x1 + x2, y1 + y2)
    }
}

/// Type alias for documenting the meaning of the u16 in enum values
pub type Offset = usize;

/// Type alias for documenting the meaning of the u16 in enum values
pub type Brightness = u8;

/// A command to send to the display.
#[derive(Debug, Clone, PartialEq)]
pub enum Command {
    /// Set all pixels to the off state
    Clear,
    /// Kills the udp daemon, usually results in a reboot of the display.
    HardReset,
    /// Slowly decrease brightness until off? Untested.
    FadeOut,
    /// Set the brightness of tiles
    CharBrightness(Origin, ByteGrid),
    /// Set the brightness of all tiles
    Brightness(Brightness),
    #[deprecated]
    /// Legacy command code, gets ignored by the real display.
    BitmapLegacy,
    /// Set pixel data starting at the offset.
    /// The contained `BitVec` is always uncompressed.
    BitmapLinear(Offset, BitVec, CompressionCode),
    /// Set pixel data according to an and-mask starting at the offset.
    /// The contained `BitVec` is always uncompressed.
    BitmapLinearAnd(Offset, BitVec, CompressionCode),
    /// Set pixel data according to an or-mask starting at the offset.
    /// The contained `BitVec` is always uncompressed.
    BitmapLinearOr(Offset, BitVec, CompressionCode),
    /// Set pixel data according to a xor-mask starting at the offset.
    /// The contained `BitVec` is always uncompressed.
    BitmapLinearXor(Offset, BitVec, CompressionCode),
    /// Show text on the screen. Note that the byte data has to be CP437 encoded.
    Cp437Data(Origin, ByteGrid),
    /// Sets a window of pixels to the specified values
    BitmapLinearWin(Origin, PixelGrid, CompressionCode),
}

impl From<Command> for Packet {
    /// Move the `Command` into a `Packet` instance for sending.
    #[allow(clippy::cast_possible_truncation)]
    fn from(value: Command) -> Self {
        match value {
            Command::Clear => Command::command_code_only(CommandCode::Clear),
            Command::FadeOut => {
                Command::command_code_only(CommandCode::FadeOut)
            }
            Command::HardReset => {
                Command::command_code_only(CommandCode::HardReset)
            }
            #[allow(deprecated)]
            Command::BitmapLegacy => {
                Command::command_code_only(CommandCode::BitmapLegacy)
            }
            Command::CharBrightness(Origin(x, y), grid) => Packet(
                Header(
                    CommandCode::CharBrightness.into(),
                    x as u16,
                    y as u16,
                    grid.width() as u16,
                    grid.height() as u16,
                ),
                grid.into(),
            ),
            Command::Brightness(brightness) => Packet(
                Header(
                    CommandCode::Brightness.into(),
                    0x00000,
                    0x0000,
                    0x0000,
                    0x0000,
                ),
                vec![brightness],
            ),
            Command::BitmapLinearWin(origin, pixels, compression) => {
                bitmap_win_into_packet(origin, pixels, compression)
            }
            Command::BitmapLinear(offset, bits, compression) => {
                Command::bitmap_linear_into_packet(
                    CommandCode::BitmapLinear,
                    offset,
                    compression,
                    bits.into(),
                )
            }
            Command::BitmapLinearAnd(offset, bits, compression) => {
                Command::bitmap_linear_into_packet(
                    CommandCode::BitmapLinearAnd,
                    offset,
                    compression,
                    bits.into(),
                )
            }
            Command::BitmapLinearOr(offset, bits, compression) => {
                Command::bitmap_linear_into_packet(
                    CommandCode::BitmapLinearOr,
                    offset,
                    compression,
                    bits.into(),
                )
            }
            Command::BitmapLinearXor(offset, bits, compression) => {
                Command::bitmap_linear_into_packet(
                    CommandCode::BitmapLinearXor,
                    offset,
                    compression,
                    bits.into(),
                )
            }
            Command::Cp437Data(Origin(x, y), grid) => Packet(
                Header(
                    CommandCode::Cp437Data.into(),
                    x as u16,
                    y as u16,
                    grid.width() as u16,
                    grid.height() as u16,
                ),
                grid.into(),
            ),
        }
    }
}

#[allow(clippy::cast_possible_truncation)]
fn bitmap_win_into_packet(
    origin: Origin,
    pixels: PixelGrid,
    compression: CompressionCode,
) -> Packet {
    let Origin(pixel_x, pixel_y) = origin;
    debug_assert_eq!(pixel_x % 8, 0);
    debug_assert_eq!(pixels.width() % 8, 0);

    let tile_x = (pixel_x / TILE_SIZE) as u16;
    let tile_w = (pixels.width() / TILE_SIZE) as u16;
    let pixel_h = pixels.height() as u16;
    let payload = into_compressed(compression, pixels.into());
    let command = match compression {
        CompressionCode::Uncompressed => {
            CommandCode::BitmapLinearWinUncompressed
        }
        #[cfg(feature = "compression_zlib")]
        CompressionCode::Zlib => CommandCode::BitmapLinearWinZlib,
        #[cfg(feature = "compression_bzip2")]
        CompressionCode::Bzip2 => CommandCode::BitmapLinearWinBzip2,
        #[cfg(feature = "compression_lzma")]
        CompressionCode::Lzma => CommandCode::BitmapLinearWinLzma,
        #[cfg(feature = "compression_zstd")]
        CompressionCode::Zstd => CommandCode::BitmapLinearWinZstd,
    };

    Packet(
        Header(command.into(), tile_x, pixel_y as u16, tile_w, pixel_h),
        payload,
    )
}

#[derive(Debug)]
/// Err values for `Command::try_from`.
#[derive(PartialEq)]
pub enum TryFromPacketError {
    /// the contained command code does not correspond to a known command
    InvalidCommand(u16),
    /// the expected payload size was n, but size m was found
    UnexpectedPayloadSize(usize, usize),
    /// Header fields not needed for the command have been used.
    ///
    /// Note that these commands would usually still work on the actual display.
    ExtraneousHeaderValues,
    /// The contained compression code is not known. This could be of disabled features.
    InvalidCompressionCode(u16),
    /// Decompression of the payload failed. This can be caused by corrupted packets.
    DecompressionFailed,
}

impl TryFrom<Packet> for Command {
    type Error = TryFromPacketError;

    /// Try to interpret the `Packet` as one containing a `Command`
    fn try_from(packet: Packet) -> Result<Self, Self::Error> {
        let Packet(Header(command_u16, a, b, c, d), _) = packet;
        let command_code = match CommandCode::try_from(command_u16) {
            Err(()) => {
                return Err(TryFromPacketError::InvalidCommand(command_u16));
            }
            Ok(value) => value,
        };

        match command_code {
            CommandCode::Clear => match Self::check_command_only(packet) {
                Some(err) => Err(err),
                None => Ok(Command::Clear),
            },
            CommandCode::Brightness => {
                let Packet(header, payload) = packet;
                if payload.len() != 1 {
                    return Err(TryFromPacketError::UnexpectedPayloadSize(
                        1,
                        payload.len(),
                    ));
                }

                let Header(_, a, b, c, d) = header;
                if a != 0 || b != 0 || c != 0 || d != 0 {
                    Err(TryFromPacketError::ExtraneousHeaderValues)
                } else {
                    Ok(Command::Brightness(payload[0]))
                }
            }
            CommandCode::HardReset => match Self::check_command_only(packet) {
                Some(err) => Err(err),
                None => Ok(Command::HardReset),
            },
            CommandCode::FadeOut => match Self::check_command_only(packet) {
                Some(err) => Err(err),
                None => Ok(Command::FadeOut),
            },
            CommandCode::Cp437Data => {
                let Packet(_, payload) = packet;
                Ok(Command::Cp437Data(
                    Origin(a as usize, b as usize),
                    ByteGrid::load(c as usize, d as usize, &payload),
                ))
            }
            CommandCode::CharBrightness => {
                let Packet(_, payload) = packet;
                Ok(Command::CharBrightness(
                    Origin(a as usize, b as usize),
                    ByteGrid::load(c as usize, d as usize, &payload),
                ))
            }
            #[allow(deprecated)]
            CommandCode::BitmapLegacy => Ok(Command::BitmapLegacy),
            CommandCode::BitmapLinear => {
                let (vec, compression) =
                    Self::packet_into_linear_bitmap(packet)?;
                Ok(Command::BitmapLinear(a as Offset, vec, compression))
            }
            CommandCode::BitmapLinearAnd => {
                let (vec, compression) =
                    Self::packet_into_linear_bitmap(packet)?;
                Ok(Command::BitmapLinearAnd(a as Offset, vec, compression))
            }
            CommandCode::BitmapLinearOr => {
                let (vec, compression) =
                    Self::packet_into_linear_bitmap(packet)?;
                Ok(Command::BitmapLinearOr(a as Offset, vec, compression))
            }
            CommandCode::BitmapLinearXor => {
                let (vec, compression) =
                    Self::packet_into_linear_bitmap(packet)?;
                Ok(Command::BitmapLinearXor(a as Offset, vec, compression))
            }
            CommandCode::BitmapLinearWinUncompressed => {
                Self::packet_into_bitmap_win(
                    packet,
                    CompressionCode::Uncompressed,
                )
            }
            #[cfg(feature = "compression_zlib")]
            CommandCode::BitmapLinearWinZlib => {
                Self::packet_into_bitmap_win(packet, CompressionCode::Zlib)
            }
            #[cfg(feature = "compression_bzip2")]
            CommandCode::BitmapLinearWinBzip2 => {
                Self::packet_into_bitmap_win(packet, CompressionCode::Bzip2)
            }
            #[cfg(feature = "compression_lzma")]
            CommandCode::BitmapLinearWinLzma => {
                Self::packet_into_bitmap_win(packet, CompressionCode::Lzma)
            }
            #[cfg(feature = "compression_zstd")]
            CommandCode::BitmapLinearWinZstd => {
                Self::packet_into_bitmap_win(packet, CompressionCode::Zstd)
            }
        }
    }
}

impl Command {
    fn packet_into_bitmap_win(
        packet: Packet,
        compression: CompressionCode,
    ) -> Result<Command, TryFromPacketError> {
        let Packet(Header(_, tiles_x, pixels_y, tile_w, pixel_h), payload) =
            packet;

        let payload = match into_decompressed(compression, payload) {
            None => return Err(TryFromPacketError::DecompressionFailed),
            Some(decompressed) => decompressed,
        };

        Ok(Command::BitmapLinearWin(
            Origin(tiles_x as usize * TILE_SIZE, pixels_y as usize),
            PixelGrid::load(
                tile_w as usize * TILE_SIZE,
                pixel_h as usize,
                &payload,
            ),
            compression,
        ))
    }

    /// Helper method for `BitMapLinear*`-Commands into `Packet`
    #[allow(clippy::cast_possible_truncation)]
    fn bitmap_linear_into_packet(
        command: CommandCode,
        offset: Offset,
        compression: CompressionCode,
        payload: Vec<u8>,
    ) -> Packet {
        let length = payload.len() as u16;
        let payload = into_compressed(compression, payload);
        Packet(
            Header(
                command.into(),
                offset as u16,
                length,
                compression.into(),
                0,
            ),
            payload,
        )
    }

    /// Helper method for creating empty packets only containing the command code
    fn command_code_only(code: CommandCode) -> Packet {
        Packet(Header(code.into(), 0x0000, 0x0000, 0x0000, 0x0000), vec![])
    }

    /// Helper method for checking that a packet is empty and only contains a command code
    fn check_command_only(packet: Packet) -> Option<TryFromPacketError> {
        let Packet(Header(_, a, b, c, d), payload) = packet;
        if !payload.is_empty() {
            Some(TryFromPacketError::UnexpectedPayloadSize(0, payload.len()))
        } else if a != 0 || b != 0 || c != 0 || d != 0 {
            Some(TryFromPacketError::ExtraneousHeaderValues)
        } else {
            None
        }
    }

    /// Helper method for Packets into `BitMapLinear*`-Commands
    fn packet_into_linear_bitmap(
        packet: Packet,
    ) -> Result<(BitVec, CompressionCode), TryFromPacketError> {
        let Packet(Header(_, _, length, sub, reserved), payload) = packet;
        if reserved != 0 {
            return Err(TryFromPacketError::ExtraneousHeaderValues);
        }
        let sub = match CompressionCode::try_from(sub) {
            Err(()) => {
                return Err(TryFromPacketError::InvalidCompressionCode(sub));
            }
            Ok(value) => value,
        };
        let payload = match into_decompressed(sub, payload) {
            None => return Err(TryFromPacketError::DecompressionFailed),
            Some(value) => value,
        };
        if payload.len() != length as usize {
            return Err(TryFromPacketError::UnexpectedPayloadSize(
                length as usize,
                payload.len(),
            ));
        }
        Ok((BitVec::from(&*payload), sub))
    }
}

#[cfg(feature = "c_api")]
pub mod c_api {
    use std::ptr::null_mut;

    use crate::{
        BitVec, Brightness, ByteGrid, Command, CompressionCode, Offset, Origin,
        Packet, PixelGrid,
    };

    /// Tries to turn a `Packet` into a `Command`. The packet is gets deallocated in the process.
    ///
    /// Returns: pointer to command or NULL
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_try_from_packet(
        packet: *mut Packet,
    ) -> *mut Command {
        let packet = *Box::from_raw(packet);
        match Command::try_from(packet) {
            Err(_) => null_mut(),
            Ok(command) => Box::into_raw(Box::new(command)),
        }
    }

    /// Clones a `Command` instance
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_clone(
        original: *const Command,
    ) -> *mut Command {
        Box::into_raw(Box::new((*original).clone()))
    }

    /// Allocates a new `Command::Clear` instance
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_clear() -> *mut Command {
        Box::into_raw(Box::new(Command::Clear))
    }

    /// Allocates a new `Command::HardReset` instance
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_hard_reset() -> *mut Command {
        Box::into_raw(Box::new(Command::HardReset))
    }

    /// Allocates a new `Command::FadeOut` instance
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_fade_out() -> *mut Command {
        Box::into_raw(Box::new(Command::FadeOut))
    }

    /// Allocates a new `Command::Brightness` instance
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_brightness(
        brightness: Brightness,
    ) -> *mut Command {
        Box::into_raw(Box::new(Command::Brightness(brightness)))
    }

    /// Allocates a new `Command::CharBrightness` instance.
    /// The passed `ByteGrid` gets deallocated in the process.
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_char_brightness(
        x: usize,
        y: usize,
        byte_grid: *mut ByteGrid,
    ) -> *mut Command {
        let byte_grid = *Box::from_raw(byte_grid);
        Box::into_raw(Box::new(Command::CharBrightness(
            Origin(x, y),
            byte_grid,
        )))
    }

    /// Allocates a new `Command::BitmapLinear` instance.
    /// The passed `BitVec` gets deallocated in the process.
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_bitmap_linear(
        offset: Offset,
        bit_vec: *mut BitVec,
        compression: CompressionCode,
    ) -> *mut Command {
        let bit_vec = *Box::from_raw(bit_vec);
        Box::into_raw(Box::new(Command::BitmapLinear(
            offset,
            bit_vec,
            compression,
        )))
    }

    /// Allocates a new `Command::BitmapLinearAnd` instance.
    /// The passed `BitVec` gets deallocated in the process.
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_bitmap_linear_and(
        offset: Offset,
        bit_vec: *mut BitVec,
        compression: CompressionCode,
    ) -> *mut Command {
        let bit_vec = *Box::from_raw(bit_vec);
        Box::into_raw(Box::new(Command::BitmapLinearAnd(
            offset,
            bit_vec,
            compression,
        )))
    }

    /// Allocates a new `Command::BitmapLinearOr` instance.
    /// The passed `BitVec` gets deallocated in the process.
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_bitmap_linear_or(
        offset: Offset,
        bit_vec: *mut BitVec,
        compression: CompressionCode,
    ) -> *mut Command {
        let bit_vec = *Box::from_raw(bit_vec);
        Box::into_raw(Box::new(Command::BitmapLinearOr(
            offset,
            bit_vec,
            compression,
        )))
    }

    /// Allocates a new `Command::BitmapLinearXor` instance.
    /// The passed `BitVec` gets deallocated in the process.
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_bitmap_linear_xor(
        offset: Offset,
        bit_vec: *mut BitVec,
        compression: CompressionCode,
    ) -> *mut Command {
        let bit_vec = *Box::from_raw(bit_vec);
        Box::into_raw(Box::new(Command::BitmapLinearXor(
            offset,
            bit_vec,
            compression,
        )))
    }

    /// Allocates a new `Command::Cp437Data` instance.
    /// The passed `ByteGrid` gets deallocated in the process.
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_cp437_data(
        x: usize,
        y: usize,
        byte_grid: *mut ByteGrid,
    ) -> *mut Command {
        let byte_grid = *Box::from_raw(byte_grid);
        Box::into_raw(Box::new(Command::Cp437Data(Origin(x, y), byte_grid)))
    }

    /// Allocates a new `Command::BitmapLinearWin` instance.
    /// The passed `PixelGrid` gets deallocated in the process.
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_bitmap_linear_win(
        x: usize,
        y: usize,
        byte_grid: *mut PixelGrid,
        compression_code: CompressionCode,
    ) -> *mut Command {
        let byte_grid = *Box::from_raw(byte_grid);
        Box::into_raw(Box::new(Command::BitmapLinearWin(
            Origin(x, y),
            byte_grid,
            compression_code,
        )))
    }

    /// Deallocates a `Command`. Note that connection_send does this implicitly, so you only need
    /// to do this if you use the library for parsing commands.
    #[no_mangle]
    pub unsafe extern "C" fn sp2_command_dealloc(ptr: *mut Command) {
        _ = Box::from_raw(ptr);
    }
}

#[cfg(test)]
mod tests {
    use crate::command::TryFromPacketError;
    use crate::command_code::CommandCode;
    use crate::{
        BitVec, ByteGrid, Command, CompressionCode, Grid, Header, Origin,
        Packet, PixelGrid,
    };

    fn round_trip(original: Command) {
        let packet: Packet = original.clone().into();
        let copy: Command = match Command::try_from(packet) {
            Ok(command) => command,
            Err(err) => panic!("could not reload {original:?}: {err:?}"),
        };
        assert_eq!(copy, original);
    }

    fn all_compressions<'t>() -> &'t [CompressionCode] {
        &[
            CompressionCode::Uncompressed,
            #[cfg(feature = "compression_lzma")]
            CompressionCode::Lzma,
            #[cfg(feature = "compression_bzip2")]
            CompressionCode::Bzip2,
            #[cfg(feature = "compression_zlib")]
            CompressionCode::Zlib,
            #[cfg(feature = "compression_zstd")]
            CompressionCode::Zstd,
        ]
    }

    #[test]
    fn round_trip_clear() {
        round_trip(Command::Clear);
    }

    #[test]
    fn round_trip_hard_reset() {
        round_trip(Command::HardReset);
    }

    #[test]
    fn round_trip_fade_out() {
        round_trip(Command::FadeOut);
    }

    #[test]
    fn round_trip_brightness() {
        round_trip(Command::Brightness(6));
    }

    #[test]
    #[allow(deprecated)]
    fn round_trip_bitmap_legacy() {
        round_trip(Command::BitmapLegacy);
    }

    #[test]
    fn round_trip_char_brightness() {
        round_trip(Command::CharBrightness(Origin(5, 2), ByteGrid::new(7, 5)));
    }

    #[test]
    fn round_trip_cp437_data() {
        round_trip(Command::Cp437Data(Origin(5, 2), ByteGrid::new(7, 5)));
    }

    #[test]
    fn round_trip_bitmap_linear() {
        for compression in all_compressions().to_owned() {
            round_trip(Command::BitmapLinear(23, BitVec::new(40), compression));
            round_trip(Command::BitmapLinearAnd(
                23,
                BitVec::new(40),
                compression,
            ));
            round_trip(Command::BitmapLinearOr(
                23,
                BitVec::new(40),
                compression,
            ));
            round_trip(Command::BitmapLinearXor(
                23,
                BitVec::new(40),
                compression,
            ));
            round_trip(Command::BitmapLinearWin(
                Origin(0, 0),
                PixelGrid::max_sized(),
                compression,
            ));
        }
    }

    #[test]
    fn error_invalid_command() {
        let p = Packet(Header(0xFF, 0x00, 0x00, 0x00, 0x00), vec![]);
        let result = Command::try_from(p);
        assert!(matches!(
            result,
            Err(TryFromPacketError::InvalidCommand(0xFF))
        ))
    }

    #[test]
    fn error_extraneous_header_values_clear() {
        let p = Packet(
            Header(CommandCode::Clear.into(), 0x05, 0x00, 0x00, 0x00),
            vec![],
        );
        let result = Command::try_from(p);
        assert!(matches!(
            result,
            Err(TryFromPacketError::ExtraneousHeaderValues)
        ))
    }

    #[test]
    fn error_extraneous_header_values_brightness() {
        let p = Packet(
            Header(CommandCode::Brightness.into(), 0x00, 0x13, 0x37, 0x00),
            vec![5],
        );
        let result = Command::try_from(p);
        assert!(matches!(
            result,
            Err(TryFromPacketError::ExtraneousHeaderValues)
        ))
    }

    #[test]
    fn error_extraneous_header_hard_reset() {
        let p = Packet(
            Header(CommandCode::HardReset.into(), 0x00, 0x00, 0x00, 0x01),
            vec![],
        );
        let result = Command::try_from(p);
        assert!(matches!(
            result,
            Err(TryFromPacketError::ExtraneousHeaderValues)
        ))
    }

    #[test]
    fn error_extraneous_header_fade_out() {
        let p = Packet(
            Header(CommandCode::FadeOut.into(), 0x10, 0x00, 0x00, 0x01),
            vec![],
        );
        let result = Command::try_from(p);
        assert!(matches!(
            result,
            Err(TryFromPacketError::ExtraneousHeaderValues)
        ))
    }

    #[test]
    fn error_unexpected_payload() {
        let p = Packet(
            Header(CommandCode::FadeOut.into(), 0x00, 0x00, 0x00, 0x00),
            vec![5, 7],
        );
        let result = Command::try_from(p);
        assert!(matches!(
            result,
            Err(TryFromPacketError::UnexpectedPayloadSize(0, 2))
        ))
    }

    #[test]
    fn error_decompression_failed_win() {
        for compression in all_compressions().to_owned() {
            let p: Packet = Command::BitmapLinearWin(
                Origin(16, 8),
                PixelGrid::new(8, 8),
                compression,
            )
            .into();
            let Packet(header, mut payload) = p;

            // mangle it
            for byte in payload.iter_mut() {
                *byte -= *byte / 2;
            }

            let p = Packet(header, payload);
            let result = Command::try_from(p);
            if compression != CompressionCode::Uncompressed {
                assert_eq!(result, Err(TryFromPacketError::DecompressionFailed))
            } else {
                assert!(result.is_ok());
            }
        }
    }

    #[test]
    fn error_decompression_failed_and() {
        for compression in all_compressions().to_owned() {
            let p: Packet =
                Command::BitmapLinearAnd(0, BitVec::new(8), compression).into();
            let Packet(header, mut payload) = p;

            // mangle it
            for byte in payload.iter_mut() {
                *byte -= *byte / 2;
            }

            let p = Packet(header, payload);
            let result = Command::try_from(p);
            if compression != CompressionCode::Uncompressed {
                assert_eq!(result, Err(TryFromPacketError::DecompressionFailed))
            } else {
                // when not compressing, there is no way to detect corrupted data
                assert!(result.is_ok());
            }
        }
    }

    #[test]
    fn unexpected_payload_size_brightness() {
        assert_eq!(
            Command::try_from(Packet(
                Header(CommandCode::Brightness.into(), 0, 0, 0, 0),
                vec!(),
            )),
            Err(TryFromPacketError::UnexpectedPayloadSize(1, 0))
        );

        assert_eq!(
            Command::try_from(Packet(
                Header(CommandCode::Brightness.into(), 0, 0, 0, 0),
                vec!(0, 0),
            )),
            Err(TryFromPacketError::UnexpectedPayloadSize(1, 2))
        );
    }

    #[test]
    fn error_reserved_used() {
        let Packet(header, payload) = Command::BitmapLinear(
            0,
            BitVec::new(8),
            CompressionCode::Uncompressed,
        )
        .into();
        let Header(command, offset, length, sub, _reserved) = header;
        let p = Packet(Header(command, offset, length, sub, 69), payload);
        assert_eq!(
            Command::try_from(p),
            Err(TryFromPacketError::ExtraneousHeaderValues)
        );
    }

    #[test]
    fn error_invalid_compression() {
        let Packet(header, payload) = Command::BitmapLinear(
            0,
            BitVec::new(8),
            CompressionCode::Uncompressed,
        )
        .into();
        let Header(command, offset, length, _sub, reserved) = header;
        let p = Packet(Header(command, offset, length, 42, reserved), payload);
        assert_eq!(
            Command::try_from(p),
            Err(TryFromPacketError::InvalidCompressionCode(42))
        );
    }

    #[test]
    fn error_unexpected_size() {
        let Packet(header, payload) = Command::BitmapLinear(
            0,
            BitVec::new(8),
            CompressionCode::Uncompressed,
        )
        .into();
        let Header(command, offset, length, compression, reserved) = header;
        let p = Packet(
            Header(command, offset, 420, compression, reserved),
            payload,
        );
        assert_eq!(
            Command::try_from(p),
            Err(TryFromPacketError::UnexpectedPayloadSize(
                420,
                length as usize,
            ))
        );
    }

    #[test]
    fn origin_add() {
        assert_eq!(Origin(4, 2), Origin(1, 0) + Origin(3, 2));
    }
}