encoding/binary

import encoding.binary
import compress
import str

func write_file(scores: Vector<int>): compress.ByteBuf:
    mut b := compress.NewByteBuf()
    compress.BufPushBytes(b, "SLM1" as void*, 4)
    binary.WriteU16LE(b, 2)
    binary.WriteU32LE(b, scores.len())
    each s in scores:
        binary.WriteI32LE(b, s)
    end
    ret b
end

func read_file(data: compress.ByteBuf, size: int): str:
    mut r := compress.NewByteReader(data.data, size)
    mut head := compress.RdBytes(r, 4)
    defer compress.BufFree(head)
    if compress.BufToStrUnsafe(head) != "SLM1": ret "not our file" end
    version := binary.ReadU16LE(r)
    if version != 2: ret "unknown version " + str.FromInt(version) end
    count := binary.ReadU32LE(r)
    if count < 0 or count > 100000: ret "implausible count" end
    mut total := 0 as i64
    repeat count:
        total += binary.ReadI32LE(r) as i64
    end
    if r.bad: ret "cut short after " + str.FromInt(r.pos) + " bytes" end
    ret str.FromInt(count) + " scores, total " + str.FromInt(total)
end

func main:
    mut scores := Vector {} as Vector<int>
    scores.push(120)
    scores.push(-15)
    scores.push(98000)
    mut data := write_file(scores)
    println "file is", compress.BufLen(data), "bytes"

    println "whole file:", read_file(data, compress.BufLen(data))
    println "first 18:  ", read_file(data, 18)
    compress.BufSet(data, 4, 9)
    println "edited:    ", read_file(data, compress.BufLen(data))
    compress.BufFree(data)
end

import encoding.binary
import compress

func fake_png(): compress.ByteBuf:
    mut b := compress.NewByteBuf()
    sig := [137, 80, 78, 71, 13, 10, 26, 10]
    each x in sig:
        binary.WriteU8(b, x)
    end
    binary.WriteU32BE(b, 13)
    compress.BufPushBytes(b, "IHDR" as void*, 4)
    binary.WriteU32BE(b, 1280)
    binary.WriteU32BE(b, 720)
    binary.WriteU8(b, 8)
    binary.WriteU8(b, 6)
    ret b
end

func main:
    mut png := fake_png()
    mut r := compress.ReaderFromBuf(png)
    if binary.ReadU8(r) != 137 or binary.ReadU8(r) != 80:
        println "not a PNG"
        ret 1
    end
    repeat 6:
        _ := binary.ReadU8(r)
    end
    length := binary.ReadU32BE(r)
    mut kind := compress.RdBytes(r, 4)
    println "first chunk:", compress.BufToStrUnsafe(kind), "of", length, "bytes"
    width := binary.ReadU32BE(r)
    height := binary.ReadU32BE(r)
    println "size:", width, "x", height
    println "bit depth:", binary.ReadU8(r), "color type:", binary.ReadU8(r)
    compress.BufFree(kind)
    compress.BufFree(png)
end

import encoding.binary
import compress

func send(b &: compress.ByteBuf, msg: str):
    binary.WriteU16BE(b, msg.len())
    compress.BufPushBytes(b, msg as void*, msg.len())
end

func main:
    mut wire := compress.NewByteBuf()
    send(wire, "HELLO")
    send(wire, "سلام")
    send(wire, "")
    send(wire, "BYE")
    binary.WriteU16BE(wire, 10)
    compress.BufPushBytes(wire, "par" as void*, 3)
    println "on the wire:", compress.BufLen(wire), "bytes"

    mut r := compress.ReaderFromBuf(wire)
    until compress.RdLeft(r) >= 2:
        n := binary.ReadU16BE(r)
        if compress.RdLeft(r) < n:
            println "incomplete frame, wait for more data"
            break
        end
        mut body := compress.RdBytes(r, n)
        println n, "bytes: [" + compress.BufToStrUnsafe(body) + "]"
        compress.BufFree(body)
    end
    compress.BufFree(wire)
end

import encoding.binary
import compress
import str

func bytes_of(b: compress.ByteBuf): str:
    mut out := ""
    repeat compress.BufLen(b) in i:
        if i > 0:
            out = out + " "
        end
        out = out + str.FromInt(compress.BufGet(b, i))
    end
    ret out
end

func main:
    mut be := compress.NewByteBuf()
    binary.WriteU32BE(be, 1000)
    mut le := compress.NewByteBuf()
    binary.WriteU32LE(le, 1000)
    println "1000 big-endian:   ", bytes_of(be)
    println "1000 little-endian:", bytes_of(le)

    mut r := compress.ReaderFromBuf(le)
    println "read with the wrong order:", binary.ReadU32BE(r)

    mut big := compress.NewByteBuf()
    binary.WriteU32BE(big, -1)
    mut r2 := compress.ReaderFromBuf(big)
    v := binary.ReadU32BE(r2)
    println "u32 0xFFFFFFFF as int:", v, "as unsigned:", (v as i64) & 4294967295

    mut r3 := compress.ReaderFromBuf(be)
    _ := binary.ReadU32BE(r3)
    println "bytes left after reading:", compress.RdLeft(r3)

    compress.BufFree(big)
    compress.BufFree(le)
    compress.BufFree(be)
end