// Package alert define alert event struct of modelRT project
package alert

import (
	"sort"
	"sync"

	"modelRT/constants"
)

var (
	once             sync.Once
	_globalManagerMu sync.RWMutex
	_globalManager   *EventManager
)

// Event define alert event struct
type Event struct {
	ComponentID int64
	AnchorName  string
	Level       constants.AlertLevel
	Message     string
	StartTime   int64
}

// EventManager define store and manager alert event struct
type EventManager struct {
	mu     sync.RWMutex
	events map[constants.AlertLevel][]Event
}

// EventSet define alert event set implement sort.Interface
type EventSet []Event

func (es EventSet) Len() int {
	return len(es)
}

func (es EventSet) Less(i, j int) bool {
	return es[i].StartTime < es[j].StartTime
}

func (es EventSet) Swap(i, j int) {
	es[i], es[j] = es[j], es[i]
}

// AddEvent define add a alert event to event manager
func (am *EventManager) AddEvent(event Event) {
	am.mu.Lock()
	defer am.mu.Unlock()

	am.events[event.Level] = append(am.events[event.Level], event)
}

// GetEventsByLevel define get alert event by alert level
func (am *EventManager) GetEventsByLevel(level constants.AlertLevel) []Event {
	am.mu.Lock()
	defer am.mu.Unlock()

	return am.events[level]
}

// GetRangeEventsByLevel define get range alert event by alert level
func (am *EventManager) GetRangeEventsByLevel(targetLevel constants.AlertLevel) []Event {
	var targetEvents []Event

	am.mu.Lock()
	defer am.mu.Unlock()

	for level, events := range am.events {
		if targetLevel <= level {
			targetEvents = append(targetEvents, events...)
		}
	}
	sort.Sort(EventSet(targetEvents))
	return targetEvents
}

// InitAlertEventManager define new alert event manager
func InitAlertEventManager() *EventManager {
	return &EventManager{
		events: make(map[constants.AlertLevel][]Event),
	}
}

// InitAlertManagerInstance return instance of zap logger
func InitAlertManagerInstance() *EventManager {
	once.Do(func() {
		_globalManager = InitAlertEventManager()
	})
	return _globalManager
}

// GetAlertMangerInstance returns the global alert manager instance It's safe for concurrent use.
func GetAlertMangerInstance() *EventManager {
	_globalManagerMu.RLock()
	manager := _globalManager
	_globalManagerMu.RUnlock()
	return manager
}