package broker

import (
	"context"
	"sync"
)

type EventBroker struct {
	handlers map[string][]EventHandler
	mu       sync.RWMutex
}

type EventHandler interface {
	Handle(ctx context.Context, event Event) error
}

type Event interface {
	Name() string
	Payload() interface{}
}

func NewEventBroker() *EventBroker {
	return &EventBroker{
		handlers: make(map[string][]EventHandler),
	}
}

func (b *EventBroker) Register(eventType string, handler EventHandler) {
	b.mu.Lock()
	defer b.mu.Unlock()
	b.handlers[eventType] = append(b.handlers[eventType], handler)
}

func (b *EventBroker) Publish(eventType string, event Event) {
	b.mu.RLock()
	defer b.mu.RUnlock()
	for _, handler := range b.handlers[eventType] {
		handler.Handle(context.Background(), event)
	}
}

func (b *EventBroker) Unregister(eventType string, handler EventHandler) {
	b.mu.Lock()
	defer b.mu.Unlock()
	handlers := b.handlers[eventType]
	for i, h := range handlers {
		if h == handler {
			// Remove the handler from the slice
			b.handlers[eventType] = append(handlers[:i], handlers[i+1:]...)
			break
		}
	}
}