#ifndef __CIRCULAR_QUEUE_HPP__
#define __CIRCULAR_QUEUE_HPP__

#include <iostream>
#include <atomic>
#include <vector>
#include <mutex>

using namespace std;


// 循环队列
template <typename T>
class CircularQueue
{
private:
    /* data */
public:
    CircularQueue();
    ~CircularQueue();

    bool init(vector<T> data);
    T getTail();
    void addTail();
    T deQueue();
    T getHead();
	void addHead();
    void clearQueue();

    int length();
    bool isEmpty();

private:
    vector<T> base;
	atomic<int> front;
	atomic<int> rear;
    mutex m_mutex;
    int max_size;
};


template <typename T>
CircularQueue<T>::CircularQueue()
{
	front = rear = 0;//头指针和尾指针置为零，队列为空
}

template <typename T>
CircularQueue<T>::~CircularQueue()
{
	base.clear();
    rear = front = 0;
}

template <typename T>
bool CircularQueue<T>::init(vector<T> data){
	base = data;
	front = rear = 0;//头指针和尾指针置为零，队列为空
	max_size = data.size();

	return true;
}
 
//循环队列的入队
template <typename T>
T CircularQueue<T>::getTail()
{
	std::lock_guard<std::mutex> l(m_mutex);
	//插入一个元素e为Q的新的队尾元素
	if ((rear + 1) % max_size == front)
		return nullptr;//队满
	return base[rear];//获取队尾元素
}

// 将队尾元素添加到队列中
template <typename T>
void CircularQueue<T>::addTail()
{
	std::lock_guard<std::mutex> l(m_mutex);
     rear = (rear + 1) % max_size;//队尾指针加1
}
 
//循环队列的出队
template <typename T>
T CircularQueue<T>::deQueue()
{
	std::lock_guard<std::mutex> l(m_mutex);
	//删除Q的队头元素，用e返回其值
	if (front == rear)
		return nullptr;//队空
	T e = base[front];//保存队头元素
	front = (front + 1) % max_size;//队头指针加1
	return e;
}
 
//取循环队列的队头元素
template <typename T>
T CircularQueue<T>::getHead()
{
	std::lock_guard<std::mutex> l(m_mutex);
	//返回Q的队头元素，不修改队头指针
	if (front == rear)
		return nullptr;//队列为空，取元素失败
	return base[front];
}

template <typename T>
void CircularQueue<T>::addHead()
{
	std::lock_guard<std::mutex> l(m_mutex);
    front = (front + 1) % max_size;//队头指针加1
}

template <typename T>
int CircularQueue<T>::length()
{
	std::lock_guard<std::mutex> l(m_mutex);
    return (rear - front + max_size) % max_size;
}

template <typename T>
bool CircularQueue<T>::isEmpty()
{
	std::lock_guard<std::mutex> l(m_mutex);
	if (front == rear)
		return true;

	return false;
}

template <typename T>
void CircularQueue<T>::clearQueue()
{
	std::lock_guard<std::mutex> l(m_mutex);
	rear = front = 0;
}

#endif