//go:build ignore

// Две задачи урока про встраивание: обе отвечают прогоном.
//
// ЗАДАЧА 1 — ПРЕДСКАЗАТЬ ВЫВОД. Три места, где встраивание ведёт себя не как
// наследование: поднятый метод вызывает метод своего типа, а не внешнего;
// встроенный T не поднимает методы с получателем-указателем в набор методов
// значения; два одноимённых поля на одной глубине пропадают из JSON молча.
//
// ЗАДАЧА 2 — ОЦЕНИТЬ КРАТНОСТЬ. Во сколько раз вызов метода, поднятого из
// встроенного *T, дороже прямого вызова того же метода. Ответ нужен не ради
// наносекунд: он показывает, что встраивание — решение компилятора о путях
// к полю, а не механизм, работающий во время выполнения.
//
// ЗАПУСК:
//
//	go run bench/goembed/practice.go
package main

import (
	"encoding/json"
	"fmt"
	"runtime"
	"testing"
)

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

type Base struct{}

func (Base) Name() string       { return "Base" }
func (b Base) Describe() string { return "describe: " + b.Name() }

type Derived struct{ Base }

func (Derived) Name() string { return "Derived" }

type Saver interface{ Save() string }
type Store struct{}

func (s *Store) Save() string { return "saved" }

type ByValue struct{ Store }

type Audit struct{ ID int }
type Owner struct{ ID int }
type Doc struct {
	Audit
	Owner
	Title string
}

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

type Engine struct{ rpm int }

//go:noinline
func (e *Engine) Rev() int { e.rpm++; return e.rpm }

type Car struct {
	*Engine
	brand string
}

var sink int

func best(f func(b *testing.B)) float64 {
	lo := 1e18
	for round := 0; round < 7; round++ {
		r := testing.Benchmark(f)
		if ns := float64(r.T.Nanoseconds()) / float64(r.N); ns < lo {
			lo = ns
		}
	}
	return lo
}

func main() {
	fmt.Println("ЗАДАЧА 1 — предсказать вывод")
	fmt.Println()
	d := Derived{}
	fmt.Println(d.Name())
	fmt.Println(d.Describe())
	_, ok := any(ByValue{}).(Saver)
	fmt.Println(ok)
	b, _ := json.Marshal(Doc{Audit{1}, Owner{2}, "report"})
	fmt.Println(string(b))

	fmt.Println()
	fmt.Println("ЗАДАЧА 2 — во сколько раз поднятый метод дороже прямого вызова")
	fmt.Println()
	e := &Engine{}
	c := Car{Engine: &Engine{}, brand: "x"}
	direct := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			sink = e.Rev()
		}
	})
	promoted := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			sink = c.Rev()
		}
	})
	fmt.Printf("  e.Rev()  прямой вызов                 %5.2f нс\n", direct)
	fmt.Printf("  c.Rev()  поднят из встроенного *Engine %5.2f нс\n", promoted)
	fmt.Printf("  кратность                             %5.2f\n", promoted/direct)
	fmt.Printf("  она же округлённо                     %5.1f\n", promoted/direct)
	fmt.Println()
	fmt.Printf("  Лучший из 7 кругов. %s %s/%s, GOMAXPROCS=%d\n",
		runtime.Version(), runtime.GOOS, runtime.GOARCH, runtime.GOMAXPROCS(0))
	fmt.Println()
	fmt.Println("  c.Rev() — это c.Engine.Rev(): путь к методу выбирается при")
	fmt.Println("  компиляции, по глубине. Во время выполнения нет ни поиска по")
	fmt.Println("  цепочке «родителей», ни таблицы методов — разница в пределах шума.")
}