package queue

type node struct {
	next *node
	val  interface{}
}

var _ Queue = (*LQueue)(nil)

type LQueue struct {
	head     *node
	tail     *node
	length   int
	capacity int
}

func NewLQueue(capacity int) *LQueue {
	if capacity <= 0 {
		capacity = minCapacity
	}
	if capacity > maxCapacity {
		capacity = maxCapacity
	}
	return &LQueue{capacity: capacity}
}

func (lq *LQueue) Add(val interface{}) error {
	if lq.length >= lq.capacity {
		return ErrIsFull
	}
	item := &node{
		val: val,
	}
	item.next = lq.head
	lq.head = item
	lq.length++
	return nil
}

func (lq *LQueue) AddTail(val interface{}) error {
	if lq.length >= lq.capacity {
		return ErrIsFull
	}
	item := &node{
		val: val,
	}
	if lq.tail == nil {
		lq.head = item
	} else {
		lq.tail.next = item
	}
	lq.length++
	lq.tail = item
	return nil
}

func (lq *LQueue) Pop() interface{} {
	if lq.head != nil {
		val := lq.head.val
		lq.head = lq.head.next
		if lq.head == nil {
			lq.tail = nil
		}
		lq.length--
		return val
	}
	return nil
}

func (lq *LQueue) Peek() interface{} {
	if lq.head != nil {
		return lq.head.val
	}
	return nil
}

func (lq *LQueue) Empty() bool {
	return lq.head == nil
}

func (lq *LQueue) Len() int {
	return lq.length
}

func (lq *LQueue) Cap() int {
	return lq.length
}

// Find return index -1 not found.
func (lq *LQueue) Find(fn IndexFunc) (interface{}, int) {
	index := 0
	for i := lq.head; i != nil; i = i.next {
		if fn(i.val, index) {
			return i.val, index
		}
		index++
	}
	return nil, -1
}

func (lq *LQueue) ToList() []interface{} {
	buf := make([]interface{}, lq.Len())
	index := 0
	for i := lq.head; i != nil; i = i.next {
		buf[index] = i.val
		index++
	}
	return buf
}