/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/
#ifndef CONTAINER_LIST_H_
#define CONTAINER_LIST_H_

#include <list>

#include <util/avm_assert.h>
#include <util/avm_numeric.h>
#include <base/SmartPointerUtil.h>

#include <collection/Collection.h>


namespace sep
{


template< typename T >
class List :
		public std::list< T >,
		public Collection< T >
{

public:
	/**
	 * TYPEDEF
	 */
	typedef       T &         reference;
	typedef const T &         const_reference;

	typedef std::list< T >    BaseList;
	typedef std::vector< T >  BaseVector;

	/**
	 * CONSTRUCTOR
	 * Default
	 */
	List()
	: BaseList()
	{
		//!! NOTHING
	}


	/**
	 * CONSTRUCTOR
	 * Copy
	 */
	List(const List & aList)
	: BaseList( aList )
	{
		//!! NOTHING
	}


	/**
	 * CONSTRUCTOR
	 * Others
	 */
	explicit List(const T & arg)
	: BaseList()
	{
		append(arg);
	}

	explicit List(const T & arg1, const T & arg2)
	: BaseList()
	{
		append(arg1, arg2);
	}

	explicit List(T arg1, T arg2, T arg3)
	: BaseList()
	{
		append(arg1, arg2, arg3);
	}


	/**
	 * DESTRUCTOR
	 */
	virtual ~List()
	{
		BaseList::clear();
	}


	/*
	 ***************************************************************************
	 * SETTER
	 * pop | push  back
	 ***************************************************************************
	 */

	inline virtual void pop_back()
	{
		BaseList::pop_back();
	}

	inline void pop_back(avm_size_t count)
	{
		for( ; (count > 0) && nonempty() ; --count )
		{
			BaseList::pop_back();
		}
	}


	inline virtual void push_back(const T & arg)
	{
		BaseList::push_back(arg);
	}


	inline virtual void push_back(const std::list< T > & aCollection)
	{
		BaseList::insert(BaseList::end(),
				aCollection.begin(), aCollection.end());
	}

	template< typename _TOE >
	inline void push_back(const std::list< _TOE > & aCollection)
	{
		BaseList::insert(BaseList::end(),
				aCollection.begin(), aCollection.end());
	}


	inline virtual void push_back(const std::vector< T > & aCollection)
	{
		BaseList::insert(BaseList::end(),
				aCollection.begin(), aCollection.end());
	}

	template< typename _TOE >
	inline void push_back(const std::vector< _TOE > & aCollection)
	{
		BaseList::insert(BaseList::end(),
				aCollection.begin(), aCollection.end());
	}


	inline virtual void push_front(const T & arg)
	{
		BaseList::push_front(arg);
	}


	/*
	 ***************************************************************************
	 * SETTER
	 * pop | push  front
	 ***************************************************************************
	 */

	inline virtual void pop_front()
	{
		BaseList::pop_front();
	}

	inline void pop_front(avm_size_t count)
	{
		for( ; (count > 0) && nonempty() ; --count )
		{
			BaseList::pop_front();
		}
	}


	inline virtual void push_front(const std::list< T > & aCollection)
	{
		BaseList::insert(BaseList::begin(),
				aCollection.begin(), aCollection.end());
	}

	template< typename _TOE >
	inline void push_front(const std::list< _TOE > & aCollection)
	{
		BaseList::insert(BaseList::begin(),
				aCollection.begin(), aCollection.end());
	}


	inline virtual void push_front(const std::vector< T > & aCollection)
	{
		BaseList::insert(BaseList::begin(),
				aCollection.begin(), aCollection.end());
	}

	template< typename _TOE >
	inline void push_front(const std::vector< _TOE > & aCollection)
	{
		BaseList::insert(BaseList::begin(),
				aCollection.begin(), aCollection.end());
	}


	/*
	 ***************************************************************************
	 * GETTER
	 * emptiness
	 ***************************************************************************
	 */
	inline virtual bool empty() const
	{
		return( BaseList::empty() );
	}

	inline virtual bool nonempty() const
	{
		return( not BaseList::empty() );
	}

	inline virtual bool singleton() const
	{
		//return( size() == 1 );

		typename BaseList::const_iterator it = BaseList::begin();
		typename BaseList::const_iterator itEnd = BaseList::end();
		return( (it != itEnd) && ((++it) == itEnd) );
	}

	inline virtual bool populated() const
	{
		//return( size() > 1 );

		typename BaseList::const_iterator it = BaseList::begin();
		typename BaseList::const_iterator itEnd = BaseList::end();
		return( (it != itEnd) && ((++it) != itEnd) );
	}


	//	inline virtual avm_size_t size() const
	//	{
	//		return( BaseList::size() );
	//	}


	/**
	 * contains a particular element
	 */
	inline virtual bool contains(const T & arg) const
	{
		typename BaseList::const_iterator it = BaseList::begin();
		typename BaseList::const_iterator itEnd = BaseList::end();
		for( ; it != itEnd ; ++it )
		{
			if( (*it) == arg )
			{
				return( true );
			}
		}

		return( false );
	}


	/**
	 * has an intersection with another list
	 */
	inline virtual bool intersect(const std::list< T > & aCollection) const
	{
		typename std::list< T >::const_iterator itCol;
		typename std::list< T >::const_iterator endItCol = aCollection.end();

		typename BaseList::const_iterator it = BaseList::begin();
		typename BaseList::const_iterator itEnd = BaseList::end();
		for( ; it != itEnd ; ++it )
		{
			for( itCol = aCollection.begin() ; itCol != endItCol ; ++itCol )
			{
				if( (*it) == (*itCol) )
				{
					return( true );
				}
			}
		}

		return( false );
	}


	/*
	 ***************************************************************************
	 * SETTER
	 * append
	 ***************************************************************************
	 */
	inline virtual void append(const T & arg)
	{
		BaseList::push_back(arg);
	}

	inline virtual void append(const T & arg1, const T & arg2)
	{
		append(arg1);
		append(arg2);
	}

	inline virtual void append(const T & arg1, const T & arg2, const T & arg3)
	{
		append(arg1);
		append(arg2);
		append(arg3);
	}


	inline virtual void append(T * anArrayOfArgument, int anArgSize)
	{
		for (int i = 0 ; i < anArgSize ; ++i)
		{
			push_back(anArrayOfArgument[i]);
		}
	}

	template< typename _TOE >
	inline void append(const std::list< _TOE > & aCollection)
	{
		BaseList::insert(BaseList::end(),
				aCollection.begin(), aCollection.end());
	}

	template< typename _TOE >
	inline void splice(std::list< _TOE > & aCollection)
	{
		BaseList::splice(BaseList::end(), aCollection);
	}

	template< typename _TOE >
	inline void append(const std::vector< _TOE > & aCollection)
	{
		BaseList::insert(BaseList::end(),
				aCollection.begin(), aCollection.end());
	}


	/*
	 ***************************************************************************
	 * SETTER
	 * add_union
	 ***************************************************************************
	 */
	inline virtual void add_union(const T & arg)
	{
		if( not contains(arg) )
		{
			BaseList::push_back(arg);
		}
	}

	inline virtual void add_union(const T & arg1, const T & arg2)
	{
		add_union(arg1);
		add_union(arg2);
	}


	inline virtual void add_union(T * anArrayOfArgument, int anArgSize)
	{
		for (int i = 0 ; i < anArgSize ; ++i)
		{
			add_union( anArrayOfArgument[i] );
		}
	}


	inline virtual void add_union(const std::list< T > & aCollection)
	{
		typename std::list< T >::const_iterator it = aCollection.begin();
		for( ; it != aCollection.end() ; ++it )
		{
			add_union( (*it) );
		}
	}

	inline virtual void add_union(const std::list< T > * aCollection)
	{
		typename std::list< T >::const_iterator it = aCollection->begin();
		for( ; it != aCollection->end() ; ++it )
		{
			add_union( (*it) );
		}
	}

	inline virtual void add_union(const std::vector< T > & aCollection)
	{
		typename std::vector< T >::const_iterator it = aCollection.begin();
		for( ; it != aCollection.end() ; ++it )
		{
			add_union( (*it) );
		}
	}


	/*
	 ***************************************************************************
	 * GETTER
	 * first & ... & last
	 ***************************************************************************
	 */
	inline virtual reference first()
	{
		return( BaseList::front() );
	}

	inline virtual const_reference first() const
	{
		return( BaseList::front() );
	}


	inline virtual T pop_first()
	{
		T theFirst = BaseList::front();

		BaseList::pop_front();

		return( theFirst );
	}

	inline virtual void pop_first_to(T & theFirst)
	{
		theFirst = BaseList::front();

		BaseList::pop_front();
	}

	inline void remove_first()
	{
		BaseList::pop_front();
	}


	inline virtual reference second()
	{
		AVM_OS_ASSERT_FATAL_ERROR_EXIT( populated() )
				<< "Expected a List with size() > 1 !!!"
				<< SEND_EXIT;

		return( *( ++(BaseList::begin()) ) );
	}

	inline virtual const_reference second() const
	{
		AVM_OS_ASSERT_FATAL_ERROR_EXIT( populated() )
				<< "Expected a List with size() > 1 !!!"
				<< SEND_EXIT;

		return( *( ++(BaseList::begin()) ) );
	}


	inline virtual reference last()
	{
		return( *( BaseList::rbegin() ) );
	}

	inline virtual const_reference last() const
	{
		return( *( BaseList::rbegin() ) );
	}


	inline virtual T pop_last()
	{
		T theLast = BaseList::back();

		BaseList::pop_back();

		return( theLast );
	}

	inline virtual void pop_last_to(T & theLast)
	{
		theLast = BaseList::back();

		BaseList::pop_back();
	}

	inline void remove_last()
	{
		BaseList::pop_back();
	}


	inline virtual reference at(avm_size_t index)
	{
		typename BaseList::iterator it = BaseList::begin();
		typename BaseList::iterator itEnd = BaseList::end();
		for( ; (index > 0) && (it != itEnd) ; ++it , --index )
		{
			//!!! NOTHING
		}

		return( ((index == 0) && (it != itEnd)) ? *it : last() );
	}

	inline virtual const_reference at(avm_size_t index) const
	{
		typename BaseList::const_iterator it = BaseList::begin();
		typename BaseList::const_iterator itEnd = BaseList::end();
		for( ; (index > 0) && (it != itEnd) ; ++it , --index )
		{
			//!!! NOTHING
		}

		return( ((index == 0) && (it != itEnd)) ? *it : last() );
	}


	inline virtual reference get(avm_size_t index)
	{
		return( at(index) );
	}

	inline virtual const_reference get(avm_size_t index) const
	{
		return( at(index) );
	}


	inline T pop_index(avm_size_t index)
	{
		typename BaseList::iterator it = BaseList::begin();
		typename BaseList::iterator itEnd = BaseList::end();
		for( ; (index > 0) && (it != itEnd) ; ++it , --index )
		{
			//!!! NOTHING
		}

		if( (index == 0) && (it != itEnd) )
		{
			T theElt = *it;

			BaseList::erase( it );

			return( theElt );
		}
		else
		{
			return( pop_last() );
		}
	}


	/*
	 ***************************************************************************
	 * SETTER
	 * reset
	 ***************************************************************************
	 */
	inline virtual void reset(const T & arg)
	{
		BaseList::clear();
		push_back(arg);
	}


	inline virtual void reset(const std::list< T > & aCollection)
	{
		BaseList::clear();

		push_back(aCollection);
	}

	inline virtual void reset(const std::vector< T > & aCollection)
	{
		BaseList::clear();

		push_back(aCollection);
	}


	template< typename _TOE >
	inline void reset(const std::list< _TOE > & aCollection)
	{
		BaseList::clear();

		push_back(aCollection);
	}

	template< typename _TOE >
	inline void reset(const std::vector< _TOE > & aCollection)
	{
		BaseList::clear();

		push_back(aCollection);
	}


	inline virtual void remove(const T & arg)
	{
		BaseList::remove(arg);
	}

	inline void remove(const std::list< T > & aCollection)
	{
		typename std::list< T >::const_iterator it = aCollection.begin();
		for( ; it != aCollection.end() ; ++it )
		{
			BaseList::remove( (*it) );
		}
	}


	inline virtual void makeUnique()
	{
		if( populated() )
		{
			typename BaseList::const_iterator itTmp;

			typename BaseList::iterator it = BaseList::begin();
			for( ++it ; it != BaseList::end() ; )
			{
				for( itTmp = BaseList::begin() ; itTmp != it ; ++itTmp )
				{
					if( (*itTmp) == (*it) )
					{
						break;
					}
				}

				if( itTmp != it )
				{
					it = BaseList::erase(it);
				}
				else
				{
					++it;
				}
			}
		}

		//		BaseList::sort();
		//		BaseList::unique();
	}

};


template< typename T >
class APList : public List< T >
{
public:
	/**
	 * TYPEDEF
	 */
	typedef T       & reference;
	typedef const T & const_reference;

	typedef List< T >  BaseAPList;


	/**
	 * CONSTRUCTOR
	 * Default
	 */
	APList()
	: BaseAPList()
	{
		//!! NOTHING
	}

	/**
	 * CONSTRUCTOR
	 * Copy
	 */
	APList(const APList & aList)
	: BaseAPList( )
	{
		typename BaseAPList::const_iterator it = aList.begin();
		typename BaseAPList::const_iterator itEnd = aList.end();
		for( ; it != itEnd ; ++it )
		{
			BaseAPList::push_back( sep::incrReferenceCount( *it ) );
		}
	}


	/**
	 * DESTRUCTOR
	 */
	virtual ~APList()
	{
		clear();
	}

	/**
	 * CLEAR
	 */
	void clear()
	{
		while( BaseAPList::nonempty() )
		{
			sep::destroy( BaseAPList::pop_last() );
		}

		BaseAPList::clear();
	}

};


/**
 * MEMORY MANAGEMENT
 * DESTROY
 */

template< class T >
void destroy(List< T * > * aList)
{
	while( aList->nonempty() )
	{
		sep::destroy( aList->pop_last() );
	}

	delete( aList );

	aList = NULL;
}


template< class T >
void destroy(List< T > * aList)
{
	delete( aList );

	aList = NULL;
}


}

#endif /*CONTAINER_LIST_H_*/