package chunkenc

// // REVERSE

// // const (
// // 	lastUnixtimeIdx = 0
// // 	baseDeltaIdx    = 4
// // )

// type ReverseTimeDeltaOfDeltaCompressor struct {
// 	buf                  *conbuf.ContinuousBuffer
// 	pos                  int
// 	lastDelta            uint32
// 	lastUnixtime         uint32
// 	lastDeltaOfDelta     int64
// 	lastDeltaOfDeltaSize int
// 	h                    byte
// }

// func NewReverseTimeDeltaOfDeltaCompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaOfDeltaCompressor {
// 	s := &ReverseTimeDeltaOfDeltaCompressor{
// 		buf: buf,
// 		pos: size,
// 	}
// 	if size > 0 {
// 		// s.lastUnixtime = s.buf.GetUint32(lastUnixtimeIdx)
// 		// u64, _, err := s.buf.GetVarUint64(baseDeltaIdx)
// 		// if err != nil {
// 		// 	log.Fatalf("bug: get base delta: %s", err)
// 		// }
// 		// s.baseDelta = uint32(u64)
// 		// s.h = s.buf.GetByte(s.pos - 1)
// 		// s.lastDeltaOfDelta, s.lastDeltaOfDeltaSize, err = s.buf.ReverseGetVarInt64(s.pos - 2)
// 		// if err != nil {
// 		// 	log.Fatalf("bug: get last delta of delta: %s", err)
// 		// }
// 	} else {
// 		//s.baseDelta = baseDelta
// 	}
// 	return s
// }

// func (s *ReverseTimeDeltaOfDeltaCompressor) Size() int {
// 	return s.pos
// }

// func (s *ReverseTimeDeltaOfDeltaCompressor) Append(unixtime uint32) {
// 	if s.lastUnixtime > 0 {
// 		if s.pos == 0 {
// 			// 2-й unixtime
// 			s.lastDelta = unixtime - s.lastUnixtime
// 			s.appendNewLiteral(0)
// 		} else {
// 			// 3-й unixtime і наступні
// 			lastDelta := unixtime - s.lastUnixtime
// 			deltaOfDelta := int64(lastDelta) - int64(s.lastDelta)
// 			if deltaOfDelta == s.lastDeltaOfDelta {
// 				if s.h < 128 {
// 					// run блок - отже треба збільшити лічильник
// 					if s.h < 127 {
// 						// increase counter
// 						s.h++
// 						s.buf.SetByte(s.pos-1, s.h)
// 					} else {
// 						// не можу збільшити - буде переповнення. Додаю новий literal блок
// 						// counter overflow
// 						// fix encode delta
// 						s.appendNewLiteral(deltaOfDelta)
// 					}
// 				} else {
// 					// literal блок.
// 					// Якщо в ньому лише одне значення - перетворюю його на run блок.
// 					// Інакше забираю останнє значення із literal блока і додаю новий run блок.
// 					q := s.h & 127
// 					if q == 0 { // 1 кодується як 0
// 						s.convertLiteralToRun()
// 					} else {
// 						s.convertLastFromLiteralToRun(deltaOfDelta)
// 					}
// 				}
// 			} else {
// 				s.lastDelta = lastDelta
// 				if s.h < 127 {
// 					// end of run
// 					s.appendNewLiteral(deltaOfDelta)
// 				} else {
// 					if s.h < 255 {
// 						// encode value from pos - 1, then append h byte
// 						s.appendDeltaToLiteral(deltaOfDelta)
// 					} else {
// 						// overflowed - encode new
// 						s.appendNewLiteral(deltaOfDelta)
// 					}
// 				}
// 			}
// 		}
// 	}
// 	// для першого unixtime - лише оновлюємо lastUnixtime, а для наступних -
// 	// теж оновлюємо, але після запису серій в buf.
// 	s.lastUnixtime = unixtime
// }

// func (s *ReverseTimeDeltaOfDeltaCompressor) convertLastFromLiteralToRun(deltaOfDelta int64) {
// 	// Зменшую кількість елементів в literal блоці
// 	s.h--
// 	s.pos -= 1 + s.lastDeltaOfDeltaSize
// 	s.buf.SetByte(s.pos, s.h) // закриваю literal блок
// 	s.pos++
// 	s.lastDeltaOfDeltaSize = s.buf.ReversePutVarInt64(s.pos, deltaOfDelta)
// 	s.pos += s.lastDeltaOfDeltaSize
// 	s.h = 0 // run блок, довжини 2
// 	s.buf.SetByte(s.pos, s.h)
// 	s.pos++
// }

// func (s *ReverseTimeDeltaOfDeltaCompressor) convertLiteralToRun() {
// 	// Знімаю flagLiteral, а лічильник 0 дорівнює 2 елементам в серії.
// 	s.h = 0
// 	s.buf.SetByte(s.pos-1, s.h)
// }

// func (s *ReverseTimeDeltaOfDeltaCompressor) appendDeltaToLiteral(deltaOfDelta int64) {
// 	s.h++ // збільшую к-сть дельт
// 	s.lastDeltaOfDelta = deltaOfDelta
// 	s.pos--
// 	s.lastDeltaOfDeltaSize = s.buf.ReversePutVarInt64(s.pos, deltaOfDelta)
// 	s.pos += s.lastDeltaOfDeltaSize
// 	s.buf.SetByte(s.pos, s.h)
// 	s.pos++
// }

// func (s *ReverseTimeDeltaOfDeltaCompressor) appendNewLiteral(deltaOfDelta int64) {
// 	s.h = flagLiteral
// 	s.lastDeltaOfDelta = deltaOfDelta
// 	s.lastDeltaOfDeltaSize = s.buf.ReversePutVarInt64(s.pos, deltaOfDelta)
// 	s.pos += s.lastDeltaOfDeltaSize
// 	s.buf.SetByte(s.pos, flagLiteral) // literal, length = 1
// 	s.pos++
// }

// func (s *ReverseTimeDeltaOfDeltaCompressor) Sync() {
// 	// дописую в кінець lastDelta та lastUnixtime
// 	if s.pos > 0 {
// 		n := s.buf.ReversePutVarUint64(s.pos, uint64(s.lastDelta))
// 		s.pos += n
// 	}
// 	if s.lastUnixtime > 0 {
// 		s.buf.PutUint32(s.pos, s.lastUnixtime)
// 		s.pos += 4
// 	}
// }

// func (s *ReverseTimeDeltaOfDeltaCompressor) DeleteLast() {

// }

// type TimeDeltaOfDeltaBound struct {
// 	LastUnixtime     uint32
// 	LastDelta        uint32
// 	Pos              int
// 	H                byte
// 	LastDeltaOfDelta int64
// }

// func (s *ReverseTimeDeltaOfDeltaCompressor) GetState() TimeDeltaOfDeltaBound {
// 	return TimeDeltaOfDeltaBound{
// 		LastUnixtime:     s.lastUnixtime,
// 		LastDelta:        s.lastDelta,
// 		Pos:              s.pos,
// 		H:                s.h,
// 		LastDeltaOfDelta: s.lastDeltaOfDelta,
// 	}
// }

// // DECOMPRESSOR

// type ReverseTimeDeltaOfDeltaDecompressor struct {
// 	buf          *conbuf.ContinuousBuffer
// 	size         int
// 	pos          int
// 	lastUnixtime uint32
// 	lastDelta    uint32
// 	//lastDeltaOfDelta int64
// 	isRun   bool
// 	pending int
// }

// func NewReverseTimeDeltaOfDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaOfDeltaDecompressor {
// 	return &ReverseTimeDeltaOfDeltaDecompressor{
// 		buf:  buf,
// 		size: size,
// 		pos:  size, // last elem
// 	}
// }

// func (s *ReverseTimeDeltaOfDeltaDecompressor) NextValue() (value uint32, done bool) {
// 	fmt.Printf("\nNextValue(): pos: %d, size: %d, pending: %d\n", s.pos, s.size, s.pending)
// 	if s.pos < s.size {
// 		if s.pending > 0 {
// 			//fmt.Println("pending", )
// 			// якщо в серії залишаються елементи
// 			fmt.Println("s.lastUnixtime -= s.lastDelta", s.lastUnixtime, s.lastDelta)
// 			s.lastUnixtime -= s.lastDelta
// 			if !s.isRun {
// 				s.readValue()
// 			}
// 			s.pending--
// 			return s.lastUnixtime, false
// 		}
// 		// FIX - читаю lastUnixtime
// 		if s.pos > 0 {
// 			s.lastUnixtime -= s.lastDelta
// 			// читаю заголовок наступної серії
// 			s.readHeader()
// 			s.readValue()
// 			s.pending--
// 			return s.lastUnixtime, false
// 		}
// 		// серія завершена - перевіряю чи є ще серії
// 		return 0, true
// 	} else {
// 		s.pos -= 4
// 		s.lastUnixtime = s.buf.GetUint32(s.pos)
// 		fmt.Println("lastUnix", s.lastUnixtime)
// 		if s.pos > 0 {
// 			s.pos--
// 			u64, n, err := s.buf.ReverseGetVarUint64(s.pos)
// 			if err != nil {
// 				log.Fatalln(err)
// 			}
// 			s.pos -= n
// 			s.lastDelta = uint32(u64)
// 			fmt.Println("lastDelta", s.lastDelta)
// 		}
// 		return s.lastUnixtime, false
// 	}
// }

// func (s *ReverseTimeDeltaOfDeltaDecompressor) readHeader() {
// 	h := s.buf.GetByte(s.pos)
// 	s.pos--
// 	s.isRun = h < 128
// 	if s.isRun {
// 		s.pending = int(h&127) + 2
// 	} else {
// 		s.pending = int(h&127) + 1
// 	}
// 	fmt.Println("h:", h)
// 	fmt.Println("isRun:", s.isRun)
// 	fmt.Println("pending:", s.pending)
// }
// func (s *ReverseTimeDeltaOfDeltaDecompressor) readValue() {
// 	//s.lastUnixtime -= s.lastDelta
// 	// var (
// 	// 	err error
// 	// 	n   int
// 	// )
// 	lastDeltaOfDelta, n, err := s.buf.ReverseGetVarInt64(s.pos)
// 	if err != nil {
// 		log.Fatalln(err)
// 	}
// 	fmt.Println()
// 	fmt.Println("read Value from pos:", s.pos)
// 	fmt.Println("delta of delta:", lastDeltaOfDelta)
// 	//fmt.Println("delta of delta n:", n)
// 	s.pos -= n
// 	s.lastDelta = uint32(int64(s.lastDelta) - lastDeltaOfDelta)
// 	fmt.Println("last delta:", s.lastDelta)
// 	fmt.Println()
// }