#include <gtest/gtest.h>

#include <string>

#include <netrush/system/view/anyvalueset.hpp>

using namespace netrush::view;

struct Foo
{
	int k;
	float l;
};

bool operator==( const Foo& a, const Foo& b )
{
	return a.k == b.k
		&& a.l == b.l
		;
}

bool operator< ( const Foo& a, const Foo& b )
{
	return a.k < b.k
		&& a.l < a.l
		;
}

struct Id
{
	int value;
};

bool operator==( const Id& a, const Id& b )
{
	return a.value == b.value;
}

bool operator< ( const Id& a, const Id& b )
{
	return a.value < b.value;
}


struct Entity
{
	Id id;
	std::string name;
};

bool operator==( const Entity& a, const Entity& b )
{
	return a.id == b.id;
}

bool operator< ( const Entity& a, const Entity& b )
{
	return a.id < b.id;
}

bool operator==( const Id& a, const Entity& b )
{
	return a == b.id;
}
bool operator==( const Entity& a, const Id& b )
{
	return b == a;
}

template< class T >
void test_all_operations( AnyValueSet& value_set, T value )
{
	const auto begin_size = value_set.size();
	value_set.add( value );
	ASSERT_TRUE( value_set.contains( value ) );
	const auto stored_value = value_set.find( value );
	ASSERT_EQ( value, *stored_value );
	ASSERT_EQ( begin_size + 1, value_set.size() );

	auto values = value_set.all<T>();
	auto find_it = std::find( begin( values ), end( values ), value );
	ASSERT_NE( end( values ), find_it );
}

TEST( Test_AnyValueSet, any_kind_of_values )
{
	AnyValueSet value_set;
	test_all_operations( value_set, 42 );
	test_all_operations( value_set, 3.14 );
	test_all_operations( value_set, 0.5f );
	test_all_operations( value_set, Foo{ 42, 0.5f } );
	test_all_operations( value_set, Id{ 1234 } );
	test_all_operations( value_set, Entity{ Id{ 5678 }, "A" } );
}

TEST( Test_AnyValueSet, unique_simple_values )
{
	AnyValueSet value_set;
	value_set.add( 42 );
	value_set.add( 42 );
	value_set.add( 42 );
	value_set.add( 42 );
	value_set.add( 42 );
	ASSERT_EQ( 1, value_set.size() );

}

TEST( Test_AnyValueSet, unique_key_values )
{
	AnyValueSet value_set;
	value_set.add( Entity{ Id{ 42 }, "A" } );
	value_set.add( Entity{ Id{ 42 }, "B" } );
	value_set.add( Entity{ Id{ 42 }, "C" } );
	value_set.add( Entity{ Id{ 42 }, "D" } );
	value_set.add( Entity{ Id{ 42 }, "E" } );
	
	ASSERT_EQ( 1, value_set.size() );
	ASSERT_EQ( "E", value_set.find<Entity>( Id{ 42 } )->name );
}


TEST( Test_AnyValueSet, merge_sets_same_type )
{
	AnyValueSet set_a, set_b;
	
	set_a.add( 1 );
	set_a.add( 2 );
	set_a.add( 3 );
	set_a.add( 4 );
	
	set_b.add( 1 );
	set_b.add( 2 );
	set_b.add( 3 );
	set_b.add( 4 );
	set_b.add( 5 );
	set_b.add( 6 );
	set_b.add( 7 );
	set_b.add( 8 );

	set_a.insert( set_b );
	ASSERT_EQ( set_a.size(), set_b.size() );
	auto b_values = set_b.all<int>();
	for( const auto i : b_values )
	{
		ASSERT_TRUE( set_a.contains( i ) );
	}

	AnyValueSet set_c;
	set_c.insert( set_a );
	auto c_values = set_c.all<int>();
	for( const auto i : c_values )
	{
		ASSERT_TRUE( set_a.contains( i ) );
	}
	for( const auto i : b_values )
	{
		ASSERT_TRUE( set_c.contains( i ) );
	}

}

TEST( Test_AnyValueSet, merge_sets_different_types )
{
	AnyValueSet set_a, set_b;

	set_a.add( 1 );
	set_a.add( 2 );
	set_a.add( 3 );
	set_a.add( 4 );

	set_b.add( 1.f );
	set_b.add( 2.f );
	set_b.add( 3.f );
	set_b.add( 4.f );
	set_b.add( 5.f );
	set_b.add( 6.f );
	set_b.add( 7.f );
	set_b.add( 8.f );

	set_a.insert( set_b );
	AnyValueSet set_c;
	set_c.insert( set_a );

	{

		auto b_values = set_b.all<int>();
		for( const auto i : b_values )
		{
			ASSERT_TRUE( set_a.contains( i ) );
		}
		auto c_values = set_c.all<int>();
		for( const auto i : c_values )
		{
			ASSERT_TRUE( set_a.contains( i ) );
		}
		for( const auto i : b_values )
		{
			ASSERT_TRUE( set_c.contains( i ) );
		}
	}
	{
		
		auto b_values = set_b.all<float>();
		for( const auto i : b_values )
		{
			ASSERT_TRUE( set_a.contains( i ) );
		}
		auto c_values = set_c.all<float>();
		for( const auto i : c_values )
		{
			ASSERT_TRUE( set_a.contains( i ) );
		}
		for( const auto i : b_values )
		{
			ASSERT_TRUE( set_c.contains( i ) );
		}
	}


}