package queue

import "container/heap"

type PQueue []IPriorityItem

var _ Queue = (*PQueue)(nil)

// Len returns the PQueue length.
func (pq PQueue) Len() int { return len(pq) }

// Less 权重越少越大前面
func (pq PQueue) Less(i, j int) bool {
	in := pq[i]
	jn := pq[j]
	if in == nil || jn == nil {
		return false
	}
	return in.PValue() < jn.PValue()
}

// Swap exchanges the indexes of the items.
func (pq PQueue) Swap(i, j int) {
	temp := pq[i]
	pq[i] = pq[j]
	pq[j] = temp
}

func (pq *PQueue) Add(elem interface{}) error {
	heap.Push(pq, elem)
	return nil
}

// Push implements the heap.Interface.Push.
// Adds x as element Len().
func (pq *PQueue) Push(x interface{}) {
	*pq = append(*pq, ConvertPriorityItem(x))
}

// Pop implements the heap.Interface.Pop.
// Removes and returns element Len() - 1.
func (pq *PQueue) Pop() interface{} {
	old := *pq
	item := old[0]
	*pq = old[1:]
	return item.GValue()
}

// Head returns the first item of a PQueue without removing it.
func (pq *PQueue) Head() IPriorityItem {
	if pq.Empty() {
		return nil
	}
	return (*pq)[0]
}

func (pq *PQueue) Peek() interface{} {
	if pq.Empty() {
		return nil
	}
	return (*pq)[0].GValue()
}

// Remove removes and returns the element at index i from the PQueue.
func (pq *PQueue) Remove(i int) interface{} {
	return heap.Remove(pq, i)
}

func (pq *PQueue) Empty() bool {
	return pq.Len() == 0
}

// Find return index -1 not found.
func (pq *PQueue) Find(fn IndexFunc) (interface{}, int) {
	for i := range *pq {
		if fn((*pq)[i], i) {
			return (*pq)[i], i
		}
	}
	return nil, -1
}