#pragma once
#include <Windows.h>
#include <vector>
#include <algorithm>
using namespace std;

template<typename Data>
class ConcurrentList
{
public:
	ConcurrentList()
	{
		m_hMetex =  ::CreateMutex(NULL, FALSE, NULL);
		m_semaMsgNum = CreateSemaphore(NULL,0,1,NULL);
	}
	~ConcurrentList()
	{
		 ::CloseHandle(m_hMetex);
	}

	void push_front(Data const &data)
	{
		WaitForSingleObject(m_hMetex, INFINITE);

		if(IsExist(data))
		{
			 ::ReleaseMutex(m_hMetex);
			return;
		}

		if(m_vector.empty())
		{
			m_vector.push_back(data);
		}
		else
		{
			m_vector.insert(m_vector.begin(),data);
		}
		::ReleaseMutex(m_hMetex);

		ReleaseSemaphore(m_semaMsgNum ,  1,  NULL);
	}

	void push_back(Data const& data)  
	{  
		WaitForSingleObject(m_hMetex, INFINITE);
		if (IsExist(data))
		{
			::ReleaseMutex(m_hMetex);
			return;
		}

		m_vector.push_back(data);
		::ReleaseMutex(m_hMetex);
		ReleaseSemaphore(m_semaMsgNum ,  1,  NULL);
	}
	bool erase(Data const&popped_value)  
	{  
		WaitForSingleObject(m_hMetex, INFINITE);
		if (m_vector.empty())
		{  
			::ReleaseMutex(m_hMetex);
			return true;  
		}  

		std::vector<Data>::iterator itFind = find(m_vector.begin(),m_vector.end(),popped_value);
		if(itFind == m_vector.end())
		{
			::ReleaseMutex(m_hMetex);
			return true;
		}

		m_vector.erase(itFind);  
		::ReleaseMutex(m_hMetex);
		return true;  
	}

// 	bool empty() 
// 	{  
// 		boost::recursive_mutex::scoped_lock lock(m_mutex);
// 		return m_vector.empty();
// 	}    

	bool PopFront( Data& dataValue )  
	{  
		WaitForSingleObject(m_hMetex, INFINITE);
		if (!m_vector.empty())
		{  
			dataValue=m_vector[0];  
			m_vector.erase(m_vector.begin());
			::ReleaseMutex(m_hMetex);
			return true;
		}

		::ReleaseMutex(m_hMetex);
		return false;
	}  

	void wait_and_pop(Data& popped_value)  
	{  
		while (m_vector.empty())
		{ 
			WaitForSingleObject(m_semaMsgNum, INFINITE);
		} 
		WaitForSingleObject(m_hMetex, INFINITE);
		popped_value=m_vector[0];  
		m_vector.erase(m_vector.begin());
		::ReleaseMutex(m_hMetex);
	}  

// 	Data& get_data(int iIndex)
// 	{
// 		boost::recursive_mutex::scoped_lock lock(m_mutex);
// 		return m_vector[iIndex];
// 	}

	int get_size()
	{
		WaitForSingleObject(m_hMetex, INFINITE);
		int iSize = m_vector.size();
		::ReleaseMutex(m_hMetex);
		return iSize;
	}
// 
// 	void clear()
// 	{
// 		boost::recursive_mutex::scoped_lock lock(m_mutex);
// 		return m_vector.clear();
// 	}

protected:  
	bool IsExist(Data const& data)
	{
		if(m_vector.end () == find(m_vector.begin(),m_vector.end(),data) )
			return false;

		return true;
	}
protected:  
	vector<Data>         m_vector;  
	HANDLE               m_hMetex;
	HANDLE               m_semaMsgNum;
};