/*
 * CppLists.cpp
 *
 *  Created on: May 9, 2010
 *      Author: Daan Janssens
 */

#include "CppLists.h"
#include <iostream>


namespace CppLists
{
    //constructors
    List::List()
    {
        size = 0;
        first = NULL;
        last = NULL;
    }
    Node::Node(int value)
    {
            data = value;
            next = NULL;
            prev = NULL;
    }

    // dllist functies
    int size(List& myList)
    {
        return myList.size;
    }

    void printNode(Node& myNode)
    {
        std::cout << myNode.data << std::endl;
    }


    void print(List& myList)
        {
            std::cout << "De lijst bevat: " << std::endl;
            Node* tempNode = myList.first;
            while (tempNode != NULL)
            {
                printNode(*tempNode);
                tempNode = tempNode->next;
            }
        }


    void add(List& myList,Node& myNode)
    {

        if (myList.size == 0)
        {
            myList.first = myList.last = &myNode;
            myNode.prev = myNode.next = NULL;
        }
        else
        {
            Node* tempNode = myList.last;

            myNode.prev = tempNode;
            tempNode->next = &myNode;
            myList.last = &myNode;
            myNode.next = NULL;
        }
        ++myList.size;

    }

    void add(List& myList, Node& myNode, unsigned int index)
    {
        if (myList.size == 0)
        {
            myList.first = myList.last = &myNode;
            myNode.prev = myNode.next = NULL;
        }
        else if (index == 0)
        {
            Node* tempNode = myList.first;
            myNode.prev = NULL;
            tempNode->prev = &myNode;
            myNode.next = tempNode;
            myList.first = &myNode;

        }
        else if (myList.size <= index)
        {
            Node* tempNode = myList.last;
            myNode.prev = tempNode;
            tempNode->next = &myNode;
            myList.last = &myNode;
            myNode.next = NULL;
        }
        else
        {
            Node* tempNode = myList.first;
            unsigned int i = 0;
            while (i < index)
            {
                tempNode = tempNode->next;
                ++i;
            }
            myNode.next = tempNode;
            myNode.prev = tempNode->prev;
            tempNode->prev->next = &myNode;
            tempNode->prev = &myNode;
        }
        ++myList.size;
    }

    void addFirst(List& myList,Node& myNode)
    {
        Node* tempNode = myList.first;
        myNode.prev = NULL;
        tempNode->prev = &myNode;
        myNode.next = tempNode;
        myList.first = &myNode;
        ++myList.size;
    }

    void addLast(List& myList,Node& myNode)
    {
        Node* tempNode = myList.last;
        myNode.prev = tempNode;
        tempNode->next = &myNode;
        myList.last = &myNode;
        myNode.next = NULL;
        ++myList.size;
    }

    void clear(List& myList)
    {

        myList.size = 0;
        myList.first = NULL;
        myList.last = NULL;

    }

    bool contains(List& myList, Node& myNode)
    {
        for(unsigned int i=0; i <= myList.size; ++i)
        {
            if( myNode.data == get(myList,i))
            {
                return true;
            }
        }
        return false;

    }

    int getFirst(List& myList)
    {
        return myList.first->data;
    }

    int getLast(List& myList)
    {
        return myList.last->data;
    }

    int get(List& myList, unsigned int index)
    {
        if (myList.size <= index)
        {
            return myList.last->data;
        }
        else
        {
            Node* tempNode = myList.first;
            unsigned int i = 0;
            while (i < index)
            {
                tempNode = tempNode->next;
                ++i;
            }
            return tempNode->data;
        }
    }

    void removeFirst(List& myList)
    {
        myList.first = myList.first->next;
        myList.first->prev = NULL;
        --myList.size;
    }

    void removeLast(List& myList)
    {
        myList.last = myList.last->prev;
        myList.last->next = NULL;
        --myList.size;
    }

    void remove(List& myList, unsigned int index)
    {
        if (myList.size == 0)
        {
            std::cout << "List is empty and nothing can be removed.." << std::endl;
        }
        else if (index == 0)
        {
            removeFirst(myList);
        }
        else if (myList.size <= index)
        {
            removeLast(myList);
        }
        else
        {
            Node* tempNode = myList.first;
            unsigned int i = 0;
            while (i < index)
            {
                tempNode = tempNode->next;
                ++i;
            }
            tempNode->next->prev = tempNode->prev;
            tempNode->prev->next = tempNode->next;
            --myList.size;
        }


    }


/*  int compare(Node& node1, Node& node2)
    {
        if (node1.data > node2.data)
        {
            return -1;
        }
        else if (node1.data == node2.data)
        {
            return 0;
        }
        else
        {
            return 1;
        }
    }

    void sortBefore(List& myList, Node& myNode)
    {
            Node* tempNode;
            tempNode = myList.first;
            while(1)
            {
                int c;
                c = compare(*tempNode,myNode);
                if( c == 1)
                {
                    if (tempNode->prev == NULL)
                    {
                        myList.first = &myNode;
                    }

                    if ( myNode.next == NULL)
                    {
                        myList.last = myNode.prev;
                    }

                    myNode.prev->next = myNode.next;
                    myNode.next->prev = myNode.prev;

                    myNode.prev = tempNode->prev;
                    if ( tempNode->prev != NULL)
                    {
                        tempNode->prev->next = &myNode;
                    }
                    tempNode->prev = &myNode;
                    myNode.next = tempNode;

                    return;

                }
                tempNode = tempNode->next;
            }
    }

    void sort(List& myList)
    {
        Node* currentNode;
        currentNode = myList.first;
        while ( currentNode->next != NULL)
        {
            int c;
            c = compare(*currentNode, *currentNode->next);
            if ( c == 1 )
            {
                sortBefore(myList, *currentNode->next);
            }
            else
            {
                currentNode = currentNode->next;
            }

        }
    }
    */

}