//go:build ignore

// Две задачи урока про функции и замыкания: обе отвечают прогоном.
//
// ЗАДАЧА 1 — ПРЕДСКАЗАТЬ ВЫВОД. Два места, где «замыкание захватывает
// значение» даёт неверный ответ, и одно, где верный: счётчик-генератор
// (у каждого вызова counter своя переменная, и замыкание меняет её);
// f(s...) передаёт тот же срез, и запись внутри видна снаружи; значение
// метода с получателем-значением копирует получатель в момент вычисления.
//
// ЗАДАЧА 2 — ОЦЕНИТЬ КРАТНОСТЬ. Сколько стоит вызов замыкания по сравнению с
// вызовом обычной функции — и сколько стоит СОЗДАТЬ замыкание, которое уходит
// наружу. Ответ нужен не ради наносекунд: он показывает, что дорог не вызов
// через значение-функцию, а выделение памяти под захваченное.
//
// ЗАМЕР. testing.Benchmark, лучший из 11 кругов. Машину делят с другими
// задачами, поэтому абсолютные наносекунды шумят от прогона к прогону;
// печатаются и сравниваются кратности к прямому вызову.
//
// ЗАПУСК:
//
//	go run bench/goclosure/practice.go
package main

import (
	"fmt"
	"runtime"
	"testing"
)

// ---------------------------------------------------------------- задача 1

func counter() func() int {
	n := 0
	return func() int { n++; return n }
}

func bump(xs ...int) { xs[0] = 10 }

type T struct{ n int }

func (t T) Get() int { return t.n }

func task1() {
	a, b := counter(), counter()
	a()
	a()
	fmt.Println(a(), b())
	s := []int{1, 2, 3}
	bump(s...)
	fmt.Println(s)
	v := T{n: 1}
	f := v.Get
	v.n = 2
	fmt.Println(f(), v.Get())
}

// ---------------------------------------------------------------- задача 2

//go:noinline
func addOne(x int) int { return x + 1 }

//go:noinline
func makeAdder(k int) func(int) int {
	return func(x int) int { return x + k }
}

var (
	sink   int
	viaVar func(int) int // обычная функция в переменной
	viaClo func(int) int // замыкание в переменной
	sinkF  func(int) int
)

type result struct {
	ns     float64
	allocs int64
}

// best — лучший из 11 кругов: минимум отсекает помехи соседей по машине, но
// не делает число свойством языка.
func best(f func(b *testing.B)) result {
	lo := result{ns: 1e18}
	for round := 0; round < 11; round++ {
		r := testing.Benchmark(func(b *testing.B) {
			b.ReportAllocs()
			f(b)
		})
		if ns := float64(r.T.Nanoseconds()) / float64(r.N); ns < lo.ns {
			lo = result{ns: ns, allocs: r.AllocsPerOp()}
		}
	}
	return lo
}

func main() {
	fmt.Println("ЗАДАЧА 1 — предсказать вывод")
	fmt.Println()
	task1()

	fmt.Println()
	fmt.Println("ЗАДАЧА 2 — цена: вызов замыкания и создание замыкания")
	fmt.Println()
	viaVar = addOne
	viaClo = makeAdder(1)

	direct := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			sink = addOne(i)
		}
	})
	fvar := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			sink = viaVar(i)
		}
	})
	clo := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			sink = viaClo(i)
		}
	})
	create := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			sinkF = makeAdder(i)
			sink = sinkF(i)
		}
	})

	row := func(label string, r result) {
		fmt.Printf("  %-40s %6.2f нс   выделений %d   кратность %5.2f\n", label, r.ns, r.allocs, r.ns/direct.ns)
	}
	row("addOne(i)        прямой вызов", direct)
	row("viaVar(i)        функция в переменной", fvar)
	row("viaClo(i)        замыкание в переменной", clo)
	row("makeAdder(i)(i)  создать и вызвать", create)
	fmt.Println()
	fmt.Printf("  вызов замыкания / прямой вызов          %5.2f\n", clo.ns/direct.ns)
	fmt.Printf("  создать и вызвать / прямой вызов        %5.2f\n", create.ns/direct.ns)
	fmt.Printf("  создать и вызвать / вызов замыкания     %5.2f\n", create.ns/clo.ns)
	fmt.Printf("  создать и вызвать / прямой, округлённо  %5.1f\n", create.ns/direct.ns)
	fmt.Println()
	fmt.Printf("  Лучший из 11 кругов. %s %s/%s, GOMAXPROCS=%d\n",
		runtime.Version(), runtime.GOOS, runtime.GOARCH, runtime.GOMAXPROCS(0))
	fmt.Println("  Машину делили с другими задачами: устойчивы кратности,")
	fmt.Println("  а не наносекунды.")
}