package bench

import (
	"fmt"
	"testing"
)

type Benchmark struct {
	Parallelism   int
	Data          interface{}
	TargetBuilder TargetBuilder
}

type Target struct {
	GetHeroList func() (interface{}, error)
}

type TargetBuilder struct {
	Name string
	Make func(bench Benchmark) (Target, error)
}

// func genData(n int) []*DBHero {
// 	heroes := []*DBHero{}

// 	GetList(&heroes)

// 	return heroes
// }

func compose(parallelisms, dataSize []int, builders []TargetBuilder) []Benchmark {
	benchmarks := make([]Benchmark, 0, len(parallelisms)*len(dataSize)*len(builders))
	for _, p := range parallelisms {
		for _, _ = range dataSize {
			// d := genData(k)
			for _, builder := range builders {
				benchmarks = append(benchmarks, Benchmark{
					Parallelism: p,
					// Data:          d,
					TargetBuilder: builder,
				})
			}

		}
	}

	return benchmarks
}

func RunBenchmark(b *testing.B, benchmarks []Benchmark) {
	// f, _ := os.Create("c://pprof")
	// pprof.WriteHeapProfile(f)
	// defer f.Close()
	for _, bench := range benchmarks {
		b.Run(fmt.Sprintf("%s-parallelism(%d)-", bench.TargetBuilder.Name, bench.Parallelism), func(b *testing.B) {
			target, err := bench.TargetBuilder.Make(bench)
			if err != nil {
				b.Fatalf("%s setup fail: %v", bench.TargetBuilder.Name, err)
			}
			if bench.Parallelism == 0 {
				b.ResetTimer()
				for i := 0; i < b.N; i++ {
					_, err := target.GetHeroList()
					if err != nil {
						b.Errorf("%s error during benchmark: %v", bench.TargetBuilder.Name, err)
					}
				}
			} else {
				b.SetParallelism(bench.Parallelism) //指定并行数目
				b.ResetTimer()
				b.RunParallel(func(pb *testing.PB) { //并行执行
					for pb.Next() {
						_, err := target.GetHeroList()
						if err != nil {
							b.Errorf("%s error during benchmark: %v", bench.TargetBuilder.Name, err)
						}
					}
				})
			}
			b.StopTimer()
		})
	}
}