package pack

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

type Reader interface {
	io.Reader
	io.ByteReader
}

type Encoder struct {
	w io.Writer
}

type Decoder struct {
	r Reader
}

func NewEncoder(w io.Writer) *Encoder {
	return &Encoder{w: w}
}

func NewDecoder(r Reader) *Decoder {
	return &Decoder{r: r}
}

func (e *Encoder) Lps(b []byte) error {
	buf := make([]byte, binary.MaxVarintLen64)
	n := binary.PutVarint(buf, int64(len(b)))

	if _, err := e.w.Write(buf[:n]); err != nil {
		return err
	}

	_, err := e.w.Write(b)
	return err
}

func (d *Decoder) Lps() ([]byte, error) {
	if n, err := binary.ReadVarint(d.r); err != nil {
		return nil, fmt.Errorf("lps: %w", err)
	} else {
		buf := make([]byte, n)

		if _, err := io.ReadFull(d.r, buf); err != nil {
			if err == io.EOF {
				err = io.ErrUnexpectedEOF
			}
			return nil, fmt.Errorf("lps: %w", err)
		}

		return buf, nil
	}
}