package main

import (
	"fmt"
	"github.com/anytypeio/go-anytype-infrastructure-experiments/cmd/benchmarks/db"
	"net/http"
	_ "net/http/pprof"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func main() {
	go func() {
		fmt.Println(http.ListenAndServe("localhost:6060", nil))
	}()
	//bench(db.NewBadgerSpaceCreator, options{
	bench(db.NewPogrebSpaceCreator, options{
		numSpaces:         1000,
		numEntriesInSpace: 100,
		numChangesInTree:  10,
		numHeadUpdates:    100,
		defValueSize:      1000,
		lenHeadUpdate:     10,
	})
}

type options struct {
	numSpaces         int
	numEntriesInSpace int
	numChangesInTree  int
	numHeadUpdates    int
	defValueSize      int
	lenHeadUpdate     int
}

func bench(factory db.SpaceCreatorFactory, opts options) {
	spaceIdKey := func(n int) string {
		return fmt.Sprintf("space%d", n)
	}
	treeIdKey := func(n int) string {
		return fmt.Sprintf("tree%d", n)
	}
	changeIdKey := func(n int) string {
		return fmt.Sprintf("change%d", n)
	}

	var byteSlice []byte
	for i := 0; i < opts.defValueSize; i++ {
		byteSlice = append(byteSlice, byte('a'))
	}

	var headUpdate string
	for i := 0; i < opts.lenHeadUpdate; i++ {
		headUpdate += "a"
	}

	creator := factory()
	// creating spaces
	now := time.Now()
	var spaces []db.Space
	for i := 0; i < opts.numSpaces; i++ {
		sp, err := creator.CreateSpace(spaceIdKey(i))
		if err != nil {
			panic(err)
		}
		err = sp.Close()
		if err != nil {
			panic(err)
		}
	}
	fmt.Println(opts.numSpaces, "spaces creation, spent ms", time.Now().Sub(now).Milliseconds())
	now = time.Now()
	// creating trees
	var trees []db.Tree
	for i := 0; i < opts.numSpaces; i++ {
		space, err := creator.GetSpace(spaceIdKey(i))
		if err != nil {
			panic(err)
		}
		spaces = append(spaces, space)
		for j := 0; j < opts.numEntriesInSpace; j++ {
			tr, err := space.CreateTree(treeIdKey(j))
			if err != nil {
				panic(err)
			}
			trees = append(trees, tr)
		}
	}
	fmt.Println(opts.numSpaces*opts.numEntriesInSpace, "trees creation, spent ms", time.Now().Sub(now).Milliseconds())
	now = time.Now()

	// filling entries and updating heads
	for _, t := range trees {
		for i := 0; i < opts.numChangesInTree; i++ {
			err := t.AddChange(changeIdKey(i), byteSlice)
			if err != nil {
				panic(err)
			}
		}
		for i := 0; i < opts.numHeadUpdates; i++ {
			err := t.UpdateHead(headUpdate)
			if err != nil {
				panic(err)
			}
		}
	}
	total := opts.numSpaces * opts.numEntriesInSpace * opts.numChangesInTree
	fmt.Println(total, "changes creation, spent ms", time.Now().Sub(now).Milliseconds())
	now = time.Now()

	// getting some values from tree
	for _, t := range trees {
		for i := 0; i < opts.numChangesInTree; i++ {
			res, err := t.GetChange(changeIdKey(i))
			if err != nil {
				panic(err)
			}
			if res == nil {
				panic("shouldn't be empty")
			}
		}
	}
	fmt.Println(total, "changes getting, spent ms", time.Now().Sub(now).Milliseconds())
	now = time.Now()

	// getting some values from tree
	for _, t := range trees {
		for i := 0; i < opts.numChangesInTree; i++ {
			b, err := t.HasChange(changeIdKey(i))
			if err != nil {
				panic(err)
			}
			if !b {
				panic("should be able to check with has")
			}
		}
	}
	fmt.Println(total, "changes checking, spent ms", time.Now().Sub(now).Milliseconds())

	exit := make(chan os.Signal, 1)
	signal.Notify(exit, os.Interrupt, syscall.SIGKILL, syscall.SIGTERM, syscall.SIGQUIT)
	sig := <-exit
	for _, sp := range spaces {
		err := sp.Close()
		if err != nil {
			panic(err)
		}
	}
	err := creator.Close()
	if err != nil {
		panic(err)
	}
	fmt.Println(sig)
}