module binary

import io

struct ChunkedReader {
    data  []u8
    chunk int = 1
mut:
    offset int
}

fn (mut r ChunkedReader) read(mut buf []u8) !int {
    if r.offset >= r.data.len {
        return io.Eof{}
    }
    mut n := if r.chunk > 0 && r.chunk < buf.len { r.chunk } else { buf.len }
    remaining := r.data.len - r.offset
    if remaining < n {
        n = remaining
    }
    copy(mut buf[..n], r.data[r.offset..r.offset + n])
    r.offset += n
    return n
}

struct ChunkedWriter {
    chunk int = 1
mut:
    data []u8
}

fn (mut w ChunkedWriter) write(buf []u8) !int {
    if buf.len == 0 {
        return 0
    }
    n := if w.chunk > 0 && w.chunk < buf.len { w.chunk } else { buf.len }
    w.data << buf[..n]
    return n
}

struct Packet {
    flag    bool
    count   u16
    values  [2]u32
    sample  f32
    trailer [3]u8
}

struct UnsupportedPacket {
    name string
}

fn test_stream_write_and_read_struct() {
    packet := Packet{
        flag:    true
        count:   0x1234
        values:  [u32(0x11223344), 0x55667788]!
        sample:  f32(12.5)
        trailer: [u8(1), 2, 3]!
    }
    mut writer := ChunkedWriter{
        chunk: 3
    }
    write(mut writer, big_endian, packet)!
    assert size(packet) == writer.data.len

    mut reader := ChunkedReader{
        data:  writer.data.clone()
        chunk: 2
    }
    mut decoded := Packet{}
    read(mut reader, big_endian, mut decoded)!
    assert decoded == packet
}

fn test_stream_read_and_write_slice() {
    values := [u16(0x0102), 0x0304, 0x0506]
    mut writer := ChunkedWriter{
        chunk: 2
    }
    write(mut writer, little_endian, values)!
    assert size(values) == 6

    mut reader := ChunkedReader{
        data:  writer.data.clone()
        chunk: 1
    }
    mut decoded := []u16{len: values.len}
    read(mut reader, little_endian, mut decoded)!
    assert decoded == values
}

fn test_stream_read_and_write_bytes() {
    bytes := [u8(9), 8, 7, 6, 5]
    mut writer := ChunkedWriter{
        chunk: 4
    }
    write(mut writer, little_endian, bytes)!

    mut reader := ChunkedReader{
        data:  writer.data.clone()
        chunk: 2
    }
    mut decoded := []u8{len: bytes.len}
    read(mut reader, little_endian, mut decoded)!
    assert decoded == bytes
}

fn test_stream_short_read_returns_eof() {
    mut reader := ChunkedReader{
        data:  [u8(1), 2]
        chunk: 1
    }
    mut value := u32(0)
    if _ := read(mut reader, little_endian, mut value) {
        assert false
    } else {
        assert err is io.Eof
    }
}

fn test_stream_reports_unsupported_types() {
    assert size('hello') == -1
    assert size(UnsupportedPacket{}) == -1

    mut writer := ChunkedWriter{}
    if _ := write(mut writer, little_endian, 'hello') {
        assert false
    } else {
        assert err.msg() == 'binary.write: unsupported type string'
    }
}