// Package plain implements the PLAIN parquet encoding.
//
// https://github.com/apache/parquet-format/blob/master/Encodings.md#plain-plain--0
package plain

import (
	
	
	
	

	
	
	
	
)

const (
	ByteArrayLengthSize = 4
	MaxByteArrayLength  = math.MaxInt32
)

type Encoding struct {
	encoding.NotSupported
}

func ( *Encoding) () string {
	return "PLAIN"
}

func ( *Encoding) () format.Encoding {
	return format.Plain
}

func ( *Encoding) ( []byte,  []byte) ([]byte, error) {
	return append([:0], ...), nil
}

func ( *Encoding) ( []byte,  []deprecated.Int96) ([]byte, error) {
	return append([:0], unsafecast.Slice[byte]()...), nil
}

func ( *Encoding) ( []byte,  []byte,  []uint32) ([]byte, error) {
	 = [:0]

	if len() > 0 {
		 := [0]

		for ,  := range [1:] {
			 = AppendByteArray(, [::])
			 = 
		}
	}

	return , nil
}

func ( *Encoding) ( []byte,  []byte,  int) ([]byte, error) {
	if  < 0 ||  > encoding.MaxFixedLenByteArraySize {
		return [:0], encoding.Error(, encoding.ErrInvalidArgument)
	}
	return append([:0], ...), nil
}

func ( *Encoding) ( []byte,  []byte) ([]byte, error) {
	return append([:0], ...), nil
}

func ( *Encoding) ( []deprecated.Int96,  []byte) ([]deprecated.Int96, error) {
	if (len() % 12) != 0 {
		return , encoding.ErrDecodeInvalidInputSize(, "INT96", len())
	}
	return append([:0], unsafecast.Slice[deprecated.Int96]()...), nil
}

func ( *Encoding) ( []byte,  []byte,  []uint32) ([]byte, []uint32, error) {
	,  = [:0], [:0]

	for  := 0;  < len(); {
		if (len() - ) < ByteArrayLengthSize {
			return , , ErrTooShort(len())
		}
		 := ByteArrayLength([:])
		if  > (len() - ByteArrayLengthSize) {
			return , , ErrTooShort(len())
		}
		 += ByteArrayLengthSize
		 = append(, uint32(len()))
		 = append(, [:+]...)
		 += 
	}

	return , append(, uint32(len())), nil
}

func ( *Encoding) ( []byte,  []byte,  int) ([]byte, error) {
	if  < 0 ||  > encoding.MaxFixedLenByteArraySize {
		return , encoding.Error(, encoding.ErrInvalidArgument)
	}
	if (len() % ) != 0 {
		return , encoding.ErrDecodeInvalidInputSize(, "FIXED_LEN_BYTE_ARRAY", len())
	}
	return append([:0], ...), nil
}

func ( *Encoding) ( []byte) int {
	return len()
}

func ( *Encoding) () bool {
	return true
}

func ( bool) []byte { return AppendBoolean(nil, 0, ) }

func ( int32) []byte { return AppendInt32(nil, ) }

func ( int64) []byte { return AppendInt64(nil, ) }

func ( deprecated.Int96) []byte { return AppendInt96(nil, ) }

func ( float32) []byte { return AppendFloat(nil, ) }

func ( float64) []byte { return AppendDouble(nil, ) }

func ( []byte) []byte { return AppendByteArray(nil, ) }

func ( []byte,  int,  bool) []byte {
	 :=  / 8
	 :=  % 8

	if cap() >  {
		 = [:+1]
	} else {
		 := make([]byte, +1, 2*(+1))
		copy(, )
		 = 
	}

	 := uint()
	 := byte(0)
	if  {
		 = 1
	}

	[] = ([] & ^(1 << )) | ( << )
	return 
}

func ( []byte,  int32) []byte {
	 := [4]byte{}
	binary.LittleEndian.PutUint32([:], uint32())
	return append(, [:]...)
}

func ( []byte,  int64) []byte {
	 := [8]byte{}
	binary.LittleEndian.PutUint64([:], uint64())
	return append(, [:]...)
}

func ( []byte,  deprecated.Int96) []byte {
	 := [12]byte{}
	binary.LittleEndian.PutUint32([0:4], [0])
	binary.LittleEndian.PutUint32([4:8], [1])
	binary.LittleEndian.PutUint32([8:12], [2])
	return append(, [:]...)
}

func ( []byte,  float32) []byte {
	 := [4]byte{}
	binary.LittleEndian.PutUint32([:], math.Float32bits())
	return append(, [:]...)
}

func ( []byte,  float64) []byte {
	 := [8]byte{}
	binary.LittleEndian.PutUint64([:], math.Float64bits())
	return append(, [:]...)
}

func (,  []byte) []byte {
	 := [ByteArrayLengthSize]byte{}
	PutByteArrayLength([:], len())
	 = append(, [:]...)
	 = append(, ...)
	return 
}

func ( []byte,  string) []byte {
	 := [ByteArrayLengthSize]byte{}
	PutByteArrayLength([:], len())
	 = append(, [:]...)
	 = append(, ...)
	return 
}

func ( []byte,  int) []byte {
	 := [ByteArrayLengthSize]byte{}
	PutByteArrayLength([:], )
	return append(, [:]...)
}

func ( []byte) int {
	return int(binary.LittleEndian.Uint32())
}

func ( []byte,  int) {
	binary.LittleEndian.PutUint32(, uint32())
}

func ( []byte,  func([]byte) error) ( error) {
	for len() > 0 {
		var  []byte
		if , ,  = NextByteArray();  != nil {
			return 
		}
		if  = ();  != nil {
			return 
		}
	}
	return nil
}

func ( []byte) (,  []byte,  error) {
	if len() < ByteArrayLengthSize {
		return nil, , ErrTooShort(len())
	}
	 := ByteArrayLength()
	if  > (len() - ByteArrayLengthSize) {
		return nil, , ErrTooShort(len())
	}
	if  > MaxByteArrayLength {
		return nil, , ErrTooLarge()
	}
	 += ByteArrayLengthSize
	return [ByteArrayLengthSize::], [:len():len()], nil
}

func ( int) error {
	return fmt.Errorf("input of length %d is too short to contain a PLAIN encoded byte array value: %w", , io.ErrUnexpectedEOF)
}

func ( int) error {
	return fmt.Errorf("byte array of length %d is too large to be encoded", )
}