package parquet

import (
	

	
	
	
)

type optionalPageValues struct {
	page   *optionalPage
	values ValueReader
	offset int
}

func ( *optionalPageValues) ( []Value) ( int,  error) {
	 := .page.maxDefinitionLevel
	 := .page.definitionLevels
	 := ^int16(.page.Column())

	for  < len() && .offset < len() {
		for  < len() && .offset < len() && [.offset] !=  {
			[] = Value{
				definitionLevel: [.offset],
				columnIndex:     ,
			}
			.offset++
			++
		}

		 := 
		 := .offset
		for  < len() &&  < len() && [] ==  {
			++
			++
		}

		if  <  {
			for ,  = .values.ReadValues([:]);  > 0; -- {
				[].definitionLevel = 
				.offset++
				++
			}
			// Do not return on an io.EOF here as we may still have null values to read.
			if  != nil &&  != io.EOF {
				return , 
			}
			 = nil
		}
	}

	if .offset == len() {
		 = io.EOF
	}
	return , 
}

type repeatedPageValues struct {
	page   *repeatedPage
	values ValueReader
	offset int
}

func ( *repeatedPageValues) ( []Value) ( int,  error) {
	 := .page.maxDefinitionLevel
	 := .page.definitionLevels
	 := .page.repetitionLevels
	 := ^int16(.page.Column())

	// While we haven't exceeded the output buffer and we haven't exceeded the page size.
	for  < len() && .offset < len() {

		// While we haven't exceeded the output buffer and we haven't exceeded the
		// page size AND the current element's definitionLevel is not the
		// maxDefinitionLevel (this is a null value), Create the zero values to be
		// returned in this run.
		for  < len() && .offset < len() && [.offset] !=  {
			[] = Value{
				repetitionLevel: [.offset],
				definitionLevel: [.offset],
				columnIndex:     ,
			}
			.offset++
			++
		}

		 := 
		 := .offset
		// Get the length of the run of non-zero values to be copied.
		for  < len() &&  < len() && [] ==  {
			++
			++
		}

		// Copy all the non-zero values in this run.
		if  <  {
			for ,  = .values.ReadValues([:]);  > 0; -- {
				[].repetitionLevel = [.offset]
				[].definitionLevel = 
				.offset++
				++
			}
			if  != nil &&  != io.EOF {
				return , 
			}
			 = nil
		}
	}

	if .offset == len() {
		 = io.EOF
	}
	return , 
}

type booleanPageValues struct {
	page   *booleanPage
	offset int
}

func ( *booleanPageValues) ( []bool) ( int,  error) {
	for  < len() && .offset < int(.page.numValues) {
		[] = .page.valueAt(.offset)
		.offset++
		++
	}
	if .offset == int(.page.numValues) {
		 = io.EOF
	}
	return , 
}

func ( *booleanPageValues) ( []Value) ( int,  error) {
	for  < len() && .offset < int(.page.numValues) {
		[] = .page.makeValue(.page.valueAt(.offset))
		.offset++
		++
	}
	if .offset == int(.page.numValues) {
		 = io.EOF
	}
	return , 
}

type int32PageValues struct {
	page   *int32Page
	offset int
}

func ( *int32PageValues) ( []byte) ( int,  error) {
	,  = .ReadInt32s(unsafecast.Slice[int32]())
	return 4 * , 
}

func ( *int32PageValues) ( []int32) ( int,  error) {
	 = copy(, .page.values[.offset:])
	.offset += 
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

func ( *int32PageValues) ( []Value) ( int,  error) {
	for  < len() && .offset < len(.page.values) {
		[] = .page.makeValue(.page.values[.offset])
		.offset++
		++
	}
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

type int64PageValues struct {
	page   *int64Page
	offset int
}

func ( *int64PageValues) ( []byte) ( int,  error) {
	,  = .ReadInt64s(unsafecast.Slice[int64]())
	return 8 * , 
}

func ( *int64PageValues) ( []int64) ( int,  error) {
	 = copy(, .page.values[.offset:])
	.offset += 
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

func ( *int64PageValues) ( []Value) ( int,  error) {
	for  < len() && .offset < len(.page.values) {
		[] = .page.makeValue(.page.values[.offset])
		.offset++
		++
	}
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

type int96PageValues struct {
	page   *int96Page
	offset int
}

func ( *int96PageValues) ( []byte) ( int,  error) {
	,  = .ReadInt96s(unsafecast.Slice[deprecated.Int96]())
	return 12 * , 
}

func ( *int96PageValues) ( []deprecated.Int96) ( int,  error) {
	 = copy(, .page.values[.offset:])
	.offset += 
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

func ( *int96PageValues) ( []Value) ( int,  error) {
	for  < len() && .offset < len(.page.values) {
		[] = .page.makeValue(.page.values[.offset])
		.offset++
		++
	}
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

type floatPageValues struct {
	page   *floatPage
	offset int
}

func ( *floatPageValues) ( []byte) ( int,  error) {
	,  = .ReadFloats(unsafecast.Slice[float32]())
	return 4 * , 
}

func ( *floatPageValues) ( []float32) ( int,  error) {
	 = copy(, .page.values[.offset:])
	.offset += 
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

func ( *floatPageValues) ( []Value) ( int,  error) {
	for  < len() && .offset < len(.page.values) {
		[] = .page.makeValue(.page.values[.offset])
		.offset++
		++
	}
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

type doublePageValues struct {
	page   *doublePage
	offset int
}

func ( *doublePageValues) ( []byte) ( int,  error) {
	,  = .ReadDoubles(unsafecast.Slice[float64]())
	return 8 * , 
}

func ( *doublePageValues) ( []float64) ( int,  error) {
	 = copy(, .page.values[.offset:])
	.offset += 
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

func ( *doublePageValues) ( []Value) ( int,  error) {
	for  < len() && .offset < len(.page.values) {
		[] = .page.makeValue(.page.values[.offset])
		.offset++
		++
	}
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

type byteArrayPageValues struct {
	page   *byteArrayPage
	offset int
}

func ( *byteArrayPageValues) ( []byte) (int, error) {
	, ,  := .readByteArrays()
	return , 
}

func ( *byteArrayPageValues) ( []byte) (int, error) {
	return .ReadByteArrays()
}

func ( *byteArrayPageValues) ( []byte) (int, error) {
	, ,  := .readByteArrays()
	return , 
}

func ( *byteArrayPageValues) ( []byte) (,  int,  error) {
	 := .page.len()
	for .offset <  {
		 := .page.index(.offset)
		 := plain.ByteArrayLengthSize + len()
		if  > (len() - ) {
			break
		}
		plain.PutByteArrayLength([:], len())
		 += plain.ByteArrayLengthSize
		 += copy([:], )
		.offset++
		++
	}
	if .offset ==  {
		 = io.EOF
	} else if  == 0 && len() > 0 {
		 = io.ErrShortBuffer
	}
	return , , 
}

func ( *byteArrayPageValues) ( []Value) ( int,  error) {
	 := .page.len()
	for  < len() && .offset <  {
		[] = .page.makeValueBytes(.page.index(.offset))
		.offset++
		++
	}
	if .offset ==  {
		 = io.EOF
	}
	return , 
}

type fixedLenByteArrayPageValues struct {
	page   *fixedLenByteArrayPage
	offset int
}

func ( *fixedLenByteArrayPageValues) ( []byte) ( int,  error) {
	,  = .ReadFixedLenByteArrays()
	return  * .page.size, 
}

func ( *fixedLenByteArrayPageValues) ( []byte) (int, error) {
	return .ReadFixedLenByteArrays()
}

func ( *fixedLenByteArrayPageValues) ( []byte) ( int,  error) {
	 = copy(, .page.data[.offset:]) / .page.size
	.offset +=  * .page.size
	if .offset == len(.page.data) {
		 = io.EOF
	} else if  == 0 && len() > 0 {
		 = io.ErrShortBuffer
	}
	return , 
}

func ( *fixedLenByteArrayPageValues) ( []Value) ( int,  error) {
	for  < len() && .offset < len(.page.data) {
		[] = .page.makeValueBytes(.page.data[.offset : .offset+.page.size])
		.offset += .page.size
		++
	}
	if .offset == len(.page.data) {
		 = io.EOF
	}
	return , 
}

type uint32PageValues struct {
	page   *uint32Page
	offset int
}

func ( *uint32PageValues) ( []byte) ( int,  error) {
	,  = .ReadUint32s(unsafecast.Slice[uint32]())
	return 4 * , 
}

func ( *uint32PageValues) ( []uint32) ( int,  error) {
	 = copy(, .page.values[.offset:])
	.offset += 
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

func ( *uint32PageValues) ( []Value) ( int,  error) {
	for  < len() && .offset < len(.page.values) {
		[] = .page.makeValue(.page.values[.offset])
		.offset++
		++
	}
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

type uint64PageValues struct {
	page   *uint64Page
	offset int
}

func ( *uint64PageValues) ( []byte) ( int,  error) {
	,  = .ReadUint64s(unsafecast.Slice[uint64]())
	return 8 * , 
}

func ( *uint64PageValues) ( []uint64) ( int,  error) {
	 = copy(, .page.values[.offset:])
	.offset += 
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

func ( *uint64PageValues) ( []Value) ( int,  error) {
	for  < len() && .offset < len(.page.values) {
		[] = .page.makeValue(.page.values[.offset])
		.offset++
		++
	}
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

type be128PageValues struct {
	page   *be128Page
	offset int
}

func ( *be128PageValues) ( []Value) ( int,  error) {
	for  < len() && .offset < len(.page.values) {
		[] = .page.makeValue(&.page.values[.offset])
		.offset++
		++
	}
	if .offset == len(.page.values) {
		 = io.EOF
	}
	return , 
}

type nullPageValues struct {
	column int
	remain int
}

func ( *nullPageValues) ( []Value) ( int,  error) {
	 := ^int16(.column)
	 = [:min(.remain, len())]
	for  := range  {
		[] = Value{columnIndex: }
	}
	.remain -= len()
	if .remain == 0 {
		 = io.EOF
	}
	return len(), 
}