TEST_CASE("basicMine") {
	std::stringstream stream;

	SECTION("void") {
		//REQUIRE(PrettyPrint::typeString() == "void");
	}

	SECTION("bool") {
		REQUIRE(PrettyPrint::typeString(true) == "bool");
		REQUIRE(PrettyPrint::dataString(true) == "true");
	}

	SECTION("float") {
		float val = 0.1f;
		stream << "This is a " << PrettyPrint::type(val) << " that contains " << PrettyPrint::data(val);
		REQUIRE(stream.str() == "This is a float that contains 0.1f");
	}

	SECTION("pair") {
		auto pair = std::make_pair(0.1, '\n');
		REQUIRE(PrettyPrint::typeString(pair) == "pair<double, char>");
	}

	SECTION("char") {
		REQUIRE(PrettyPrint::typeString('a') == "char");
		stream << PrettyPrint::data('\x1') << 100;
		REQUIRE(stream.str() == "'\\x1'100");
	}

	SECTION("string") {
		std::string hello = "Hello";
		//REQUIRE(PrettyPrint::typeString("ahoj") == "char[5]");
		REQUIRE(PrettyPrint::typeString(hello) == "string");
	}

	SECTION("map") {
		const std::map<int, unsigned> m = { { 3, 14 }, { 7, 42 }, { 0, 0 } };
		REQUIRE(PrettyPrint::dataString(m) == "map<int, unsigned>{ 0: 0u, 3: 14u, 7: 42u }");
	}

	SECTION("vector") {
		const std::vector<int> v = { };
		REQUIRE(PrettyPrint::dataString(v) == "vector<int>{ }");
		const std::vector<int> vi = {1, 2, 3};
		REQUIRE(PrettyPrint::dataString(vi) == "vector<int>{ 1, 2, 3 }");
		const std::vector<char> vc = {'a', 'b', 'c'};
		REQUIRE(PrettyPrint::dataString(vc) == "vector<char>{ 'a', 'b', 'c' }");
	}

	SECTION("set") {
		const std::set<int> v = { };
		REQUIRE(PrettyPrint::dataString(v) == "set<int>{ }");
		const std::set<int> vi = {1, 2, 3};
		REQUIRE(PrettyPrint::dataString(vi) == "set<int>{ 1, 2, 3 }");
		const std::set<char> vc = {'a', 'b', 'c'};
		REQUIRE(PrettyPrint::dataString(vc) == "set<char>{ 'a', 'b', 'c' }");
	}

	SECTION("C_ptr") {
		int i = -1;
		int *ptr = &i;
		std::stringstream s;
		s << "int*{ ";
		s << ptr;
		s << " }";
		std::cout << s.str() << std::endl;
		REQUIRE(PrettyPrint::dataString(ptr) == s.str());

		int *ptrnull;
		REQUIRE(PrettyPrint::dataString(ptrnull) == "int*{ nullptr }");
	}

	SECTION("unique_ptr") {
		const auto ptr = std::make_unique<int>(-1);
		std::unique_ptr<int> ptrnull = nullptr;
		std::stringstream s;
		s << "int*{ ";
		s << ptr.get();
		s << " }";
		std::cout << s.str() << std::endl;
		std::cout << PrettyPrint::dataString(ptr) << std::endl;
		REQUIRE_THAT(PrettyPrint::dataString(ptrnull), Catch::StartsWith("unique_ptr<int>{ "));
		REQUIRE_THAT(PrettyPrint::dataString(ptr), Catch::StartsWith("unique_ptr<int>{ "));
		REQUIRE_THAT(PrettyPrint::dataString(ptr), Catch::EndsWith(" }"));
	}

	SECTION("array") {
		int array[3] = { 0, 1, 2};
		REQUIRE(PrettyPrint::typeString(array) == "int[3]");
		REQUIRE(PrettyPrint::dataString(array) == "int[3]{ 0, 1, 2 }");
	}
}

struct Person {
	std::string name;
	std::string surname;
};

namespace PrettyPrint {
	template <>
	struct Type<Person> {
		std::ostream& operator()(std::ostream& os) const {
			return os << "Person";
		}
	};

	template <>
	struct Data<Person> {
		Data(const Person& val) : val(val) {}
		std::ostream& operator()(std::ostream& os) const {
			return os << PrettyPrint::type(val) << ": " << val.name << " " << val.surname;
		}
		const Person& val;
	};
}


TEST_CASE("basicR") {
	std::stringstream stream;

	SECTION("bool") {
		REQUIRE(PrettyPrint::typeString(true) == "bool");
		REQUIRE(PrettyPrint::dataString(true) == "true");
	}

	SECTION("float") {
		float val = 0.1f;
		stream << "This is a " << PrettyPrint::type(val) << " that contains " << PrettyPrint::data(val);
		REQUIRE(stream.str() == "This is a float that contains 0.1f");
	}

	SECTION("pair") {
		auto pair = std::make_pair(0.1, '\n');
		REQUIRE(PrettyPrint::typeString(pair) == "pair<double, char>");
		REQUIRE(PrettyPrint::dataString(pair) == "pair<double, char>{ 0.1, '\\n' }");

	}

	SECTION("My nullptr"){
		std::nullptr_t aNullptr;
		REQUIRE(PrettyPrint::typeString(aNullptr) == "nullptr_t");
		REQUIRE(PrettyPrint::dataString(nullptr) == "nullptr_t{ nullptr }");
		//REQUIRE(PrettyPrint::dataString(aNullptr) == "nullptr_t{ nullptr }");

	}


	SECTION("char") {
		REQUIRE(PrettyPrint::typeString('a') == "char");
		stream << PrettyPrint::data('\x1') << 100;
		REQUIRE(stream.str() == "'\\x1'100");
		REQUIRE(PrettyPrint::dataString('\f')  == "\'\\f\'");
		int i = 5;
		int *ptrInt = &i;

		/*char ch = 'c';
		char *ptr = &ch;
		REQUIRE(PrettyPrint::dataString(ptr) == "");*/
	}


	SECTION("string") {
		std::string hello = "Hello";
		REQUIRE(PrettyPrint::typeString("ahoj") == "char[5]");
		//std::cout << PrettyPrint::dataString(hello);

		REQUIRE(PrettyPrint::dataString(hello) == "\"Hello\"");

		REQUIRE(PrettyPrint::dataString("abc") == "char[4]{ 'a', 'b', 'c', '\\0' }");
		REQUIRE(PrettyPrint::typeString(hello) == "string");
		REQUIRE(PrettyPrint::typeString("4") == "char[2]");
	}

	SECTION("Vector"){
		std::vector<int> vector = {5,6,3,1,05,123,456,78999};
		std::vector<int> empty_vector = { };
		REQUIRE(PrettyPrint::typeString(vector) == "vector<int>");
		REQUIRE(PrettyPrint::dataString(vector) == "vector<int>{ 5, 6, 3, 1, 5, 123, 456, 78999 }");
		REQUIRE(PrettyPrint::dataString(empty_vector) == "vector<int>{ }");
		//std::cout << PrettyPrint::dataString(vector);
	}

	SECTION("array") {
		int mArray[5] = {0,1,2,3,4};
		REQUIRE(PrettyPrint::typeString(mArray) == "int[5]");
		REQUIRE(PrettyPrint::dataString(mArray) == "int[5]{ 0, 1, 2, 3, 4 }");
	}

	SECTION("Set") {
		std::set<int> set = {5, 6, 3, 1, 05};
		std::set<int> empty_set = {};
		REQUIRE(PrettyPrint::typeString(set) == "set<int>");
		REQUIRE(PrettyPrint::dataString(set) == "set<int>{ 1, 3, 5, 6 }");
		REQUIRE(PrettyPrint::dataString(empty_set) == "set<int>{ }");
	}

	SECTION("map") {
		const std::map<int, unsigned> m = { { 3, 14 }, { 7, 42 }, { 0, 0 } };
		const std::map<std::string, float> m1 = {{"a", 0.1}, {"b", 0.2}};
		const std::map<float, bool> empty_map = { };
		REQUIRE(PrettyPrint::dataString(m) == "map<int, unsigned>{ 0: 0u, 3: 14u, 7: 42u }");
		REQUIRE(PrettyPrint::dataString(m1) == "map<string, float>{ \"a\": 0.1f, \"b\": 0.2f }");
		REQUIRE(PrettyPrint::dataString(empty_map) == "map<float, bool>{ }");
	}

	SECTION("raw pointer"){
		void* p;
		int my_int = 30;
		int* a = &my_int;
		REQUIRE(PrettyPrint::typeString(p) == "void*");
		REQUIRE(PrettyPrint::typeString(a) == "int*");
		//std::cout << PrettyPrint::dataString(a) << "\n";
		REQUIRE_THAT(PrettyPrint::dataString(a), Catch::StartsWith("int*{ "));
		REQUIRE_THAT(PrettyPrint::dataString(a), Catch::EndsWith(" }"));

	}


	SECTION("unique_ptr") {
		const auto ptr = std::make_unique<int>(-1);
		REQUIRE(PrettyPrint::typeString(ptr) == "unique_ptr<int>");
		REQUIRE_THAT(PrettyPrint::dataString(ptr), Catch::StartsWith("unique_ptr<int>{ "));
		REQUIRE_THAT(PrettyPrint::dataString(ptr), Catch::EndsWith(" }"));
	}


}