package scheduling

type queueItem interface {
	ts() float64
	setIndex(idx int)
}

type queue struct {
	items []queueItem
}

// Len implements heap.Interface.
func (q *queue) Len() int {
	return len(q.items)
}

// Less implements heap.Interface.
func (q *queue) Less(i int, j int) bool {
	return q.items[i].ts() < q.items[j].ts()
}

// Pop implements heap.Interface.
func (q *queue) Pop() any {
	n := len(q.items)
	item := q.items[n-1]
	q.items[n-1] = nil
	q.items = q.items[0 : n-1]
	item.setIndex(invalidIndex)
	return item
}

// Push implements heap.Interface.
func (q *queue) Push(x any) {
	it := x.(queueItem)
	it.setIndex(q.Len())
	q.items = append(q.items, it)
}

// Swap implements heap.Interface.
func (q *queue) Swap(i int, j int) {
	q.items[i], q.items[j] = q.items[j], q.items[i]
	q.items[i].setIndex(i)
	q.items[j].setIndex(j)
}

var _ queueItem = &reservationMQueueItem{}

type reservationMQueueItem struct {
	r *request
}

func (i *reservationMQueueItem) ts() float64 {
	return i.r.reservation
}

func (i *reservationMQueueItem) setIndex(idx int) {
	i.r.reservationIdx = idx
}

var _ queueItem = &limitMQueueItem{}

type limitMQueueItem struct {
	r *request
}

func (i *limitMQueueItem) ts() float64 {
	return i.r.limit
}

func (i *limitMQueueItem) setIndex(idx int) {
	i.r.limitIdx = idx
}

var _ queueItem = &sharesMQueueItem{}

type sharesMQueueItem struct {
	r *request
}

func (i *sharesMQueueItem) ts() float64 {
	return i.r.shares
}

func (i *sharesMQueueItem) setIndex(idx int) {
	i.r.sharesIdx = idx
}

var _ queueItem = &readyMQueueItem{}

type readyMQueueItem struct {
	r *request
}

func (i *readyMQueueItem) ts() float64 {
	return i.r.shares
}

func (i *readyMQueueItem) setIndex(idx int) {
	i.r.readyIdx = idx
}