#ifndef HGUARD_NETRUSH_VIEW_ANYVALUESET_HPP__
#define HGUARD_NETRUSH_VIEW_ANYVALUESET_HPP__

#include <memory>
#include <typeindex>
#include <vector>

#include <boost/container/flat_map.hpp>
#include <boost/container/flat_set.hpp>
#include <boost/optional.hpp>


namespace netrush {
namespace view {


	class AnyValueSet
	{
	public:
		
		template< class ValueType >
		void add( ValueType value )
		{
			auto& flag_set = find_or_create_set<ValueType>();
			flag_set.add( std::move(value) );
			m_size_changed = true;
		}

		template< class ValueType >
		void remove( const ValueType& value )
		{
			if( auto* flag_set = find_set<ValueType>() )
			{
				flag_set->remove( std::forward<ValueType>( value ) );
				m_size_changed = true;
			}			
		}

		template< class ValueType, class KeyType >
		boost::optional<ValueType> find( const KeyType& key ) const
		{
			if( auto* flag_set = find_set<ValueType>() )
			{
				return flag_set->find( key );
			}
			return {};
		}

		template< class ValueType >
		boost::optional<ValueType> find( const ValueType& value ) const
		{
			return find<ValueType, ValueType>( value );
		}


		template< class ValueType, class KeyType >
		bool contains( const KeyType& key ) const
		{
			if( auto* flag_set = find_set<ValueType>() )
			{
				return flag_set->contains( key );
			}
			return false;
		}

		template< class ValueType >
		bool contains( const ValueType& value ) const
		{
			return contains<ValueType, ValueType>( value );
		}


		void insert( const AnyValueSet& other )
		{
			for( const auto& set_pair : other.m_set_index )
			{
				if( auto flag_set = find_set( set_pair.first ) )
				{
					flag_set->insert( *set_pair.second );
				}
				else
				{
					m_set_index.emplace( set_pair.first, set_pair.second->clone() );
				}
			}
			m_size_changed = true;
		}


		template< class ValueType >
		std::vector<ValueType> all() const
		{
			if( auto* flag_set = find_set<ValueType>() )
			{
				return flag_set->values();
			}
			return {};
		}
		
		size_t size() const 
		{ 
			if( m_size_changed )
			{
				m_size_changed = false;
				compute_size();
			}
				
			return m_size; 
		}

	private:

		struct Set
		{
			virtual void insert( const Set& other ) = 0;
			virtual std::unique_ptr<Set> clone() = 0;
			virtual size_t size() const = 0;
		};

		template< class T >
		class SetOf : public Set
		{
			boost::container::flat_set<T> m_values;
		public:
			SetOf() = default;

			template< class Iterator >
			SetOf( Iterator&& it_begin, Iterator&& it_end )
				: m_values( std::forward<Iterator>( it_begin ), std::forward<Iterator>( it_end ) )
			{}

			/** Add a new value or replace an old one by the provided one.
			*/
			void add( T value ) 
			{
				auto result = m_values.emplace( std::move( value ) );
				if( !result.second ) // force overwriting if the value already exists
					*result.first = value;
			}
			void remove( T value ) { m_values.erase( std::move( value ) ); }

			template< class KeyType >
			boost::optional<T> find( const KeyType& key ) const
			{
				for( const auto& value : m_values )
				{
					if( value == key ) 
						return value;
				}

				return {};
			}

			template< class KeyType >
			bool contains( const KeyType& key ) const 
			{ 
				for( const auto& value : m_values )
				{
					if( value == key )
						return true;
				}
					
				return false;
			}
			
			void insert( const Set& other ) override
			{
				const auto& specific_set = static_cast<const SetOf<T>&>( other );
				m_values.insert( begin( specific_set.m_values ), end( specific_set.m_values ) );
			}

			std::unique_ptr<Set> clone() override
			{
				return std::make_unique<SetOf<T>>( begin( m_values ), end( m_values ) );
			}

			size_t size() const override { return m_values.size(); }

			std::vector<T> values() const
			{
				return { begin( m_values ), end( m_values ) };
			}
		};

		boost::container::flat_map<std::type_index, std::shared_ptr<Set>> m_set_index;
		mutable bool m_size_changed = false;
		mutable size_t m_size = 0;
		

		Set* find_set( std::type_index type_id ) const
		{
			auto find_it = m_set_index.find( type_id );
			if( find_it != end( m_set_index ) )
			{
				auto& specific_set = *find_it->second;
				return &specific_set;
			}
			return nullptr;
		}


		template< class T >
		SetOf<T>* find_set() const { return static_cast<SetOf<T>*>( find_set( typeid( T ) ) ); }

		template< class T >
		SetOf<T>& find_or_create_set()
		{
			if( auto* specific_set = find_set<T>() )
			{
				return *specific_set;
			}

			auto position = m_set_index.emplace( typeid( T ), std::make_shared < SetOf < T >> ( ) ).first;
			return static_cast<SetOf<T>&>( *position->second );
		}

		void compute_size() const
		{
			m_size = 0;
			for( const auto& set_pair : m_set_index )
			{
				m_size += set_pair.second->size();
			}
		}

	};


}}


#endif