/************************************************
* Memory Queue is a special linear table,
* which is a first in,
* first out (FIFO) data structure
*
* create zoufuzhou 20201001
*
************************************************/
#ifndef _MEM_QUEUE_CACHE_HPP_
#define _MEM_QUEUE_CACHE_HPP_


#include <glob/GlobMem.h>
#include <mutex>

template <typename T> class CMemQueue
{
  typedef struct{
    unsigned int maxsize;
    unsigned int size;
    unsigned int head;
    unsigned int tail;
  }HEAD;

//Local variable
private:
  std::mutex m_mutex;

//Memory variable
private:
  HEAD* p_head;
	T*    p_ptr;

private:
  void init(const string& tableName)
  {
    char* ptr = (char*)GlobMem::GetInstancePtr()->GetTablePtr(tableName);
    if(ptr == nullptr)
    {
      p_ptr = nullptr;
      p_head = nullptr;
      return;
    }
    p_head = (HEAD*)(ptr);
    p_ptr  = (T*)(ptr+sizeof(HEAD));

  };

public:
	CMemQueue(const string& tableName)
	{
    this->init(tableName);
    //assert(p_head->maxsize>1);

//    p_head->size = p_head->size%p_head->maxsize;
//    p_head->head = p_head->head%p_head->maxsize;
//    p_head->tail = p_head->tail%p_head->maxsize;
	};

	CMemQueue(const string& tableName,unsigned int maxsize)
	{
    //assert(maxsize>1);
    this->init(tableName);

    m_mutex.lock();
		p_head->maxsize = maxsize;
		if(p_head->size != p_head->maxsize)
		{
			p_head->size = 0;
			p_head->head = 0;
			p_head->tail = 0;
		}
		else
		{
			p_head->size = p_head->size%p_head->maxsize;
			p_head->head = p_head->head%p_head->maxsize;
			p_head->tail = p_head->tail%p_head->maxsize;
		}
    m_mutex.unlock();
	};

	~CMemQueue(){};

	T* operator()(void)
	{
		return p_ptr;
	};

	unsigned int max_size(void)
	{
		return p_head->maxsize;
	}

	unsigned int size(void)
	{
		if(p_head == nullptr)return 0;
		return p_head->size;
	}

	T* operator[](unsigned int i)
	{
		if(p_ptr == nullptr)return nullptr;
		return p_ptr+i;
	};

	void push(T* t)
	{
		if(p_ptr == nullptr)return;
		if (p_head->size < p_head->maxsize)
		{
      m_mutex.lock();
			p_head->size++;
      m_mutex.unlock();
		}
    else
    {
      this->pop();
    }

		memcpy(p_ptr+p_head->tail,t,sizeof(T));
		p_head->tail = (p_head->tail+1)%p_head->maxsize;
	};

	T* pop(void)
	{
		if(this->empty())return nullptr;
    else
    {
      unsigned int itmp = p_head->head;
      p_head->head = (p_head->head+1)%p_head->maxsize;
      m_mutex.lock();
      p_head->size--;
      m_mutex.unlock();
      return p_ptr+itmp;
    }
	};

	bool empty(void)
	{
		if(p_head == nullptr)return true;
		return !p_head->size;
	};

	T* back(void)
	{
		if(this->empty())return nullptr;
    else
    {
      if(p_head->tail == 0)
      {
        return p_ptr+p_head->maxsize;
      }
      else
      {
        return p_ptr+(p_head->tail-1)%p_head->maxsize;
      }
    }
	};

	T* front(void)
	{
		if(this->empty())return nullptr;
    else return p_ptr+p_head->head;
	};

	void clear(void)
	{
		if(p_head == nullptr)return;
		p_head->size = 0;
		p_head->head = 0;
		p_head->tail = 0;
	};
};
#endif