package brotli

/* Copyright 2013 Google Inc. All Rights Reserved.

   Distributed under MIT license.
   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/

/* A ringBuffer(window_bits, tail_bits) contains `1 << window_bits' bytes of
   data in a circular manner: writing a byte writes it to:
     `position() % (1 << window_bits)'.
   For convenience, the ringBuffer array contains another copy of the
   first `1 << tail_bits' bytes:
     buffer_[i] == buffer_[i + (1 << window_bits)], if i < (1 << tail_bits),
   and another copy of the last two bytes:
     buffer_[-1] == buffer_[(1 << window_bits) - 1] and
     buffer_[-2] == buffer_[(1 << window_bits) - 2]. */
type ringBuffer struct {
	size_       uint32
	mask_       uint32
	tail_size_  uint32
	total_size_ uint32
	cur_size_   uint32
	pos_        uint32
	data_       []byte
	buffer_     []byte
}

func ringBufferInit( *ringBuffer) {
	.pos_ = 0
}

func ringBufferSetup( *encoderParams,  *ringBuffer) {
	var  int = computeRbBits()
	var  int = .lgblock
	*(*uint32)(&.size_) = 1 << uint()
	*(*uint32)(&.mask_) = (1 << uint()) - 1
	*(*uint32)(&.tail_size_) = 1 << uint()
	*(*uint32)(&.total_size_) = .size_ + .tail_size_
}

const kSlackForEightByteHashingEverywhere uint = 7

/* Allocates or re-allocates data_ to the given length + plus some slack
   region before and after. Fills the slack regions with zeros. */
func ringBufferInitBuffer( uint32,  *ringBuffer) {
	var  []byte
	var  uint
	 := 2 + int() + int(kSlackForEightByteHashingEverywhere)
	if cap(.data_) <  {
		 = make([]byte, )
	} else {
		 = .data_[:]
	}
	if .data_ != nil {
		copy(, .data_[:2+.cur_size_+uint32(kSlackForEightByteHashingEverywhere)])
	}

	.data_ = 
	.cur_size_ = 
	.buffer_ = .data_[2:]
	.data_[1] = 0
	.data_[0] = .data_[1]
	for  = 0;  < kSlackForEightByteHashingEverywhere; ++ {
		.buffer_[.cur_size_+uint32()] = 0
	}
}

func ringBufferWriteTail( []byte,  uint,  *ringBuffer) {
	var  uint = uint(.pos_ & .mask_)
	if uint32() < .tail_size_ {
		/* Just fill the tail buffer with the beginning data. */
		var  uint = uint(.size_ + uint32())
		copy(.buffer_[:], [:brotli_min_size_t(, uint(.tail_size_-uint32()))])
	}
}

/* Push bytes into the ring buffer. */
func ringBufferWrite( []byte,  uint,  *ringBuffer) {
	if .pos_ == 0 && uint32() < .tail_size_ {
		/* Special case for the first write: to process the first block, we don't
		   need to allocate the whole ring-buffer and we don't need the tail
		   either. However, we do this memory usage optimization only if the
		   first write is less than the tail size, which is also the input block
		   size, otherwise it is likely that other blocks will follow and we
		   will need to reallocate to the full size anyway. */
		.pos_ = uint32()

		ringBufferInitBuffer(.pos_, )
		copy(.buffer_, [:])
		return
	}

	if .cur_size_ < .total_size_ {
		/* Lazily allocate the full buffer. */
		ringBufferInitBuffer(.total_size_, )

		/* Initialize the last two bytes to zero, so that we don't have to worry
		   later when we copy the last two bytes to the first two positions. */
		.buffer_[.size_-2] = 0

		.buffer_[.size_-1] = 0
	}
	{
		var  uint = uint(.pos_ & .mask_)

		/* The length of the writes is limited so that we do not need to worry
		   about a write */
		ringBufferWriteTail(, , )

		if uint32(+) <= .size_ {
			/* A single write fits. */
			copy(.buffer_[:], [:])
		} else {
			/* Split into two writes.
			   Copy into the end of the buffer, including the tail buffer. */
			copy(.buffer_[:], [:brotli_min_size_t(, uint(.total_size_-uint32()))])

			/* Copy into the beginning of the buffer */
			copy(.buffer_, [.size_-uint32():][:uint32()-(.size_-uint32())])
		}
	}
	{
		var  bool = .pos_&(1<<31) != 0
		var  uint32 = (1 << 31) - 1
		.data_[0] = .buffer_[.size_-2]
		.data_[1] = .buffer_[.size_-1]
		.pos_ = (.pos_ & ) + uint32(uint32()&)
		if  {
			/* Wrap, but preserve not-a-first-lap feature. */
			.pos_ |= 1 << 31
		}
	}
}