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

using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace CST126;

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);

			InsertAfter(&NewList, 3, &Node4);

			ListNode<int>* TraverseNode = NewList._head;

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

			struct SinglyLinkedList<int> NewList {};
			ListNode<int> Node1 = { 1,nullptr };

			InsertAfter(&NewList, NULL, &Node1);

		

			Assert::AreEqual(1, NewList._head->_data);
		}


		TEST_METHOD(Insert_Before_UNO_List)
		{
			struct SinglyLinkedList<int> NewList{};
			ListNode<int> Node1 = { 1, nullptr };
			ListNode<int> Node2 = { 2, nullptr };
			bool Success = InsertBefore(&NewList, 1, &Node2);

			Assert::AreEqual(2, NewList._head->_data);
		}

		TEST_METHOD(Insert_Before_5_List)
		{
			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 };
	
			bool Success = Append(&NewList, &Node1);
			Success = Append(&NewList, &Node2);
			Success = Append(&NewList, &Node3);
			Success = Append(&NewList, &Node5);
			InsertBefore(&NewList, 5, &Node4);

			ListNode<int>* Traverse = NewList._head;
			for (auto i = 1; i < 5; i++)
			{
				Traverse = Traverse->_next;
			}

			Assert::AreEqual(4, Traverse->_data);
		}
		
		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(Prepend_LinkedList_With_0)
		{
			struct SinglyLinkedList<int> NewList {};
			ListNode<int> Node1 = { 1,nullptr };

			Prepend(&NewList, &Node1);

			Assert::AreEqual(1, NewList._head->_data);
			Assert::AreEqual(1ull, NewList._size);
		}

		TEST_METHOD(Prepend_LinkedList_With_5)
		{
			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 };

			bool Success = Append(&NewList, &Node2);
			Success = Append(&NewList, &Node3);
			Success = Append(&NewList, &Node4);
			Success = Append(&NewList, &Node5);

			Prepend(&NewList, &Node1);

			Assert::AreEqual(1, NewList._head->_data);
			Assert::AreEqual(5ull, NewList._size);
		}

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

			bool Success = Append(&NewList, &Node1);

			RemoveFirst(&NewList);

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

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

			Assert::IsTrue(RemoveFirst(&NewList));
			Assert::IsNull(NewList._head);
		}

		TEST_METHOD(RemoveFirst_LinkedList_5items)
		{
			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 };


			bool Success = Append(&NewList, &Node1);
			Success = Append(&NewList, &Node2);
			Success = Append(&NewList, &Node3);
			Success = Append(&NewList, &Node4);
			Success = Append(&NewList, &Node5);

			Assert::IsTrue(RemoveFirst(&NewList));
			Assert::AreEqual(NewList._head->_data, Node2._data);
		}


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

			bool Success = Append(&NewList, &Node1);

			RemoveLast(&NewList);

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

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

			Assert::IsTrue(RemoveLast(&NewList));
			Assert::IsNull(NewList._head);
		}

		TEST_METHOD(RemoveLast_LinkedList_5items)
		{
			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 };


			bool Success = Append(&NewList, &Node1);
			Success = Append(&NewList, &Node2);
			Success = Append(&NewList, &Node3);
			Success = Append(&NewList, &Node4);
			Success = Append(&NewList, &Node5);

			Assert::IsTrue(RemoveFirst(&NewList));

			ListNode<int>* Traverse = NewList._head;
			for (auto i = 1; i < 3; i++)
			{
				Traverse = Traverse->_next;
			}
			Assert::AreEqual(4ull, NewList._size);
			Assert::AreEqual(Node4._data, Traverse->_data);
		}



		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 };

			
			bool Success = Append(&NewList, &Node1);
			Success = Append(&NewList, &Node2);
			Success = Append(&NewList, &Node3);
			Success = Append(&NewList, &Node4);
			Success = Append(&NewList, &Node5);


			ListNode<int>* Temp = Extract(&NewList, Node1._data);
			ListNode<int>* NullCheck = &Node1;
		
			Assert::AreEqual(1, Temp->_data);
			Assert::IsNull(NullCheck->_next);

			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 };

			bool Success = Append(&NewList, &Node1);
			Success = Append(&NewList, &Node2);
			Success = Append(&NewList, &Node3);
			Success = Append(&NewList, &Node4);
			Success = Append(&NewList, &Node5);

			ListNode<int>* Temp = Extract(&NewList, Node5._data);
			ListNode<int>* NullCheck = &Node4;

			Assert::AreEqual(5, Temp->_data);
			Assert::IsNull(NullCheck->_next);

			delete Temp;
		}

		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 };

			

			bool Success = Append(&NewList, &Node1);
			Success = Append(&NewList, &Node2);
			Success = Append(&NewList, &Node3);
			Success = Append(&NewList, &Node4);
			Success = Append(&NewList, &Node5);


			ListNode<int>* Temp = Extract(&NewList, Node3._data);
			ListNode<int>* NullCheck = &Node3;

			Assert::AreEqual(3, Temp->_data);
			Assert::IsNull(Node3._next);
			delete Temp;

		}


		TEST_METHOD(Clear_LinkedList_Full)
		{
			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 };



			bool Success = Append(&NewList, &Node1);
			Success = Append(&NewList, &Node2);
			Success = Append(&NewList, &Node3);
			Success = Append(&NewList, &Node4);
			Success = Append(&NewList, &Node5);
			Clear(&NewList);

			Assert::AreEqual(0ull, NewList._size);

		}

		TEST_METHOD(Clear_LinkedList_Empty)
		{
			struct SinglyLinkedList<int> NewList {};
		
			Clear(&NewList);

			Assert::AreEqual(0ull, NewList._size);

		}

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

			bool Success = Append(&NewList, &Node1);
			
			Clear(&NewList);

			Assert::AreEqual(0ull, NewList._size);
		
		}
	};


	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());

			delete NewNode;
		}
		
	};

};