package boxio

// 块数据读写，封装了varint
// 读：首先读取数据块的可变大小，然后根据该大小，读取块数据内容，然后反序列化为具体的块对象
// 写：首先序列化块对象，然后获取该对象的大小，然后写入可变大小，最后写入块数据内容

import (
	"bufio"
	"encoding/binary"
	"io"
)

func NewBoxWriter(w io.Writer) WriteCloser {

	//return &BoxWriter{w, make([]byte, binary.MaxVarintLen64), nil}
	return &BoxWriter{w, make([]byte, binary.MaxVarintLen64)}
}

type BoxWriter struct {
	w      io.Writer
	lenBuf []byte
	//buffer []byte
}

func (that *BoxWriter) WriteBox(d BoxData) error {
	data, err := d.Marshal()
	if err != nil {
		return err
	}
	length := uint64(len(data))
	n := binary.PutUvarint(that.lenBuf, length)
	_, err = that.w.Write(that.lenBuf[:n])
	if err != nil {
		return err
	}
	_, err = that.w.Write(data)
	return err
}

func (that *BoxWriter) Close() error {
	if closer, ok := that.w.(io.Closer); ok {
		return closer.Close()
	}
	return nil
}

func NewBoxReader(r io.Reader, maxSize int) ReadCloser {
	var closer io.Closer
	if c, ok := r.(io.Closer); ok {
		closer = c
	}
	return &BoxReader{bufio.NewReader(r), nil, maxSize, closer}
}

type BoxReader struct {
	r       *bufio.Reader
	buf     []byte
	maxSize int
	closer  io.Closer
}

func (that *BoxReader) ReadBox(d BoxData) error {
	length64, err := binary.ReadUvarint(that.r)
	if err != nil {
		return err
	}
	length := int(length64)
	if length < 0 || length > that.maxSize {
		return io.ErrShortBuffer
	}
	if len(that.buf) < length {
		that.buf = make([]byte, length)
	}
	buf := that.buf[:length]
	if _, ex := io.ReadFull(that.r, buf); ex != nil {
		return ex
	}
	return d.Unmarshal(buf)
}

func (that *BoxReader) Close() error {
	if that.closer != nil {
		return that.closer.Close()
	}
	return nil
}