//go:build ignore

// Две задачи урока про пакеты и один факультативный эксперимент: всё
// отвечает прогоном.
//
// ЗАДАЧА 1 — ПРЕДСКАЗАТЬ ВЫВОД. Программа из двух пакетов: main импортирует
// dep, в main переменные объявлены не в том порядке, в каком зависят друг от
// друга, и функций init две. Вывод отвечает на три вопроса сразу: кто раньше —
// зависимость или импортирующий пакет; в каком порядке инициализируются
// переменные; когда вызываются init. Программа записывается во временный
// каталог из строк ниже и запускается командой go — поэтому показанный в
// уроке код дословно есть в этом файле.
//
// ЭКСПЕРИМЕНТ (раздел 2, не задача). Сколько пакетов войдёт в программу,
// которая импортирует только fmt, и сколько из них делают работу
// инициализации. Число зависит от версии Go и конфигурации сборки, поэтому
// печатается вместе с ней: это не знание о языке, а наблюдение.
//
// ЗАДАЧА 2 (раздел 3) — ОЦЕНИТЬ ЧИСЛО. Пакеты a, b и c импортируют общий
// пакет reg, main импортирует a, b и c; в каждом из пяти пакетов одна init,
// которая печатает строку. Сколько строк init будет до main? Ответ держится
// на правиле «каждый пакет инициализируется один раз», а не на памяти.
//
// ЗАПУСК:
//
//	go run bench/gopkg/practice.go
//	/usr/local/go1.25.1/bin/go run bench/gopkg/practice.go
package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"runtime"
	"strings"
)

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

const goMod = `module example

go 1.24
`

const depGo = `
// dep/dep.go
package dep

import "fmt"

var Ready = mark("dep: var Ready")

func mark(s string) bool {
	fmt.Println(s)
	return true
}

func init() { fmt.Println("dep: init") }
`

const mainGo = `
// main.go
package main

import (
	"fmt"

	"example/dep"
)

var total = trace("total", price*qty)
var price = trace("price", 10)
var qty = trace("qty", 3)

func trace(name string, v int) int {
	fmt.Println("main: var", name)
	return v
}

func init() { fmt.Println("main: init 1, total =", total) }

func init() { fmt.Println("main: init 2") }

func main() { fmt.Println("main: main, dep.Ready =", dep.Ready) }
`

// ---------------------------------------------------------------- эксперимент

const helloGo = `package main

import "fmt"

func main() { fmt.Println("hello") }
`

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

const regGo = `package reg

import "fmt"

func init() { fmt.Println("init reg") }

func Touch() {}
`

// leafGo — пакеты a, b и c: каждый импортирует reg.
const leafGo = `package NAME

import (
	"fmt"

	"example/reg"
)

func init() {
	reg.Touch()
	fmt.Println("init NAME")
}
`

const shareMain = `package main

import (
	"fmt"

	_ "example/a"
	_ "example/b"
	_ "example/c"
)

func init() { fmt.Println("init main") }

func main() { fmt.Println("main") }
`

var goBin string

func write(dir, name, body string) {
	p := filepath.Join(dir, name)
	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
		panic(err)
	}
	if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
		panic(err)
	}
}

func command(dir string, env []string, name string, args ...string) (stdout, stderr string) {
	cmd := exec.Command(name, args...)
	cmd.Dir = dir
	cmd.Env = append(append(os.Environ(), "GOTOOLCHAIN=local", "GOFLAGS="), env...)
	var so, se strings.Builder
	cmd.Stdout, cmd.Stderr = &so, &se
	if err := cmd.Run(); err != nil {
		panic(fmt.Sprint(err, se.String()))
	}
	return so.String(), se.String()
}

func show(title string) {
	fmt.Println()
	fmt.Println(title)
	fmt.Println(strings.Repeat("─", len([]rune(title))))
}

func main() {
	goBin = filepath.Join(runtime.GOROOT(), "bin", "go")
	if _, err := os.Stat(goBin); err != nil {
		goBin = "go"
	}
	work, err := os.MkdirTemp("", "gopkg-practice")
	if err != nil {
		panic(err)
	}
	defer os.RemoveAll(work)

	fmt.Printf("%s %s/%s | пакеты: задачи урока и эксперимент\n", runtime.Version(), runtime.GOOS, runtime.GOARCH)

	show("1) ПОРЯДОК ИНИЦИАЛИЗАЦИИ: ВЫВОД ПРОГРАММЫ")
	p1 := filepath.Join(work, "p1")
	write(p1, "go.mod", goMod)
	write(p1, "dep/dep.go", depGo)
	write(p1, "main.go", mainGo)
	out, _ := command(p1, nil, goBin, "run", ".")
	fmt.Print(out)

	show("2) ЭКСПЕРИМЕНТ: СКОЛЬКО ПАКЕТОВ В ГРАФЕ СБОРКИ")
	p2 := filepath.Join(work, "p2")
	write(p2, "go.mod", goMod)
	write(p2, "main.go", helloGo)
	deps, _ := command(p2, nil, goBin, "list", "-deps", ".")
	n := len(strings.Fields(deps))
	bin := filepath.Join(work, "hello")
	command(p2, nil, goBin, "build", "-o", bin, ".")
	_, trace := command(p2, []string{"GODEBUG=inittrace=1"}, bin)
	re := regexp.MustCompile(`(?m)^init (\S+) @`)
	var withWork []string
	for _, m := range re.FindAllStringSubmatch(trace, -1) {
		withWork = append(withWork, m[1])
	}
	env, _ := command(p2, nil, goBin, "env", "GOOS", "GOARCH", "CGO_ENABLED")
	fmt.Println("программа: package main, import \"fmt\", fmt.Println(\"hello\")")
	fmt.Printf("  конфигурация: %s, GOOS/GOARCH/CGO_ENABLED = %s, GOFLAGS пуст\n",
		runtime.Version(), strings.Join(strings.Fields(env), "/"))
	fmt.Printf("  пакетов в графе сборки (go list -deps, вместе с main и unsafe): %d\n", n)
	fmt.Printf("  из них с работой инициализации (GODEBUG=inittrace=1): %d\n", len(withWork))
	fmt.Printf("  %s\n", strings.Join(withWork, " "))

	show("3) ОБЩАЯ ЗАВИСИМОСТЬ: СКОЛЬКО СТРОК init ДО main")
	p3 := filepath.Join(work, "p3")
	write(p3, "go.mod", goMod)
	write(p3, "reg/reg.go", regGo)
	for _, name := range []string{"a", "b", "c"} {
		write(p3, name+"/"+name+".go", strings.ReplaceAll(leafGo, "NAME", name))
	}
	write(p3, "main.go", shareMain)
	out, _ = command(p3, nil, goBin, "run", ".")
	fmt.Println("a, b, c импортируют reg; main импортирует a, b, c; в каждом пакете одна init")
	fmt.Print(out)
	inits := 0
	for _, l := range strings.Split(out, "\n") {
		if strings.HasPrefix(l, "init ") {
			inits++
		}
	}
	fmt.Printf("  строк init до main: %d (пакетов: 5, импортов reg: 3)\n", inits)
}