module binary

import io

// ByteOrder decodes and encodes fixed-size integers using a specific byte order.
pub interface ByteOrder {
    u16(b []u8) u16
    u32(b []u8) u32
    u64(b []u8) u64
    put_u16(mut b []u8, value u16)
    put_u32(mut b []u8, value u32)
    put_u64(mut b []u8, value u64)
}

// LittleEndian implements ByteOrder using little-endian encoding.
pub struct LittleEndian {}

// BigEndian implements ByteOrder using big-endian encoding.
pub struct BigEndian {}

pub const little_endian = LittleEndian{}
pub const big_endian = BigEndian{}

// u16 decodes a 16-bit unsigned integer from b using little-endian byte order.
pub fn (_ LittleEndian) u16(b []u8) u16 {
    return little_endian_u16(b)
}

// u32 decodes a 32-bit unsigned integer from b using little-endian byte order.
pub fn (_ LittleEndian) u32(b []u8) u32 {
    return little_endian_u32(b)
}

// u64 decodes a 64-bit unsigned integer from b using little-endian byte order.
pub fn (_ LittleEndian) u64(b []u8) u64 {
    return little_endian_u64(b)
}

// put_u16 encodes value into b using little-endian byte order.
pub fn (_ LittleEndian) put_u16(mut b []u8, value u16) {
    little_endian_put_u16(mut b, value)
}

// put_u32 encodes value into b using little-endian byte order.
pub fn (_ LittleEndian) put_u32(mut b []u8, value u32) {
    little_endian_put_u32(mut b, value)
}

// put_u64 encodes value into b using little-endian byte order.
pub fn (_ LittleEndian) put_u64(mut b []u8, value u64) {
    little_endian_put_u64(mut b, value)
}

// u16 decodes a 16-bit unsigned integer from b using big-endian byte order.
pub fn (_ BigEndian) u16(b []u8) u16 {
    return big_endian_u16(b)
}

// u32 decodes a 32-bit unsigned integer from b using big-endian byte order.
pub fn (_ BigEndian) u32(b []u8) u32 {
    return big_endian_u32(b)
}

// u64 decodes a 64-bit unsigned integer from b using big-endian byte order.
pub fn (_ BigEndian) u64(b []u8) u64 {
    return big_endian_u64(b)
}

// put_u16 encodes value into b using big-endian byte order.
pub fn (_ BigEndian) put_u16(mut b []u8, value u16) {
    big_endian_put_u16(mut b, value)
}

// put_u32 encodes value into b using big-endian byte order.
pub fn (_ BigEndian) put_u32(mut b []u8, value u32) {
    big_endian_put_u32(mut b, value)
}

// put_u64 encodes value into b using big-endian byte order.
pub fn (_ BigEndian) put_u64(mut b []u8, value u64) {
    big_endian_put_u64(mut b, value)
}

// read decodes fixed-size values from reader using order.
pub fn read[T](mut reader io.Reader, order ByteOrder, mut data T) ! {
    read_value(mut reader, order, mut data)!
}

// write encodes fixed-size values to writer using order.
pub fn write[T](mut writer io.Writer, order ByteOrder, data T) ! {
    write_value(mut writer, order, data)!
}

// size returns the number of bytes needed to encode data, or `-1` for unsupported types.
pub fn size[T](data T) int {
    return size_value(data)
}

fn size_value[T](data T) int {
    $if T is bool || T is u8 || T is i8 {
        return 1
    } $else $if T is u16 || T is i16 {
        return 2
    } $else $if T is u32 || T is i32 || T is f32 {
        return 4
    } $else $if T is u64 || T is i64 || T is f64 {
        return 8
    } $else $if T is $array_fixed {
        mut total := 0
        for i in 0 .. data.len {
            value_size := size_value(data[i])
            if value_size < 0 {
                return -1
            }
            total += value_size
        }
        return total
    } $else $if T is $array {
        mut total := 0
        for value in data {
            value_size := size(value)
            if value_size < 0 {
                return -1
            }
            total += value_size
        }
        return total
    } $else $if T is $struct {
        mut total := 0
        $for field in T.fields {
            if field.name == '_' {
                return -1
            }
            field_size := size(data.$(field.name))
            if field_size < 0 {
                return -1
            }
            total += field_size
        }
        return total
    } $else {
        return -1
    }
}

fn read_value[T](mut reader io.Reader, order ByteOrder, mut data T) ! {
    $if T is bool {
        mut buf := []u8{len: 1}
        read_full(mut reader, mut buf)!
        data = buf[0] != 0
    } $else $if T is u8 {
        mut buf := []u8{len: 1}
        read_full(mut reader, mut buf)!
        data = buf[0]
    } $else $if T is i8 {
        mut buf := []u8{len: 1}
        read_full(mut reader, mut buf)!
        data = i8(buf[0])
    } $else $if T is u16 {
        mut buf := []u8{len: 2}
        read_full(mut reader, mut buf)!
        data = order.u16(buf)
    } $else $if T is i16 {
        mut buf := []u8{len: 2}
        read_full(mut reader, mut buf)!
        data = i16(order.u16(buf))
    } $else $if T is u32 {
        mut buf := []u8{len: 4}
        read_full(mut reader, mut buf)!
        data = order.u32(buf)
    } $else $if T is i32 {
        mut buf := []u8{len: 4}
        read_full(mut reader, mut buf)!
        data = i32(order.u32(buf))
    } $else $if T is u64 {
        mut buf := []u8{len: 8}
        read_full(mut reader, mut buf)!
        data = order.u64(buf)
    } $else $if T is i64 {
        mut buf := []u8{len: 8}
        read_full(mut reader, mut buf)!
        data = i64(order.u64(buf))
    } $else $if T is f32 {
        mut buf := []u8{len: 4}
        read_full(mut reader, mut buf)!
        data = unsafe {
            U32_F32{
                u: order.u32(buf)
            }.f
        }
    } $else $if T is f64 {
        mut buf := []u8{len: 8}
        read_full(mut reader, mut buf)!
        data = unsafe {
            U64_F64{
                u: order.u64(buf)
            }.f
        }
    } $else $if T is $array_fixed {
        for i in 0 .. data.len {
            read_value(mut reader, order, mut data[i])!
        }
    } $else $if T is $array {
        $if T is []u8 {
            read_full(mut reader, mut data)!
        } $else {
            for i in 0 .. data.len {
                read_value(mut reader, order, mut data[i])!
            }
        }
    } $else $if T is $struct {
        $for field in T.fields {
            if field.name == '_' {
                return error('binary.read: structs with `_` fields are not supported')
            }
            read_value(mut reader, order, mut data.$(field.name))!
        }
    } $else {
        return error('binary.read: unsupported type ${typeof(data).name}')
    }
}

fn write_value[T](mut writer io.Writer, order ByteOrder, data T) ! {
    $if T is bool {
        write_full(mut writer, [u8(data)])!
    } $else $if T is u8 {
        write_full(mut writer, [u8(data)])!
    } $else $if T is i8 {
        write_full(mut writer, [u8(data)])!
    } $else $if T is u16 {
        mut buf := []u8{len: 2}
        order.put_u16(mut buf, data)
        write_full(mut writer, buf)!
    } $else $if T is i16 {
        mut buf := []u8{len: 2}
        order.put_u16(mut buf, u16(data))
        write_full(mut writer, buf)!
    } $else $if T is u32 {
        mut buf := []u8{len: 4}
        order.put_u32(mut buf, data)
        write_full(mut writer, buf)!
    } $else $if T is i32 {
        mut buf := []u8{len: 4}
        order.put_u32(mut buf, u32(data))
        write_full(mut writer, buf)!
    } $else $if T is u64 {
        mut buf := []u8{len: 8}
        order.put_u64(mut buf, data)
        write_full(mut writer, buf)!
    } $else $if T is i64 {
        mut buf := []u8{len: 8}
        order.put_u64(mut buf, u64(data))
        write_full(mut writer, buf)!
    } $else $if T is f32 {
        mut buf := []u8{len: 4}
        bits := unsafe {
            U32_F32{
                f: data
            }.u
        }
        order.put_u32(mut buf, bits)
        write_full(mut writer, buf)!
    } $else $if T is f64 {
        mut buf := []u8{len: 8}
        bits := unsafe {
            U64_F64{
                f: data
            }.u
        }
        order.put_u64(mut buf, bits)
        write_full(mut writer, buf)!
    } $else $if T is $array_fixed {
        for i in 0 .. data.len {
            write_value(mut writer, order, data[i])!
        }
    } $else $if T is $array {
        $if T is []u8 {
            write_full(mut writer, data)!
        } $else {
            for value in data {
                write_value(mut writer, order, value)!
            }
        }
    } $else $if T is $struct {
        $for field in T.fields {
            if field.name == '_' {
                return error('binary.write: structs with `_` fields are not supported')
            }
            write_value(mut writer, order, data.$(field.name))!
        }
    } $else {
        return error('binary.write: unsupported type ${typeof(data).name}')
    }
}

fn read_full(mut reader io.Reader, mut buf []u8) ! {
    mut offset := 0
    for offset < buf.len {
        n := reader.read(mut buf[offset..])!
        if n <= 0 || n > buf.len - offset {
            return error('binary.read: reader returned an invalid number of bytes')
        }
        offset += n
    }
}

fn write_full(mut writer io.Writer, buf []u8) ! {
    mut offset := 0
    for offset < buf.len {
        n := writer.write(buf[offset..])!
        if n <= 0 || n > buf.len - offset {
            return error('binary.write: writer returned an invalid number of bytes')
        }
        offset += n
    }
}