//go:build ignore

// Структуры и методы в Go: значение, которое копируется целиком.
//
// ЗАЧЕМ ЭТА ПРОГРАММА. Про структуры говорят «это как класс без
// наследования» — и упускают то, о чём на самом деле спрашивают: структура в
// Go — значение. Она копируется при присваивании и передаче, сравнивается
// оператором ==, если это позволяют поля, занимает в памяти столько, сколько
// велит выравнивание, а её нулевое значение может быть рабочим без всякого
// конструктора. Каждое из этих утверждений проверяется запуском.
//
// ВОСЕМЬ НАБЛЮДЕНИЙ:
//
//  1. Нулевое значение. sync.Mutex и bytes.Buffer работают без конструктора;
//     свой тип — только если так написан.
//  2. Присваивание, передача в функцию и range копируют структуру целиком.
//  3. Копия поверхностная: массив копируется, а срез, карта и указатель
//     после копии ведут на те же данные.
//  4. Сравнение == и структура ключом карты; несравнимое поле за интерфейсом —
//     паника во время выполнения (ошибки компиляции — в compile.sh).
//  5. Размер и выравнивание: порядок полей меняет unsafe.Sizeof.
//  6. Пустая структура весит 0 байт, но в конце другой структуры — нет.
//  7. Метод — функция с получателем; определённый тип не наследует методы.
//  8. Анонимная структура и присваиваемость именованной.
//
// И два раздела, добавленные после внешнего аудита 14.10.2026:
//
//  9. slices.Clone и maps.Clone тоже копируют поверхностно: вложенные срезы
//     и значения-срезы остаются общими; массив указателей копирует указатели.
//     Глубокую копию делает свой метод Clone, который знает устройство типа.
//  10. Поле-интерфейс: структура сравнима при компиляции, а сравнение и
//     вставка ключом карты паникуют, если внутри лежит срез.
//
// ЗАПУСК:
//
//	go run bench/gostruct/internals.go
package main

import (
	"bytes"
	"fmt"
	"maps"
	"reflect"
	"runtime"
	"slices"
	"strings"
	"sync"
	"time"
	"unsafe"
)

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

// panicText выполняет f и возвращает текст паники или "".
func panicText(f func()) (msg string) {
	defer func() {
		if r := recover(); r != nil {
			msg = fmt.Sprint(r)
		}
	}()
	f()
	return ""
}

// --------------------------------------------------- 1. нулевое значение

// Registry ждёт, что карту создаст конструктор. Нулевое значение — ловушка.
type Registry struct {
	names map[string]int
}

func (r *Registry) Add(name string) { r.names[name]++ }

// Stats написан так, чтобы нулевое значение было рабочим: карта создаётся
// при первой записи. Конструктор ему не нужен.
type Stats struct {
	counts map[string]int
}

func (s *Stats) Add(name string) {
	if s.counts == nil {
		s.counts = make(map[string]int)
	}
	s.counts[name]++
}

func (s *Stats) Count(name string) int { return s.counts[name] } // чтение из nil-карты законно

// ------------------------------------------------ 2–3. копия при присваивании

type Point struct{ X, Y int }

func moveRight(p Point) { p.X += 100 } // получает копию

type Bag struct {
	Name  string
	Arr   [3]int
	Slice []int
	Map   map[string]int
	Ptr   *int
}

// ------------------------------------------------------------- 4. сравнение

type Team struct {
	Name    string
	Members []string
}

type Node struct{ Val *int }

// ------------------------------------------------- 5–6. размер и выравнивание

type BoolIntBool struct {
	a bool
	b int64
	c bool
}

type IntBoolBool struct {
	b int64
	a bool
	c bool
}

type EmptyFirst struct {
	z struct{}
	n int64
}

type EmptyLast struct {
	n int64
	z struct{}
}

// ------------------------------------------------------- 7. метод — функция

type Celsius float64

func (c Celsius) Fahrenheit() float64 { return float64(c)*9/5 + 32 }

// MyDuration — новый определённый тип с тем же базовым типом int64, что у
// time.Duration. Методы time.Duration (в том числе String) он не получает.
type MyDuration time.Duration

// ------------------------------------------------- 9. Clone тоже поверхностный

// Doc — тип, которому нужна независимая копия. Его Clone документирует, что
// именно разрывается: и внешний срез, и каждый внутренний.
type Doc struct {
	Title string
	Grid  [][]int
}

// Clone возвращает копию, не делящую с d ни одного массива: внешний срез
// клонируется, и каждый внутренний — тоже.
func (d Doc) Clone() Doc {
	c := d
	c.Grid = make([][]int, len(d.Grid))
	for i, row := range d.Grid {
		c.Grid[i] = slices.Clone(row)
	}
	return c
}

// ----------------------------------------- 10. поле-интерфейс и сравнимость

type Key struct{ X any }

func main() {
	fmt.Printf("%s %s/%s | структуры и методы\n", runtime.Version(), runtime.GOOS, runtime.GOARCH)

	// ---------------------------------------------------------------- 1
	show("1) НУЛЕВОЕ ЗНАЧЕНИЕ БЕЗ КОНСТРУКТОРА")
	var mu sync.Mutex
	mu.Lock()
	fmt.Printf("  var mu sync.Mutex; mu.Lock()      -> mu.TryLock(): %v (замок уже взят)\n", mu.TryLock())
	mu.Unlock()
	var buf bytes.Buffer
	buf.WriteString("ok")
	fmt.Printf("  var buf bytes.Buffer; WriteString -> %q, Len(): %d\n", buf.String(), buf.Len())
	var s Stats
	s.Add("go")
	fmt.Printf("  var s Stats; s.Add(\"go\")          -> s.Count(\"go\"): %d\n", s.Count("go"))
	var r Registry
	fmt.Printf("  var r Registry; r.Add(\"go\")       -> паника: %s\n", panicText(func() { r.Add("go") }))
	fmt.Printf("  нулевой Bag: %+v\n", Bag{})
	fmt.Println("  Ни у одного из четырёх типов нет вызова конструктора. Mutex, Buffer")
	fmt.Println("  и Stats написаны так, что нулевое значение рабочее; Registry — нет.")

	// ---------------------------------------------------------------- 2
	show("2) ПРИСВАИВАНИЕ И ПЕРЕДАЧА КОПИРУЮТ СТРУКТУРУ")
	p := Point{X: 1, Y: 2}
	q := p
	q.X = 10
	fmt.Printf("  q := p; q.X = 10                    -> p.X = %d, q.X = %d\n", p.X, q.X)
	moveRight(p)
	fmt.Printf("  moveRight(p) прибавил 100 к копии   -> p.X = %d\n", p.X)
	pts := []Point{{1, 2}, {3, 4}}
	for _, v := range pts {
		v.X = 0
	}
	fmt.Printf("  for _, v := range pts { v.X = 0 }   -> pts[0].X = %d\n", pts[0].X)
	for i := range pts {
		pts[i].X = 0
	}
	fmt.Printf("  for i := range pts { pts[i].X = 0 } -> pts[0].X = %d\n", pts[0].X)
	pp := &p
	pp.X = 7
	fmt.Printf("  pp := &p; pp.X = 7                  -> p.X = %d (через указатель — тот же p)\n", p.X)

	// ---------------------------------------------------------------- 3
	show("3) КОПИЯ ПОВЕРХНОСТНАЯ")
	n := 1
	a := Bag{Name: "a", Arr: [3]int{1, 2, 3}, Slice: []int{1, 2, 3}, Map: map[string]int{"k": 1}, Ptr: &n}
	b := a
	b.Name = "b"
	b.Arr[0] = 99
	b.Slice[0] = 99
	b.Map["k"] = 99
	*b.Ptr = 99
	fmt.Println("  b := a, затем в b меняем всё:")
	fmt.Printf("  string  a.Name     = %q  — не изменилось\n", a.Name)
	fmt.Printf("  [3]int  a.Arr[0]   = %d    — не изменилось\n", a.Arr[0])
	fmt.Printf("  []int   a.Slice[0] = %d   — изменилось\n", a.Slice[0])
	fmt.Printf("  map     a.Map[\"k\"] = %d   — изменилось\n", a.Map["k"])
	fmt.Printf("  *int    *a.Ptr     = %d   — изменилось\n", *a.Ptr)
	fmt.Printf("  unsafe.Sizeof(a)   = %d байт: копируются заголовки, а не данные за ними\n", unsafe.Sizeof(a))

	// ---------------------------------------------------------------- 4
	show("4) СРАВНЕНИЕ == И СТРУКТУРА КЛЮЧОМ КАРТЫ")
	fmt.Printf("  Point{1, 2} == Point{1, 2}        -> %v\n", Point{1, 2} == Point{1, 2})
	grid := map[Point]string{{1, 2}: "treasure"}
	fmt.Printf("  grid[Point{1, 2}]                 -> %q\n", grid[Point{1, 2}])
	x, y := 5, 5
	fmt.Printf("  Node{&x} == Node{&y}, x == y == 5 -> %v (указатели сравниваются адресами)\n", Node{&x} == Node{&y})
	var t1, t2 any = Team{Name: "core"}, Team{Name: "core"}
	fmt.Printf("  any(Team{}) == any(Team{})        -> паника: %s\n", panicText(func() { _ = t1 == t2 }))
	byAny := map[any]int{}
	fmt.Printf("  m := map[any]int{}; m[t1] = 1     -> паника: %s\n", panicText(func() { byAny[t1] = 1 }))
	fmt.Printf("  reflect.DeepEqual(t1, t2)         -> %v\n", reflect.DeepEqual(t1, t2))
	fmt.Println("  Напрямую a == b для Team не собирается — см. compile.sh, раздел 1.")

	// ---------------------------------------------------------------- 5
	show("5) РАЗМЕР И ВЫРАВНИВАНИЕ: ПОРЯДОК ПОЛЕЙ")
	var bib BoolIntBool
	var ibb IntBoolBool
	fmt.Printf("  Alignof: bool %d, int64 %d\n", unsafe.Alignof(bib.a), unsafe.Alignof(bib.b))
	fmt.Printf("  struct{ a bool; b int64; c bool }  Sizeof %2d  смещения a=%d b=%d c=%d\n",
		unsafe.Sizeof(bib), unsafe.Offsetof(bib.a), unsafe.Offsetof(bib.b), unsafe.Offsetof(bib.c))
	fmt.Printf("  struct{ b int64; a bool; c bool }  Sizeof %2d  смещения b=%d a=%d c=%d\n",
		unsafe.Sizeof(ibb), unsafe.Offsetof(ibb.b), unsafe.Offsetof(ibb.a), unsafe.Offsetof(ibb.c))
	fmt.Printf("  полезных байт в обоих: %d; выравнивание структуры: %d\n",
		unsafe.Sizeof(bib.a)+unsafe.Sizeof(bib.b)+unsafe.Sizeof(bib.c), unsafe.Alignof(bib))

	// ---------------------------------------------------------------- 6
	show("6) ПУСТАЯ СТРУКТУРА")
	fmt.Printf("  unsafe.Sizeof(struct{}{})          %2d\n", unsafe.Sizeof(struct{}{}))
	fmt.Printf("  unsafe.Sizeof([1000]struct{}{})    %2d\n", unsafe.Sizeof([1000]struct{}{}))
	var ef EmptyFirst
	var el EmptyLast
	fmt.Printf("  struct{ z struct{}; n int64 }      %2d  (z по смещению %d)\n", unsafe.Sizeof(ef), unsafe.Offsetof(ef.z))
	fmt.Printf("  struct{ n int64; z struct{} }      %2d  (z по смещению %d)\n", unsafe.Sizeof(el), unsafe.Offsetof(el.z))
	fmt.Println("  Пустое поле в конце получает байт, а выравнивание до 8 делает")
	fmt.Println("  из него восемь: адрес &s.z не должен указывать за конец s.")

	// ---------------------------------------------------------------- 7
	show("7) МЕТОД — ФУНКЦИЯ С ПОЛУЧАТЕЛЕМ")
	fmt.Printf("  Celsius(100).Fahrenheit()          -> %v\n", Celsius(100).Fahrenheit())
	fmt.Printf("  Celsius.Fahrenheit(100)            -> %v\n", Celsius.Fahrenheit(100))
	fmt.Printf("  тип Celsius.Fahrenheit             -> %T\n", Celsius.Fahrenheit)
	d := 1500 * time.Millisecond
	fmt.Printf("  time.Duration(1.5 с)               -> %v\n", d)
	fmt.Printf("  MyDuration(1.5 с)                  -> %v (метода String нет)\n", MyDuration(d))
	_, hasString := any(MyDuration(d)).(fmt.Stringer)
	fmt.Printf("  MyDuration реализует fmt.Stringer  -> %v\n", hasString)

	// ---------------------------------------------------------------- 8
	show("8) АНОНИМНАЯ СТРУКТУРА")
	cfg := struct {
		Host string
		Port int
	}{"localhost", 8080}
	fmt.Printf("  cfg := struct{ Host string; Port int }{...} -> %+v\n", cfg)
	var pt Point = struct{ X, Y int }{1, 2}
	fmt.Printf("  var pt Point = struct{ X, Y int }{1, 2}     -> %+v\n", pt)
	fmt.Println("  Тип без имени присваивается именованному, если поля совпадают:")
	fmt.Println("  имя, тип и тег каждого поля, в том же порядке.")

	// ---------------------------------------------------------------- 9
	show("9) CLONE ТОЖЕ ПОВЕРХНОСТНЫЙ")
	flat := []int{1, 2}
	flatC := slices.Clone(flat)
	flatC[0] = 99
	fmt.Printf("  []int:            slices.Clone, c[0] = 99        -> s[0] = %d\n", flat[0])
	nested := [][]int{{1, 2}, {3, 4}}
	nestedC := slices.Clone(nested)
	nestedC[0][0] = 99
	fmt.Printf("  [][]int:          slices.Clone, c[0][0] = 99     -> s[0][0] = %d\n", nested[0][0])
	counts := map[string]int{"k": 1}
	countsC := maps.Clone(counts)
	countsC["k"] = 99
	fmt.Printf("  map[string]int:   maps.Clone, c[\"k\"] = 99        -> m[\"k\"] = %d\n", counts["k"])
	lists := map[string][]int{"k": {1, 2}}
	listsC := maps.Clone(lists)
	listsC["k"][0] = 99
	fmt.Printf("  map[string][]int: maps.Clone, c[\"k\"][0] = 99     -> m[\"k\"][0] = %d\n", lists["k"][0])
	one, two := 1, 2
	ptrs := [2]*int{&one, &two}
	ptrsC := ptrs
	*ptrsC[0] = 99
	fmt.Printf("  [2]*int:          b := a, *b[0] = 99             -> *a[0] = %d\n", *ptrs[0])
	doc := Doc{Title: "plan", Grid: [][]int{{1, 2}, {3, 4}}}
	docC := doc.Clone()
	docC.Grid[0][0] = 99
	fmt.Printf("  Doc:              doc.Clone(), c.Grid[0][0] = 99 -> doc.Grid[0][0] = %d\n", doc.Grid[0][0])
	fmt.Println("  Clone копирует один уровень: контейнер новый, элементы — те же")
	fmt.Println("  значения, и если элемент — срез, карта или указатель, данные за")
	fmt.Println("  ним общие. Глубину копии решает метод Clone самого типа.")

	// ---------------------------------------------------------------- 10
	show("10) ПОЛЕ-ИНТЕРФЕЙС: СОБИРАЕТСЯ, НО МОЖЕТ ПАНИКОВАТЬ")
	fmt.Printf("  Key{1} == Key{1}                   -> %v\n", Key{1} == Key{1})
	fmt.Printf("  Key{\"1\"} == Key{1}                 -> %v\n", Key{"1"} == Key{1})
	k1, k2 := Key{[]int{1}}, Key{[]int{1}}
	fmt.Printf("  Key{[]int{1}} == Key{[]int{1}}     -> паника: %s\n", panicText(func() { _ = k1 == k2 }))
	byKey := map[Key]int{}
	fmt.Printf("  m := map[Key]int{}; m[Key{[]int{1}}] = 1 -> паника: %s\n", panicText(func() { byKey[k1] = 1 }))
	fmt.Println("  type Key struct{ X any } сравним: компилятор пропускает и ==, и")
	fmt.Println("  ключ карты. Проверка сравнимости значения в X — во время выполнения.")
}