package server

import (
	"io"
	"bufio"
	"testing"
	"compress/gzip"
	"encoding/binary"
)

type benchCompressor func(*blockVolume) io.ReadCloser

func theirCompress(v *blockVolume) io.ReadCloser {
	rd, wr := io.Pipe()
	go func() {
		defer wr.Close()
		z := gzip.NewWriter(wr)
		defer z.Close()
		bw := bufio.NewWriter(z)
		defer bw.Flush()

		v.RLock()
		defer v.RUnlock()
		binary.Write(bw, binary.BigEndian, uint32(v.size.X*v.size.Y*v.size.Z))
		for block := range v.unsyncGetAll() {
			err := bw.WriteByte(byte(block))
			if err != nil {
				return
			}
		}
	}()
	return rd
}

func ourCompress(v *blockVolume) io.ReadCloser {
	return v.syncCompressForNetwork()
}

func doCompressorBenchmark(
		b *testing.B, c benchCompressor, v *blockVolume, testName string) {
	b.StartTimer()
	rd := c(v)
	data, err := io.ReadAll(rd)
	if err != nil {
		panic(err)
	}
	b.Logf("compressed %s to %d bytes", testName, len(data))
	b.StopTimer()
}

func doCompressorBenchmarks(b *testing.B, c benchCompressor) {
	b.StopTimer()
	var (
		v blockVolume
		size = blockPos {1024, 1024, 1024}
	)
	v.init(size)
	doCompressorBenchmark(b, c, &v, "empty")
	v.init(size)
	generateDebug(&v)
	doCompressorBenchmark(b, c, &v, "debug")
	v.init(size)
	generateFlat(&v)
	doCompressorBenchmark(b, c, &v, "flat")
	v.init(size)
	generateSphere(&v)
	doCompressorBenchmark(b, c, &v, "sphere")
}

func BenchmarkNaiveGzip(b *testing.B) {
	doCompressorBenchmarks(b, theirCompress)
	b.Logf("naive gzip compressor completed in %v", b.Elapsed())
}

func BenchmarkDeflate(b *testing.B) {
	doCompressorBenchmarks(b, ourCompress)
	b.Logf("custom deflate compressor completed in %v", b.Elapsed())
}