wartank/pkg/components/section/down_time/down_time.go

// package down_time -- счётчик обратного времени в мсек
package down_time

import (
	"context"
	"fmt"

	// "log"
	"sync"
	"time"

	"wartank/pkg/alias"
	"wartank/pkg/components/parser_time"
	"wartank/pkg/components/safe_bool"
	"wartank/pkg/components/safe_int"
	"wartank/pkg/types"
)

const (
	спатьИнтервал = time.Millisecond * 100 // Малый интервал сна в 100 мсек
)

// ВремОбрат -- счётчик обратного времени для игровой зоны (анга, база, битва и т.п.)
type ВремОбрат struct {
	сцена types.ИСцена // Сцена, которой принадлежит отсчёт времени

	остатПарсер types.ИПарсерВремя // Парсер значения (мсек)

	остатЗнач    *safe_int.БезопЦелое // Фактическое значение счётчика в мсек
	порогЗнач    *safe_int.БезопЦелое // Целевое время срабатывания в мсек
	еслиРаботает *safe_bool.БезопБул  // Признак работы

	канТик   chan int // Канал секундных интервалов сна (для отображения)
	канВызов chan int // Канал для отправки сигналов (для верхнего уровня)

	кнт      context.Context // Контекст для счётчика времени
	фнОтмена func()          // Функция отмены контекста для счётчика времени

	блок sync.RWMutex
}

// НовВремОбрат -- возвращает новый *CountTime
func НовВремОбрат(сцена types.ИСцена, время alias.МилСек) *ВремОбрат {
	if сцена == nil {
		panic("НовВремОбрат(): ИСцена == nil")
	}
	кнт, фнОтмена := context.WithCancel(сцена.Кнт())
	сам := &ВремОбрат{
		сцена:        сцена,
		остатЗнач:    safe_int.НовБезопЦелое(),
		канТик:       make(chan int, 5),
		канВызов:     make(chan int, 2),
		еслиРаботает: safe_bool.НовБезопБул(),
		остатПарсер:  parser_time.НовПарсерВремя(),
		порогЗнач:    safe_int.НовБезопЦелое(),
		кнт:          кнт,
		фнОтмена:     фнОтмена,
	}
	мСек := alias.МилСек(time.Now().UTC().UnixMilli()) + время
	сам.порогЗнач.Уст(int(мСек))
	сам.еслиРаботает.Уст()
	go сам.сделатьТик()
	go сам.пуск()
	go сам.закрыть()
	_ = types.ИВремяОстат(сам)
	return сам
}

// ПолучМилСек -- возвращает оставшееся хранимое время остатка
func (сам *ВремОбрат) ПолучМилСек() alias.МилСек {
	return сам.остатПарсер.ПолучМилСек()
}

// Запускает тикер для интервалов сна (через каждые 100 мСек)
func (сам *ВремОбрат) сделатьТик() {
	defer close(сам.канТик)
	for {
		select {
		case <-сам.кнт.Done(): // Отмена контекста тикера (а может и сцены, может и бота)
			return
		default:
			time.Sleep(спатьИнтервал)
			if !сам.еслиРаботает.Получ() {
				сам.фнОтмена()
				return
			}
			timeNow := time.Now().UTC().Unix()
			if сам.порогЗнач.Получ() < int(timeNow) {
				continue
			}
			сам.канТик <- 1
			сам.фнОтмена()
			сам.еслиРаботает.Сброс()
			return
		}
	}
}

// Главный цикл обратного отсчёта
func (сам *ВремОбрат) пуск() {
	for range сам.канТик {
		close(сам.канВызов)
		сам.фнОтмена()
		return
	}
}

// Сброс -- сбрасывает оставшееся время в ноль
func (сам *ВремОбрат) Сброс() {
	сам.остатПарсер.Сброс()
	сам.остатЗнач.Сброс()
	сам.порогЗнач.Сброс()
}

// Стоп -- останавливает работу cчётчика
func (сам *ВремОбрат) Стоп() {
	сам.фнОтмена()
}

// Уст -- устанавливает число оставшихся сек
func (сам *ВремОбрат) Уст(время alias.Время) error {
	сам.блок.Lock()
	defer сам.блок.Unlock()
	if ош := сам.остатПарсер.Уст(время); ош != nil {
		return fmt.Errorf("ВремОбрат(): ошибка при установке времени, ош=\n\t%w", ош)
	}
	_val := сам.остатПарсер.ПолучМилСек()
	сам.остатЗнач.Уст(int(_val))
	val := int(time.Now().UTC().UnixMilli()) + сам.остатЗнач.Получ()
	сам.порогЗнач.Уст(val)
	return nil
}

// устанавливает число оставшихся сек
func (сам *ВремОбрат) set_val(val int) error {
	сам.блок.Lock()
	defer сам.блок.Unlock()
	if val < 0 {
		return fmt.Errorf("CountTime.set_val(): val(%v)<0", val)
	}
	сам.остатЗнач.Уст(val)
	return nil
}

// String -- возвращает строковое представление оставшихся сек
func (сам *ВремОбрат) String() string {
	сам.блок.RLock()
	defer сам.блок.RUnlock()
	timeNow := time.Now().UTC().Unix()
	val := сам.порогЗнач.Получ() - int(timeNow)
	go сам.set_val(val)
	return сам.остатПарсер.String()
}

// КаналСиг -- возвращает канал чтения тиков
func (сам *ВремОбрат) КаналСиг() <-chan int {
	return сам.канВызов
}

func (сам *ВремОбрат) закрыть() {
	<-сам.кнт.Done()
	сам.блок.Lock()
	defer сам.блок.Unlock()
	if !сам.еслиРаботает.Получ() {
		return
	}
	сам.еслиРаботает.Сброс()
}