package timer

import (
	"sync"
)

// BlockMeter calculates block time interval dynamically.
type BlockMeter func() (uint32, error)

// BlockTickHandler is a callback of a certain block advance.
type BlockTickHandler func()

// BlockTimer represents block timer.
//
// It can tick the blocks and perform certain actions
// on block time intervals.
type BlockTimer struct {
	rolledBack bool

	mtx *sync.Mutex

	dur BlockMeter

	baseDur uint32

	mul, div uint32

	cur, tgt uint32

	last uint32

	h BlockTickHandler

	ps []BlockTimer

	once bool

	deltaCfg
}

// DeltaOption is an option of delta-interval handler.
type DeltaOption func(*deltaCfg)

type deltaCfg struct {
	pulse bool
}

// WithPulse returns option to call delta-interval handler multiple
// times
func WithPulse() DeltaOption {
	return func(c *deltaCfg) {
		c.pulse = true
	}
}

// StaticBlockMeter returns BlockMeters that always returns (d, nil).
func StaticBlockMeter(d uint32) BlockMeter {
	return func() (uint32, error) {
		return d, nil
	}
}

// NewBlockTimer creates a new BlockTimer.
//
// Reset should be called before timer ticking.
func NewBlockTimer(dur BlockMeter, h BlockTickHandler) *BlockTimer {
	return &BlockTimer{
		mtx: new(sync.Mutex),
		dur: dur,
		mul: 1,
		div: 1,
		h:   h,
		deltaCfg: deltaCfg{
			pulse: true,
		},
	}
}

// NewOneTickTimer creates a new BlockTimer that ticks only once.
//
// Do not use delta handlers with pulse in this timer.
func NewOneTickTimer(dur BlockMeter, h BlockTickHandler) *BlockTimer {
	return &BlockTimer{
		mtx:  new(sync.Mutex),
		dur:  dur,
		mul:  1,
		div:  1,
		h:    h,
		once: true,
	}
}

// OnDelta registers handler which is executed on (mul / div * BlockMeter()) block
// after basic interval reset.
//
// If WithPulse option is provided, handler is executed (mul / div * BlockMeter()) block
// during base interval.
func (t *BlockTimer) OnDelta(mul, div uint32, h BlockTickHandler, opts ...DeltaOption) {
	c := deltaCfg{
		pulse: false,
	}

	for i := range opts {
		opts[i](&c)
	}

	t.ps = append(t.ps, BlockTimer{
		mul:  mul,
		div:  div,
		h:    h,
		once: t.once,

		deltaCfg: c,
	})
}

// Reset resets previous ticks of the BlockTimer.
//
// Returns BlockMeter's error upon occurrence.
func (t *BlockTimer) Reset() error {
	d, err := t.dur()
	if err != nil {
		return err
	}

	t.mtx.Lock()

	t.resetWithBaseInterval(d)

	for i := range t.ps {
		t.ps[i].resetWithBaseInterval(d)
	}

	t.mtx.Unlock()

	return nil
}

func (t *BlockTimer) resetWithBaseInterval(d uint32) {
	t.rolledBack = false
	t.baseDur = d
	t.reset()
}

func (t *BlockTimer) reset() {
	mul, div := t.mul, t.div

	if !t.pulse && t.rolledBack && mul < div {
		mul, div = 1, 1
	}

	delta := mul * t.baseDur / div
	if delta == 0 {
		delta = 1
	}

	t.tgt = delta
	t.cur = 0
}

// Tick ticks one block in the BlockTimer.
//
// Executes all callbacks which are awaiting execution at the new block.
func (t *BlockTimer) Tick(h uint32) {
	t.mtx.Lock()
	t.tick(h)
	t.mtx.Unlock()
}

func (t *BlockTimer) tick(h uint32) {
	if h != 0 && t.last == h {
		return
	}

	t.last = h
	t.cur++

	if t.cur == t.tgt {
		// it would be advisable to optimize such execution, for example:
		//   1. push handler to worker pool t.wp.Submit(h);
		//   2. call t.tickH(h)
		t.h()

		if !t.once {
			t.cur = 0
			t.rolledBack = true
			t.reset()
		}
	}

	for i := range t.ps {
		t.ps[i].tick(h)
	}
}