package timer

import (
	"errors"
	"gitee.com/h79/goutils/common/system"
	"time"
)

var (
	TimeoutError = errors.New("operation timed out")
	ClosedError  = errors.New("process closed")
)

type CallbackFunc func(interface{}) bool

// Ticker
// 定时调用
func Ticker(tick time.Duration, fun CallbackFunc, param interface{},
	funcDefer CallbackFunc, paramDefer interface{}) {

	Delay(0, tick, fun, param, funcDefer, paramDefer)
}

func Delay(delay, tick time.Duration, fun CallbackFunc, param interface{},
	funcDefer CallbackFunc, paramDefer interface{}) {

	if fun == nil {
		return
	}
	system.ChildRunning(func() {
		defer func() {
			if funcDefer != nil {
				funcDefer(paramDefer)
			}
		}()
		if delay > 0 {
			time.Sleep(delay)
			if fun(param) {
				return
			}
		}
		ticker := time.NewTicker(tick)
		for {
			select {
			case _ = <-ticker.C:
				if fun(param) {
					return
				}
			case <-system.Closed():
				return
			}
		}
	})
}

func Call(timeout time.Duration, fn func() (interface{}, error)) (interface{}, error) {
	if timeout > 0 {
		resultCh := make(chan *resultWithError, 1)

		system.ChildRunning(func() {
			result, err := fn()
			resultCh <- &resultWithError{result, err}
		})

		select {
		case <-time.After(timeout):
			return nil, TimeoutError
		case rwe := <-resultCh:
			return rwe.result, rwe.err
		case <-system.Closed():
			return nil, ClosedError
		}
	}
	return fn()
}

type resultWithError struct {
	result interface{}
	err    error
}