/*
    (c) 2018 Ringo Hoffmann
    SimpleLinkedList v.0.4.0
*/

#include <iostream>

using namespace std;

// Nur um eine Exception throwen zu können, wenn ein Index
// angegeben wurde, welcher nicht in dem Rahmen der Liste
// ist.
class IndexOutOfBoundsException : public exception {
    virtual const char* what() const throw() {
        return "Specified index of element in list is out of bounds.";
    }
};


struct Element {
    int val;
    Element *next;
};


class List {

    public:
    	/**
    		Constructor für liste.
    		Erzeugt eine neue, leere liste mit dem ersten
    		Element als Nullpointer.
    	*/
        List() {
             m_start = 0;
        }
        /**
        	Constructor für Liste.
        	Erzegt eine Liste der Länge 1 mit dem Argument
			als ersten Wert.

			@param val Wert des ersten Elements.
        */
        List(int val) {
            m_start = new Element { val, 0 };
            ++m_len;
        }

        /**
        	Constructor für Liste.
        	Erzeugt eine Liste der Länge angegebener Elemente
        	übergeben in einem Array von Elementen.

        	@param val  Array der Elemente zum Hinzufügen
        	@param size Größe des Arrays
        */
        List(int *val, int size) {
        	m_start = new Element { val[0], 0 };
        	Element *curr = m_start;
        	for (int i = 1; i < size; i++) {
        		curr->next = new Element { val[i], 0 };
        		curr = curr->next;
			}
            m_len += size;
		}

 		/**
 			Gibt die Länge der Liste wieder.

 			@returns Länge der Liste.
 		*/
 	    int len() {
 			return m_len;
		}

 		/**
 			Erzeugt einen Debug-Konsolenoutput mit
 			allen Elementen der Liste, ihren Adressen und
 			den Adressen, auf welche jedes Element verweist.
 		*/
        void output() {
            Element *curr = m_start;
            int i = 0;

            while (curr != 0) {
                cout << i++ << " - [" << curr << "->" << curr->next
                     << "] - " << curr->val << endl;
                curr = curr->next;
            }
            cout << endl << "LEN: " << len() << endl;
            cout << "------------------------" << endl;
        }

		/**
			Ein Element an das Ende der Liste anfügen.

			@param val Anzufügendes Element
		*/
        void push(int val) {
            Element *curr = m_start;

            while (curr->next != 0)
                curr = curr->next;

            curr->next = new Element { val, 0 };
            ++m_len;
        }

        /**
			Fügt alle Werte eines übergebenen Arrays an
			das Ende der Liste an.

			@param val  Array der anzufügenden Elemente.
			@param size Länge des Arrays.
		*/
        void push(int *val, int size) {
        	Element *curr = m_start;

            while (curr->next != 0)
                curr = curr->next;

        	for (int i = 0; i < size; i++) {
        		curr->next = new Element { val[i], 0 };
        		curr = curr->next;
			}

            m_len += size;
		}

        /**
        	Entfernt und gibt das letzte Element der
        	Liste wieder.

        	@returns Wert des letzten Elements der Liste.
        */
        int pop() {
            Element *curr = m_start;
            int out = 0;
            if (curr->next != 0) {
                while (curr->next->next != 0)
                    curr = curr->next;
                out = curr->next->val;
                delete curr->next;
                curr->next = 0;
            }
            else {
                out = curr->val;
                m_start = 0;
            }

            --m_len;
            return out;
        }

		/**
			Gibt den Wert des Elements mit dem angegebenen
			Index wieder.

			@param   index Index des auszulesenden Wertes
			@returns Wert des Elements
		*/
        int get(int index) {
            Element *curr = m_start;
            int i = 0;

            if (index >= m_len || index < 0)
                throw IndexOutOfBoundsException();

            while (curr->next != 0 && i++ < index)
                curr = curr->next;

            return curr->val;
        }

		/**
			Fügt ein Element an einer beliebigen Stelle in
			in der Liste ein.

			@param index Stelle des einzufügenden Elements.
			@param val   Wert des einzufügenden Elements.
		*/
        void insert(int index, int val) {
            Element *curr = m_start;
            int i = 0;

            if (index > m_len || index < 0)
                throw IndexOutOfBoundsException();

            if (index == 0) {
                m_start = new Element { val, m_start };
                return;
            }

            while (curr->next != 0 && ++i < index)
                curr = curr->next;

            curr->next = new Element { val, curr->next };
            --m_len;
        }

        /**
            Fügt alle Elemente eines Arrays in einer
            beliebigen Stelle in der Liste ein.

            @param index Stelle, an der die Elemente
                         eingefügt werden sollen.
        */
        void insert(int index, int *val, int size) {
            Element *curr = m_start, *tmp;
            int i = 0;

            if (index > m_len || index < 0)
                throw IndexOutOfBoundsException();

            if (index == 0) {
                tmp = m_start;
                m_start = new Element { val[0], 0 };
                curr = m_start;
                for (int i = 1; i < size; i++) {
        			curr->next = new Element { val[i], 0 };
        			curr = curr->next;
				}
				curr->next = tmp;
            }
            else {
                for (int i = 0; i < index - 1; i++)
                    curr = curr->next;

                tmp = new Element { curr->next->val, curr->next->next };

                for (int i = 0; i < size; i++) {
                    curr->next = new Element { val[i], 0 };
        			curr = curr->next;
                }

				curr->next = tmp;
                m_len += size;
            }
        }

		/**
			Entfernt einen Wert an einer beliebigen Stelle in
			der Liste.

			@param index Stelle des zu entfernenden Elements.
		*/
        void remove(int index) {
            Element *curr = m_start;
            int i = 0;

            if (index >= m_len || index < 0)
                throw IndexOutOfBoundsException();

            if (index == 0 && m_len == 1) {
                m_start = 0;
                return;
            }

            if (index == m_len - 1) {
                pop();
                return;
            }

            while (curr->next != 0 && ++i < index)
                curr = curr->next;

            if (curr->next != 0) {
                if (curr->next->next != 0)
                    curr->next = curr->next->next;
            }

            --m_len;
        }

        /**
			Ändert den Wert eines Elements an einer
			beliebigen Stelle.

			@param index Index des zu ändernden Elements
			@param val   Neuer Wert des Elements
		*/
        void change(int index, int val) {
        	Element *curr = m_start;

			if (index >= m_len || index < 0)
                throw IndexOutOfBoundsException();

            for (int i = 0; i < index; i++)
            	curr = curr->next;

			curr->val = val;
		}

		/**
			Tauscht die Werte zweier Elemente via der
			Angegebenen Indizes.

			@param i1 Index des ersten Elements.
			@param i2 Index des zweiten Elements.
		*/
        void swap(int i1, int i2) {
            int v1 = get(i1);
            int v2 = get(i2);
            change(i2, v1);
            change(i1, v2);
        }


    private:
    	// Startelement (Ankerelemenet)
        Element *m_start;
        // Länge der Liste
        int m_len = 0;
};

int main() {

    List l(new int[5] {0, 1, 2, 3, 4}, 5);
    //l.insert(2, new int[3] {11, 12, 13}, 3);
    //l.insert(3, 99);
    //l.output();
    //l.swap(1,3);
    l.output();
}