#include "pch.h"
#include "CppUnitTest.h"
#include "SinglyLinkedList.hpp"
#include "crt_check_memory.hpp"

using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace CST_126;

namespace LinkedListUnitTests
{
	TEST_CLASS(LinkedListUnitTests)
	{
	public:
		
		TEST_METHOD(EmptyListHasZeroSize)
		{
			SinglyLinkedList<int> LinkedList{};
			Assert::AreEqual(0ull, LinkedList._size);
		}

		TEST_METHOD(AppendingLinkedListWith1Item)
		{
			SinglyLinkedList<int> LinkedList{};
			ListNode<int>* node = new ListNode<int>{ 5, nullptr };
			

			bool Success = Append(&LinkedList, node);
			Assert::AreEqual(5, LinkedList._head->_data);
			delete node;
		}
		TEST_METHOD(AppendingLinkedListWith5Items)
		{
			struct SinglyLinkedList<int> LinkedList = {};
			ListNode<int>Node1 ={ 1,nullptr };
			ListNode<int>Node2 ={ 2,nullptr };
			ListNode<int>Node3 ={ 3,nullptr };
			ListNode<int>Node4 ={ 4,nullptr };
			ListNode<int>Node5 = { 5, nullptr };
			

			bool success = Append(&LinkedList, &Node1);
			success = Append(&LinkedList, &Node2);
			success = Append(&LinkedList, &Node3);
			success = Append(&LinkedList, &Node4);
			success = Append(&LinkedList, &Node5);

			Assert::AreEqual(Node1._data, LinkedList._head->_data);

			ListNode<int>* TraverseNode = LinkedList._head;

			for (auto i = 1; i <= 5; i++)
			{
				Assert::AreEqual(i, TraverseNode->_data);
				TraverseNode = TraverseNode->_next;
			}

			
		}

		TEST_METHOD(One_Append_Clear_LinkedList_Success)
		{
			struct SinglyLinkedList<int> LinkedList = {};
			ListNode<int>Node1 = { 1,nullptr };


			bool success = Append(&LinkedList, &Node1);
			
			Clear(&LinkedList);

			Assert::AreEqual(0ull, LinkedList._size);
			Assert::IsNull(LinkedList._head);


		}


		TEST_METHOD(Multiple_Append_Clear_LinkedList_Success)
		{
			struct SinglyLinkedList<int> LinkedList = {};
			ListNode<int>Node1 = { 1,nullptr };
			ListNode<int>Node2 = { 2,nullptr };
			ListNode<int>Node3 = { 3,nullptr };
			ListNode<int>Node4 = { 4,nullptr };
			ListNode<int>Node5 = { 5,nullptr };

			bool success = Append(&LinkedList, &Node1);
			success = Append(&LinkedList, &Node2);
			success = Append(&LinkedList, &Node3);
			success = Append(&LinkedList, &Node4);
			success = Append(&LinkedList, &Node5);


			Clear(&LinkedList);

			Assert::AreEqual(0ull, LinkedList._size);
			Assert::IsNull(LinkedList._head);
			Assert::IsNull(Node1._next);
			Assert::IsNull(Node2._next);
			Assert::IsNull(Node3._next);
			Assert::IsNull(Node4._next);
			Assert::IsNull(Node5._next);
		}

		TEST_METHOD(Insert_After_Single_LinkedList_Success)
		{
			//Arrange
			struct SinglyLinkedList<int> NewList{};
			ListNode<int> Node1 = { 1,nullptr };
			ListNode<int>Node2 = { 2,nullptr };
			ListNode<int>Node3 = { 3,nullptr };
			ListNode<int>Node4 = { 4,nullptr };
			ListNode<int>Node5 = { 5,nullptr };
			//Act
			bool Success = Append(&NewList, &Node1);
			Success = Append(&NewList, &Node2);
			Success = Append(&NewList, &Node3);
			Success = Append(&NewList, &Node5);

			

			ListNode<int>* TraverseNode = NewList._head;

			for (auto i = 1; i < 5; i++)
			{
				Assert::AreEqual(i, TraverseNode->_data);
				TraverseNode = TraverseNode->_next;
			}
			
			//Assert
			//Assert that list is corret
		}

		//TEST_METHOD(DeleteFirstLinkWith0)
		//{
		//	SinglyLinkedList<int> LinkedList{};
		//	ListNode<int>* node = new ListNode<int>{};
		//	bool Success = RemoveFirst(&LinkedList);
		//	Assert::AreEqual(1, static_cast<int>(Success));
		//	delete node;
		//}
		//
		//TEST_METHOD(PREPENDLINKEDLIST)
		//{

		//}

		//TEST_METHOD(ExtractFirst_LinkedList_Success)
		//{
		//	struct SinglyLinkedList<int> NewList {};
		//	ListNode<int> Node1 = { 1,nullptr };
		//	ListNode<int>Node2 = { 2,nullptr };
		//	ListNode<int>Node3 = { 3,nullptr };
		//	ListNode<int>Node4 = { 4,nullptr };
		//	ListNode<int>Node5 = { 5,nullptr };

		//	ListNode<int> NodeArray[] = { Node1, Node2, Node3, Node4, Node5 };

		//	for (auto node : NodeArray)
		//	{
		//		Assert::IsTrue(Append(&NewList, &node));
		//	}

		//	ListNode<int>* Temp = Extract(&NewList, Node1._data);
		//
		///*	size_t NodeAddress = reinterpret_cast<size_t>(&Node1);
		//	size_t TempAddress = reinterpret_cast<size_t>(&Temp);*/
		//	//Assert::AreSame(&Node1, Temp);

		//
		//	
		//	//Assert::AreEqual(&Node1, Extract(&NewList, Node1._data));
		//
		//	//Assert::AreEqual(NodeAddress, TempAddress);
		//	//Assert::AreEqual(4ull, NewList._size);




		//	delete Temp;
		//}


		//TEST_METHOD(Extract_Last_LinkedList_Success)
		//{
		//	struct SinglyLinkedList<int> NewList {};
		//	ListNode<int> Node1 = { 1,nullptr };
		//	ListNode<int>Node2 = { 2,nullptr };
		//	ListNode<int>Node3 = { 3,nullptr };
		//	ListNode<int>Node4 = { 4,nullptr };
		//	ListNode<int>Node5 = { 5,nullptr };

		//	ListNode<int> NodeArray[] = { Node1, Node2, Node3, Node4, Node5 };

		//	for (auto node : NodeArray)
		//	{
		//		Assert::IsTrue(Append(&NewList, &node));
		//	}

		//}

		//TEST_METHOD(Extract_Middle_LinkedList_Success)
		//{
		//	struct SinglyLinkedList<int> NewList {};
		//	ListNode<int> Node1 = { 1,nullptr };
		//	ListNode<int>Node2 = { 2,nullptr };
		//	ListNode<int>Node3 = { 3,nullptr };
		//	ListNode<int>Node4 = { 4,nullptr };
		//	ListNode<int>Node5 = { 5,nullptr };

		//	ListNode<int> NodeArray[] = { Node1, Node2, Node3, Node4, Node5 };

		//	for (auto node : NodeArray)
		//	{
		//		Assert::IsTrue(Append(&NewList, &node));
		//	}




		//}

		
		



	};
	TEST_CLASS(NodeUnitTests)
	{
	public:
		const CrtCheckMemory Check;


		TEST_METHOD(NodeConstructor_Success)
		{
			Node<int>* NewNode = new Node<int>();

			Assert::IsNotNull(NewNode);


			delete NewNode;
		}



		TEST_METHOD(NodeLoadedConstructor_Success)
		{
			const CrtCheckMemory Check;

			Node<int>* NewNode = new Node<int>(5);

			Assert::IsNotNull(NewNode);
			Assert::AreEqual(5, NewNode->Data());
		}
		

	}



};