package main

import (
	"fmt"
	"sync"
	"time"
)

// программа засыпает на заданное время
// time.Sleep(time.Second * 2)

// func After(d Duration) <-chan Time
// создает канал, который через заданное время вернет значение
//timer := time.After(time.Second)
//<-timer // значение будет получено из канала ровно через 1 секунду

// func Tick(d Duration) <-chan Time
// создает канал, который будет посылать сигналы постоянно через
// заданный промежуток времени

/*
ticker := time.Tick(time.Second)
count := 0

for {
	<-ticker
	fmt.Println("очередной тик")
	count++
	if count == 3 {
		break
	}
}
*/

// ---------------------------------------------------------------

// type Timer

// Таймер по своей сути очень похож на результат работы After, но
// позволяет остановить или изменить время его выполнения:

// создаем новый таймер, который сработает через 1 секунду
/*
t := time.NewTimer(time.Second)

fo func() {
	<-t.C // C - канал, который должен вернуть значение через заданное время
}()
t.Stop()
*/

// пока таймер не сработал, мы может сбросить его, установив новый
// срок выполнения
// t.Reset(time.Second * 2)
// <-t.C

// ---------------------------------------------------------------

// type Ticker

// Ticker же работает как функция Tick, но может быть остановлен:
/*
func NewTicker(d Duration) *Ticker // создаем новый Ticker
func (t *Ticker) Stop() // останавливаем Ticker
*/

func main() {
	// <-work()

	tick := time.NewTicker(time.Second)
	defer tick.Stop()

	wg := new(sync.WaitGroup)

	for i := 1; i <= 5; i++ {
		wg.Add(1)
		go worker(i, tick.C, wg)
	}

	wg.Wait()
}

func work() <-chan struct{} {
	done := make(chan struct{}) // канал для синхронизации горутин

	go func() {
		// синхронизирующий канал будет закрыт,
		// когда функция завершит свою работу
		defer close(done)

		stop := time.NewTimer(time.Second)

		tick := time.NewTicker(time.Millisecond * 200)
		// освободим ресурсы, при завершении работы функции
		defer tick.Stop()

		for {
			select {
			case <-stop.C:
				// stop - Timer, который через 1 секунду даст
				// сигнал завершить работу
				return
			case <-tick.C:
				// tick -Ticker, посылающий сигнал выполнить
				// работу каждые 200 миллисекунд
				fmt.Println("тик-так")
			}
		}
	}()

	return done
}

func worker(id int, limit <-chan time.Time, wg *sync.WaitGroup) {
	defer wg.Done()
	<-limit
	fmt.Printf("worker %d выполнил работу\n", id)

}