package hooks

import (
	"apiServer_service/utils/logger"
	"context"
	"fmt"
	"sort"
	"sync"
)

type handlerWithMeta struct {
	priority int
	async    bool
	h        Handler
}

type Manager struct {
	mu       sync.RWMutex
	handlers map[EventType][]handlerWithMeta
}

func NewManager() *Manager {
	return &Manager{
		handlers: make(map[EventType][]handlerWithMeta),
	}
}

// Register 同步注册，优先级 0
func (m *Manager) Register(event EventType, h Handler) {
	m.RegisterWithOptions(event, 0, false, h)
}

// RegisterWithPriority 指定优先级（同步）
func (m *Manager) RegisterWithPriority(event EventType, priority int, h Handler) {
	m.RegisterWithOptions(event, priority, false, h)
}

// RegisterAsync 异步注册，优先级 0
func (m *Manager) RegisterAsync(event EventType, h Handler) {
	m.RegisterWithOptions(event, 0, true, h)
}

// RegisterWithOptions 核心注册：优先级 + 同步/异步
func (m *Manager) RegisterWithOptions(event EventType, priority int, async bool, h Handler) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.handlers[event] = append(m.handlers[event], handlerWithMeta{
		priority: priority,
		async:    async,
		h:        h,
	})
}

// Trigger 触发事件，按优先级从高到低执行
func (m *Manager) Trigger(ctx context.Context, event EventType, payload *EventPayload) {
	m.mu.RLock()
	hs := m.handlers[event]
	m.mu.RUnlock()

	if len(hs) == 0 {
		return
	}

	sorted := make([]handlerWithMeta, len(hs))
	copy(sorted, hs)
	sort.SliceStable(sorted, func(i, j int) bool {
		return sorted[i].priority > sorted[j].priority
	})

	for _, hm := range sorted {
		if hm.async {
			go func(hm handlerWithMeta) {
				if err := hm.h.Handle(ctx, event, payload); err != nil {
					logger.Error("Hook", fmt.Sprintf("async event=%s err=%v", event, err))
				}
			}(hm)
		} else {
			if err := hm.h.Handle(ctx, event, payload); err != nil {
				logger.Error("Hook", fmt.Sprintf("event=%s err=%v", event, err))
			}
		}
	}
}