use deku::ctx::{Endian, Order};
use deku::{DekuError, DekuWriter};
use deku::prelude::{Reader, Writer};
use deku::prelude::*;

pub fn read_pascal_string<R>(reader: &mut Reader<R>) -> core::result::Result<String, DekuError>
where
    R: deku::no_std_io::Read + deku::no_std_io::Seek,
{
    let byte_len = u32::from_reader_with_ctx(reader, Endian::Little)? as usize;
    let mut bytes = vec![0u8; byte_len];
    reader.read_bytes(byte_len, &mut bytes, Order::Msb0)?;

    String::from_utf8(bytes).map_err(|err| DekuError::Parse(err.to_string().into()))
}


pub fn write_pascal_string<W>(
    writer: &mut Writer<W>,
    value: &String,
) -> core::result::Result<(), DekuError>
where
    W: deku::no_std_io::Write + deku::no_std_io::Seek,
{
    let bytes = value.as_bytes();
    let byte_len =
        u32::try_from(bytes.len()).map_err(|_| DekuError::Parse("string too large".into()))?;

    byte_len.to_writer(writer, Endian::Little)?;
    writer.write_bytes(bytes)?;
    Ok(())
}

pub fn read_bool_u8<R>(reader: &mut Reader<R>) -> core::result::Result<bool, DekuError>
where
    R: deku::no_std_io::Read + deku::no_std_io::Seek,
{
    let value = u8::from_reader_with_ctx(reader, Endian::Little)?;
    match value {
        0 => Ok(false),
        1 => Ok(true),
        _ => Err(DekuError::Parse("invalid bool value".into())),
    }
}

pub fn write_bool_u8<W>(
    writer: &mut Writer<W>,
    value: &bool,
) -> core::result::Result<(), DekuError>
where
    W: deku::no_std_io::Write + deku::no_std_io::Seek,
{
    let encoded: u8 = if *value { 1 } else { 0 };
    encoded.to_writer(writer, Endian::Little)?;
    Ok(())
}