//go:build ignore

// Отмена стадии конвейера: где именно стадия ждёт и какая из этих точек
// слушает ctx.Done().
//
// ЗАЧЕМ ЭТА ПРОГРАММА. В internals.go (раздел 11) стадия sqCtx читала вход
// через `for n := range in` и слушала ctx.Done() только на отправке. В той
// связке это сработало: источник countFromCtx сам закрыл свой выход по
// отмене, range в sq вышел. Но у стадии ДВЕ точки ожидания — получение из
// входа и отправка в выход, — и range отмену не слушает. Здесь обе версии
// стадии проверяются на четырёх сценариях, и завершение определяется не
// счётом горутин, а сигналом: закрылся ли выход стадии за отведённое время.
//
// СЦЕНАРИИ:
//
//  1. Обычный поток: вход 1, 2, 3 и закрыт.
//  2. Вход закрыт и пуст.
//  3. Отмена, пока вход открыт и пуст (никто не отправляет и не закрывает);
//     и то же для nil-входа.
//  4. Отмена, пока выход заблокирован (никто не читает); вход бесконечный,
//     так что выход может закрыться только по отмене.
//
// ЗАПУСК:
//
//	go run bench/gopattern/cancel.go
package main

import (
	"context"
	"fmt"
	"runtime"
	"strings"
	"time"
)

// sqRange — стадия из раздела 11 internals.go: вход через range, отмена
// только на отправке.
func sqRange(ctx context.Context, in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for n := range in {
			select {
			case out <- n * n:
			case <-ctx.Done():
				return
			}
		}
	}()
	return out
}

// sqCtx — обе точки ожидания в select с ctx.Done().
func sqCtx(ctx context.Context, in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for {
			var n int
			var ok bool
			select {
			case <-ctx.Done():
				return
			case n, ok = <-in:
				if !ok {
					return
				}
			}
			select {
			case <-ctx.Done():
				return
			case out <- n * n:
			}
		}
	}()
	return out
}

// closedWithin дочитывает out до закрытия, но не дольше d. Это и есть
// проверка завершения: стадия закрывает выход в defer, значит закрытый
// выход — сигнал, что её горутина вернулась. Таймаут здесь — не способ
// «дождаться», а граница, после которой проверка честно говорит «нет».
func closedWithin(out <-chan int, d time.Duration) ([]int, bool) {
	var got []int
	timeout := time.After(d)
	for {
		select {
		case v, ok := <-out:
			if !ok {
				return got, true
			}
			got = append(got, v)
		case <-timeout:
			return got, false
		}
	}
}

// countFrom — бесконечный вход без отмены: закрывается никогда. В сценарии 4
// это важно: выход стадии может закрыться только по ctx.Done(), а не потому,
// что кончился вход.
func countFrom() <-chan int {
	out := make(chan int)
	go func() {
		for n := 1; ; n++ {
			out <- n
		}
	}()
	return out
}

func gen(nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for _, n := range nums {
			out <- n
		}
	}()
	return out
}

type stage func(context.Context, <-chan int) <-chan int

func yesno(b bool) string {
	if b {
		return "да"
	}
	return "НЕТ"
}

func main() {
	fmt.Printf("%s %s/%s | отмена стадии конвейера: две точки ожидания\n",
		runtime.Version(), runtime.GOOS, runtime.GOARCH)
	const wait = 500 * time.Millisecond
	stages := []struct {
		name string
		f    stage
	}{{"СТАДИЯ sqRange: RANGE ПО ВХОДУ, SELECT ТОЛЬКО НА ОТПРАВКЕ", sqRange}, {"СТАДИЯ sqCtx: SELECT И НА ПОЛУЧЕНИИ, И НА ОТПРАВКЕ", sqCtx}}

	for i, st := range stages {
		title := fmt.Sprintf("%d) %s", i+1, st.name)
		fmt.Println()
		fmt.Println(title)
		fmt.Println(strings.Repeat("─", len([]rune(title))))

		// 1. Обычный поток.
		{
			ctx, cancel := context.WithCancel(context.Background())
			got, ok := closedWithin(st.f(ctx, gen(1, 2, 3)), wait)
			cancel()
			fmt.Printf("  обычный поток 1, 2, 3:            получено %v, выход закрыт: %s\n", got, yesno(ok))
		}
		// 2. Вход закрыт и пуст.
		{
			ctx, cancel := context.WithCancel(context.Background())
			in := make(chan int)
			close(in)
			_, ok := closedWithin(st.f(ctx, in), wait)
			cancel()
			fmt.Printf("  вход закрыт и пуст:               выход закрыт: %s\n", yesno(ok))
		}
		// 3. Отмена при открытом пустом входе.
		{
			ctx, cancel := context.WithCancel(context.Background())
			in := make(chan int) // никто не отправляет и не закрывает
			out := st.f(ctx, in)
			cancel()
			_, ok := closedWithin(out, wait)
			fmt.Printf("  отмена, вход открыт и пуст:       выход закрыт за 500 мс: %s\n", yesno(ok))
		}
		{
			ctx, cancel := context.WithCancel(context.Background())
			var in chan int // nil: получение из него ждёт вечно
			out := st.f(ctx, in)
			cancel()
			_, ok := closedWithin(out, wait)
			fmt.Printf("  отмена, вход nil:                 выход закрыт за 500 мс: %s\n", yesno(ok))
		}
		// 4. Отмена при заблокированном выходе.
		{
			ctx, cancel := context.WithCancel(context.Background())
			out := st.f(ctx, countFrom())
			// Даём стадии получить 1 и встать на отправке 1: читать выход
			// пока некому. Это не гарантия завершения — только постановка
			// сценария; проверка ниже от неё не зависит: вход бесконечный,
			// так что закрыться выход может только по отмене.
			time.Sleep(50 * time.Millisecond)
			cancel()
			_, ok := closedWithin(out, wait)
			fmt.Printf("  отмена, выход никто не читает:    выход закрыт за 500 мс: %s\n", yesno(ok))
		}
	}

	fmt.Println()
	fmt.Println("  cancel() — сигнал, а не остановка: стадия выходит, только если в")
	fmt.Println("  момент ожидания слушает ctx.Done(). range по входу его не слушает.")
}