package main

import (
	"bytes"
	"os"
	"sort"

	"github.com/klauspost/compress/zstd"
)

func buildEncoder() *zstd.Encoder {
	level := zstd.SpeedBestCompression

	opts := []zstd.EOption{
		// Set the compression level configured.
		zstd.WithEncoderLevel(level),
		// Disable CRC, we have enough checks in place, makes the
		// compressed data four bytes shorter.
		zstd.WithEncoderCRC(false),
		// Set a window of 512kbyte, so we have good lookbehind for usual
		// blob sizes.
		zstd.WithWindowSize(512 * 1024),
	}

	enc, err := zstd.NewWriter(nil, opts...)
	if err != nil {
		panic(err)
	}
	return enc
}

func buildDecoder() *zstd.Decoder {
	opts := []zstd.DOption{
		// Use all available cores.
		zstd.WithDecoderConcurrency(0),
		// Limit the maximum decompressed memory. Set to a very high,
		// conservative value.
		zstd.WithDecoderMaxMemory(16 * 1024 * 1024 * 1024),
	}

	dec, err := zstd.NewReader(nil, opts...)
	if err != nil {
		panic(err)
	}
	return dec
}

var enc = buildEncoder()
var dec = buildDecoder()

func verifyCompression(data []byte) bool {
	compressed := enc.EncodeAll(data, nil)
	decompressed, err := dec.DecodeAll(compressed, make([]byte, 0, len(data)))
	if err != nil {
		panic(err)
	}

	return bytes.Equal(data, decompressed)
}

func main() {
	data, err := os.ReadFile(os.Args[1])
	if err != nil {
		panic(err)
	}

	idx := sort.Search(len(data), func(i int) bool {
		return !verifyCompression(data[:i])
	})
	if verifyCompression(data[:idx]) {
		panic("missing compression error")
	}

	startIdx := sort.Search(idx, func(i int) bool {
		return verifyCompression(data[i:idx])
	}) - 1
	if verifyCompression(data[startIdx:idx]) {
		panic("missing compression error")
	}

	println("minimal example from", startIdx, "to", idx)

	f, err := os.OpenFile(os.Args[1]+"-minimized", os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0666)
	if err != nil {
		panic(err)
	}
	_, err = f.Write(data[startIdx:idx])
	if err != nil {
		panic(err)
	}
	err = f.Close()
	if err != nil {
		panic(err)
	}
}