package internal

import (
	"bytes"
	"encoding/binary"
	`io`

	`r00t2.io/sshkeys/errs`
)

/*
	ReadSizeBytes returns a uint32 allocator for a given set of data for preparation of packing into bytes.

	See SerializeData for valid types for data.

	If pack is true, the original data will be appended to the returned allocated *bytes.Reader.

	NOTE: If data is a *bytes.Reader, the bytes WILL be consumed within that reader.
*/
func ReadSizeBytes(data interface{}, pack bool) (allocated *bytes.Reader, err error) {

	var u uint32
	var b []byte
	var sizer = make([]byte, 4)

	if b, err = SerializeData(data); err != nil {
		return
	}

	u = uint32(len(b))

	if !pack {
		binary.BigEndian.PutUint32(sizer, u)
		allocated = bytes.NewReader(sizer)
	} else {
		if b, err = PackBytes(b); err != nil {
			return
		}
		allocated = bytes.NewReader(b)
	}

	return
}

/*
	PackBytes prefixes data with an allocator.

	See SerializeData for valid types for data.

	NOTE: If data is a *bytes.Reader, the bytes WILL be consumed within that reader.
*/
func PackBytes(data interface{}) (b []byte, err error) {

	var dataBytes []byte
	var size uint32

	if dataBytes, err = SerializeData(data); err != nil {
		return
	}

	size = uint32(len(dataBytes))

	b = make([]byte, size)
	binary.BigEndian.PutUint32(b, size)
	b = append(b, dataBytes...)

	return
}

/*
	UnpackBytes performs the opposite of PackBytes, reading an allocator and then reading ONLY the remaining bytes.

	NOTE: If data is a bytes.Buffer pointer, it will consume ONLY the leading prefix and the length of bytes the prefix indicates and no more.

	NOTE: If data is a *bytes.Reader, it will consume ONLY the leading prefix and the length of bytes the prefix indicates and no more.
*/
func UnpackBytes(data interface{}) (unpacked []byte, err error) {

	var sizeBytes []byte = make([]byte, 4)
	var u uint32

	// We can't use SerializeData because it'll consume the entire data set. We don't want that.
	switch t := data.(type) {
	case []byte:
		sizeBytes = t[:4]
		u = binary.BigEndian.Uint32(sizeBytes)
		unpacked = t[4:u]
	case *bytes.Buffer:
		sizeBytes = t.Next(4)
		u = binary.BigEndian.Uint32(sizeBytes)
		unpacked = t.Next(int(u))
	case bytes.Buffer:
		t2 := &t
		sizeBytes = t2.Next(4)
		u = binary.BigEndian.Uint32(sizeBytes)
		unpacked = t2.Next(int(u))
	case *bytes.Reader:
		if _, err = t.Read(sizeBytes); err != nil {
			return
		}
		u = binary.BigEndian.Uint32(sizeBytes)
		unpacked = make([]byte, u)
		if _, err = io.ReadFull(t, unpacked); err != nil {
			return
		}
	case bytes.Reader:
		t2 := &t
		if _, err = t2.Read(sizeBytes); err != nil {
			return
		}
		u = binary.BigEndian.Uint32(sizeBytes)
		unpacked = make([]byte, u)
		if _, err = io.ReadFull(t2, unpacked); err != nil {
			return
		}
	default:
		err = errs.ErrBadData
		return
	}

	return
}

/*
	SerializeData transforms one of the following types:

		- string
		- []byte
		- byte
		- bytes.Buffer
		- *bytes.Buffer
		- bytes.Reader
		- *bytes.Reader

	into a []byte.

	NOTE: If data is a *bytes.Buffer, no bytes will be consumed -- the bytes are taken in entirety without consuming them (Buffer.Bytes()).

	NOTE: If data is a *bytes.Reader, ALL bytes WILL be consumed.
*/
func SerializeData(data interface{}) (b []byte, err error) {

	switch t := data.(type) {
	case string:
		b = []byte(t)
	case byte:
		b = []byte{t}
	case []byte:
		b = t
	case *bytes.Buffer:
		b = t.Bytes()
	case bytes.Buffer:
		t2 := &t
		b = t2.Bytes()
	case *bytes.Reader:
		b = make([]byte, t.Len())
		if b, err = io.ReadAll(t); err != nil {
			return
		}
	case bytes.Reader:
		t2 := &t
		b = make([]byte, t2.Len())
		if b, err = io.ReadAll(t2); err != nil {
			return
		}
	default:
		err = errs.ErrBadData
		return
	}

	return
}