// MAIN:
#include "queue_lnk.hpp"

typedef LinkedQueue<int> IntQueue;

int main()
{
    IntQueue a;

    a.addToQueue(1);
    a.addToQueue(2);
    a.addToQueue(3);

    cout << "Queue: ";
    printOut(a);
    cout << endl;

    cout << "-----------------------------" << endl;
    cout << "Obavlja se uklanjanje iz reda!" << endl;
    a.removeFromQueue();

    cout << "Queue: ";
    printOut(a);
    cout << endl;

    cout << "-----------------------------" << endl;
    cout << "Dodavanje u red broja 45!" << endl;
    a.addToQueue(45);
    cout << "Queue: ";
    printOut(a);
    cout << endl;

    cout << "-----------------------------" << endl;
    cout << "Pokusaj samo citanja (ne i uklanjanja) iz reda!" << endl;
    int ret;
    if (a.readFromQueue(ret))
        cout << "Obavljeno citanje iz reda: " << ret << endl;
    else
        cout << "Citanje nije obavljeno - Prazan red!" << endl;

    cout << "-----------------------------" << endl;
    cout << "Obavlja se uklanjanje iz reda!" << endl;
    a.removeFromQueue();
    cout << "Queue: ";
    printOut(a);
    cout << endl;

    cout << "-----------------------------" << endl;
    cout << "Obavlja se uklanjanje iz reda!" << endl;
    a.removeFromQueue();
    cout << "Queue: ";
    printOut(a);
    cout << endl;

    cout << "-----------------------------" << endl;
    cout << "Pokusaj samo citanja (ne i uklanjanja) iz reda!" << endl;
    if (a.readFromQueue(ret))
        cout << "Obavljeno citanje iz reda: " << ret << endl;
    else
        cout << "Citanje nije obavljeno - Prazan red!" << endl;

    cout << "-----------------------------" << endl;
    cout << "Dodavanje u red broja 100!" << endl;
    a.addToQueue(100);
    cout << "Queue: ";
    printOut(a);

    return 0;
}


// QUEUELNK:
#ifndef QUEUE_LNK_HPP_INCLUDED
#define QUEUE_LNK_HPP_INCLUDED

#include "list.hpp"

template <class T>
class LinkedQueue;

template <class T>
void printOut(const LinkedQueue<T> &);

template <class T>
class LinkedQueue : private List <T>
{
    public:
        LinkedQueue() {};
        bool readFromQueue(T&) const;
        void removeFromQueue()
        {
            List<T>::remove(1);
        }
        void addToQueue(const T &El)
        {
            add(size()+1, El);
        }
        bool empty() const
        {
            return List<T> :: empty();
        }
        int size() const
        {
            return List<T> :: size();
        }
        friend void printOut<>(const LinkedQueue<T>&);
        virtual ~LinkedQueue() {}
};

template <class T>
void printOut(const LinkedQueue<T> &rlq)
{
    cout << endl;
    cout << "\tVelicina reda: " << rlq.size() << endl;
    cout << "\tSadrzaj reda je: ";
    T retVal;
    for (int i = 1; i<=rlq.size(); i++)
    {
        if (i>1)
            cout << ", ";
        rlq.read(i, retVal);
        cout << retVal;
    }
    cout << endl << endl;
}

template <class T>
bool LinkedQueue<T> :: readFromQueue(T& retVal) const
{
    return List<T> :: read(1, retVal);
}



#endif // QUEUE_LNK_HPP_INCLUDED

// LIST:
#ifndef LIST_DEF
#define LIST_DEF

#include <stdlib.h>
#include <iostream>
using namespace std;

template <class T>
class List{
    private:
        struct listEl{
            T content;
            struct listEl *next;
        };
        listEl *head;
        listEl *tail;
        int noEl;
    public:
        List(){
            head=tail=NULL;
            noEl=0;
        }
        List(const List<T>&);
        List<T>& operator=(const List<T>&);
        virtual ~List();
        int getH() const { return (int)head; }
        int getT() const { return (int)tail; }
        int size() const {return noEl;}
        bool empty() const {return head==NULL?1:0;}
        bool add(int, const T&);
        bool remove(int);
        bool read(int, T&)const;
        void clear();

};

template <class T>
ostream& operator<<(ostream & out, const List<T> &l){
    out<<endl;
    out<<"--------"<<endl;
    for(int i=1;i<=l.size();i++){
        if(i!=1) out<<", ";
        T res;
        l.read(i,res);
        out<<res;
    }
    out<<endl<<"--------"<<endl;
    return out;
}

template <class T>
List<T>::List(const List<T> &l){
    head=NULL;
    tail=NULL;
    noEl=0;
    for(int i=1;i<=l.noEl;i++){
        T res;
        if(l.read(i,res))
            add(i,res);
    }
}

template <class T>
List<T>& List<T>::operator=(const List<T> &l){
    if(this!=&l){
        clear();
        head=NULL;
        tail=NULL;
        noEl=0;
        for(int i=1;i<=l.noEl;i++){
            T res;
            if(l.read(i,res))
                add(i,res);
        }
    }
    return *this;
}

template <class T>
List<T>::~List(){
    while(!empty())
        remove(1);
}

template <class T>
bool List<T>::add(int n, const T& newContent){
    if(n<1 || n>noEl+1)
        return false;
    else{
        listEl *newEl=new listEl;
        if(newEl==NULL)
            return false;
        else{
            newEl->content=newContent;
            if(n==1){
                newEl->next=head;
                head=newEl;
            }else if(n==noEl+1){
                newEl->next=NULL;
                tail->next=newEl;
            }else{
                listEl *temp=head;
                for(int i=2;i<n;i++)
                    temp=temp->next;
                newEl->next=temp->next;
                temp->next=newEl;
            }
            noEl++;
            if(newEl->next==NULL)
                tail=newEl;
            return true;
        }
    }
}

template <class T>
bool List<T>::remove(int n){
    if(n<1 || n>noEl)
        return false;
    else{
        if(n==1){
            listEl *del=head;
            head=head->next;
            if(tail==del)
                tail=NULL;
            delete del;
            noEl--;
        } else {
            listEl *temp=head;
            for(int i=2;i<n;i++)
                temp=temp->next;
            listEl *del=temp->next;
            temp->next=del->next;
            if(tail==del)
                tail=temp;
            delete del;
            noEl--;
        }
        return true;
    }
}

template <class T>
bool List<T>::read(int n,T& retVal)const{
    if(n<1 || n>noEl)
        return false;
    else{
        if(n==1)
            retVal=head->content;
        else if(n==noEl)
            retVal=tail->content;
        else{
            listEl *temp=head;
            for(int i=1;i<n;i++)
                temp=temp->next;
            retVal=temp->content;
        }
        return true;
    }
}

template <class T>
void List<T>::clear(){
    while(!empty())
        remove(1);
}

#endif