package boxio

// 块数据读写接口定义

import (
	"bytes"
	"encoding/binary"
	"errors"
	"io"
)

type BoxData interface {
	Unmarshal(data []byte) error
	Marshal() ([]byte, error)
	Size() int
	Tag() string
}

type Writer interface {
	WriteBox(BoxData) error
}

type WriteCloser interface {
	Writer
	io.Closer
}

type Reader interface {
	ReadBox(block BoxData) error
}

type ReadCloser interface {
	Reader
	io.Closer
}

// 基础的读写函数

type NumType uint8

const (
	Num8  NumType = 8  //1个字节
	Num16 NumType = 16 // 2个字节
	Num32 NumType = 32 // 4个字节
	Num64 NumType = 64 // 8个字节
)

// WriteData 块级别，tiny uint8，small uint16，normal uint32，big uint64；
func WriteData(buff *bytes.Buffer, data []byte, numType NumType) error {

	dataSize := len(data)
	switch numType {
	case 8:
		uSize := uint8(dataSize)
		if uSize > 0xFF {
			return errors.New("数据超出范围")
		}
		e := binary.Write(buff, binary.BigEndian, uSize)
		if e != nil {
			return e
		}
	case 16:
		uSize := uint16(dataSize)
		if uSize > 0xFFFF {
			return errors.New("数据超出范围")
		}
		e := binary.Write(buff, binary.BigEndian, uSize)
		if e != nil {
			return e
		}
	case 32:
		uSize := uint32(dataSize)
		if uSize > 0xFFFFFFFF {
			return errors.New("数据超出范围")
		}
		e := binary.Write(buff, binary.BigEndian, uSize)
		if e != nil {
			return e
		}
	case 64:
		uSize := uint64(dataSize)
		if uSize > 0xFFFFFFFFFFFFFFFF {
			return errors.New("数据超出范围")
		}
		e := binary.Write(buff, binary.BigEndian, uSize)
		if e != nil {
			return e
		}
	default:
		return errors.New("BlockLevel参数错误")
	}
	if dataSize > 0 {
		e := binary.Write(buff, binary.BigEndian, data)
		if e != nil {
			return e
		}
	}

	return nil
}

// ReadData 读一个极小块数据，块级别，tiny uint8，small uint16，normal uint32，big uint64；
func ReadData(buff *bytes.Buffer, numType NumType) ([]byte, error) {
	var dataSize int
	switch numType {
	case 8:
		dataLen := uint8(0)
		err := binary.Read(buff, binary.BigEndian, &dataLen)
		if err != nil {
			return nil, err
		}
		dataSize = int(dataLen)
	case 16:
		dataLen := uint16(0)
		err := binary.Read(buff, binary.BigEndian, &dataLen)
		if err != nil {
			return nil, err
		}
		dataSize = int(dataLen)
	case 32:
		dataLen := uint32(0)
		err := binary.Read(buff, binary.BigEndian, &dataLen)
		if err != nil {
			return nil, err
		}
		dataSize = int(dataLen)
	case 64:
		dataLen := uint32(0)
		err := binary.Read(buff, binary.BigEndian, &dataLen)
		if err != nil {
			return nil, err
		}
		dataSize = int(dataLen) // todo 数据类型转换，有溢出的风险
	default:
		return nil, errors.New("参数错误")
	}
	xData := make([]byte, dataSize)
	if dataSize > 0 {
		err := binary.Read(buff, binary.BigEndian, &xData)
		if err != nil {
			return nil, err
		}
	}
	return xData, nil
}

func ReadString(buff *bytes.Buffer, numType NumType) (string, error) {
	d, e := ReadData(buff, numType)
	if e != nil {
		return "", e
	}
	if len(d) == 0 {
		return "", nil
	}
	return string(d), nil
}

func ReadBool(buff *bytes.Buffer) (bool, error) {
	var result bool
	err := binary.Read(buff, binary.BigEndian, &result)
	if err != nil {
		return false, err
	}
	return result, nil
}

func WriteBool(buff *bytes.Buffer, b bool) error {
	e := binary.Write(buff, binary.BigEndian, &b)
	if e != nil {
		return e
	}
	return nil
}