package network

import (
	"encoding/binary"
	"io"
)

type DataReader struct {
	r io.Reader
}

func NewDataReader(r io.Reader) *DataReader {
	return &DataReader{r: r}
}

func (reader *DataReader) Byte() (byte, error) {
	var b byte

	err := binary.Read(reader.r, binary.BigEndian, &b)
	if err != nil {
		return 0, err
	}

	return b, nil
}

func (reader *DataReader) Bytes(bytesLen int) ([]byte, error) {
	retBytes := make([]byte, bytesLen)
	err := binary.Read(reader.r, binary.BigEndian, retBytes)
	if err != nil {
		return nil, err
	}

	return retBytes, nil
}

func (reader *DataReader) Uint8() (uint8, error) {
	var b uint8

	err := binary.Read(reader.r, binary.BigEndian, &b)
	if err != nil {
		return 0, err
	}

	return b, nil
}

func (reader *DataReader) Uint16() (uint16, error) {
	retBytes := make([]byte, 2)
	_, err := reader.r.Read(retBytes)
	if err != nil {
		return 0, err
	}

	return binary.BigEndian.Uint16(retBytes), nil
}

func (reader *DataReader) Uint32() (uint32, error) {
	retBytes := make([]byte, 4)
	_, err := reader.r.Read(retBytes)
	if err != nil {
		return 0, err
	}

	return binary.BigEndian.Uint32(retBytes), nil
}

func (reader *DataReader) Uint64() (uint64, error) {
	retBytes := make([]byte, 8)
	_, err := reader.r.Read(retBytes)
	if err != nil {
		return 0, err
	}

	return binary.BigEndian.Uint64(retBytes), nil
}

func (reader *DataReader) String(bytesLen int) (string, error) {
	retBytes := make([]byte, bytesLen)
	err := binary.Read(reader.r, binary.BigEndian, retBytes)
	if err != nil {
		return "", err
	}

	return string(retBytes), nil
}