module cbor

import io

// Stream I/O wrappers over the standard `io.Reader` / `io.Writer`
// interfaces. Use these for files, sockets, pipes — anywhere the
// payload doesn't fit cleanly in a single `[]u8`.

// encode_to serialises `val` into an internal buffer, then writes the
// bytes to `w` in a loop until everything is accepted. Errors on the
// first I/O failure.
pub fn encode_to[T](val T, mut w io.Writer, opts EncodeOpts) ! {
    bytes := encode[T](val, opts)!
    mut written := 0
    for written < bytes.len {
        n := w.write(bytes[written..])!
        if n == 0 {
            return error('cbor: writer stopped accepting bytes at ${written}/${bytes.len}')
        }
        written += n
    }
}

// decode_from reads bytes from `r` until EOF (or until
// `DecodeOpts.max_stream_bytes` is hit) and decodes a single top-level
// value. For multi-value streams, use `Unpacker` directly on a
// pre-buffered slice.
//
// Always set `max_stream_bytes` on untrusted readers — otherwise a peer
// that never sends EOF blocks the call forever.
pub fn decode_from[T](mut r io.Reader, opts DecodeOpts) !T {
    bounded := opts.max_stream_bytes > 0
    mut buf := []u8{cap: 4096}
    for {
        if bounded && buf.len >= opts.max_stream_bytes {
            return error('cbor: stream exceeded max_stream_bytes (${opts.max_stream_bytes})')
        }
        slot_len := if bounded {
            cap_left := opts.max_stream_bytes - buf.len
            if cap_left < 4096 {
                cap_left
            } else {
                4096
            }
        } else {
            4096
        }
        mut slot := []u8{len: slot_len}
        // Treat io.Eof as the legitimate end of the stream; any other
        // reader error must propagate so callers don't mistake a
        // transport failure for a successful (truncated) decode. The
        // unbounded branch used to delegate to `io.read_all`, which
        // also swallows non-EOF errors — same loop here keeps the
        // strict semantic regardless of whether `max_stream_bytes` is set.
        n := r.read(mut slot) or {
            if err is io.Eof {
                break
            }
            return err
        }
        if n == 0 {
            break
        }
        buf << slot[..n]
    }
    return decode[T](buf, opts)!
}

// pack_to is the streaming sibling of `encode_to`, for users who built
// their payload manually via the `Packer` API. Errors if any
// indefinite-length container is still open — emitting half-closed
// CBOR would produce a payload no decoder can parse.
pub fn (mut p Packer) pack_to(mut w io.Writer) ! {
    if !p.is_complete() {
        return error('cbor: pack_to called with an open indefinite-length item — close it with pack_break first')
    }
    bytes := p.bytes()
    mut written := 0
    for written < bytes.len {
        n := w.write(bytes[written..])!
        if n == 0 {
            return error('cbor: writer stopped at ${written}/${bytes.len}')
        }
        written += n
    }
}