package event

type DispatcherEvent interface {
	Dispatch(event *StoppableEvent)
}

type StoppableEvent interface {
	Name() string
	IsPropagationStopped() bool
	Stop()
	Continue()
}

type Listener interface {
	Listen(event *StoppableEvent)
}

type Dispatcher struct {
	events map[string][]Listener
}

var (
	dispatcher *Dispatcher
)

func NewDispatcher() *Dispatcher {
	dispatcher = &Dispatcher{
		events: make(map[string][]Listener),
	}
	return dispatcher
}

func GetDispatcher() *Dispatcher {
	if dispatcher == nil {
		NewDispatcher()
	}
	return dispatcher
}

func (p *Dispatcher) Dispatch(event StoppableEvent) {
	e := event
	listeners := p.events[e.Name()]
	if listeners != nil && len(listeners) > 0 {
		for _, listener := range listeners {
			if e.IsPropagationStopped() {
				break
			} else {
				listener.Listen(&event)
			}
		}
	}
}

func (p *Dispatcher) Bind(eventName string, listeners ...Listener) {
	p.BindBatch(eventName, listeners)
}

func (p *Dispatcher) BindBatch(eventName string, listeners []Listener) {
	for _, listener := range listeners {
		p.events[eventName] = append(p.events[eventName], listener)
	}
}

func Dispatch(event StoppableEvent) {
	dispatcher.Dispatch(event)
}

type Event struct {
	stop bool
}

func (p *Event) IsPropagationStopped() bool {
	return p.stop
}

func (p *Event) Stop() {
	p.stop = true
}

func (p *Event) Continue() {
	p.stop = false
}