#pragma once

#if _MSC_VER <= 1700
    #pragma warning(disable : 4290)
#endif

#include "stdafx.h"

#include <exception>
#include <string>

#define _DLEXCEPT throw(DoubleListException)
#define _DLTEMP ::SemestralniPrace::DoubleList<T>::
#define _DLTYPE typename _DLTEMP

namespace SemestralniPrace {

template<typename T>
class DoubleList
{
private:
    struct Prvek
    {
        T data;
        Prvek* predchudce;
        Prvek* naslednik;
    };

    class DoubleListException : public exception
    {
    public:
        DoubleListException(const char* msg) : msg(msg) {}
        DoubleListException(const std::string &msg) : msg(msg) {}
        virtual ~DoubleListException(void) {}
        virtual const char* what(void) const throw()
        { return msg.c_str(); }
    private:
        std::string msg;
    };
public:
    typedef void (*UkFunkce)(const T&);

    DoubleList(void);
    ~DoubleList(void);

    inline bool JePrazdny(void) const { return pocetPrvku > 0; }
    inline size_t PocetPrvku() const { return pocetPrvku; }

    void VlozPrvni(const T&);
    void VlozPosledni(const T&);
    void VlozNaslednika(const T&) _DLEXCEPT;
    void VlozPredchudce(const T&) _DLEXCEPT;

    T& ZpristupniAktualni(void) _DLEXCEPT;
    T& ZpristupniPrvni(void) _DLEXCEPT;
    T& ZpristupniPosledni(void) _DLEXCEPT;
    T& ZpristupniNaslednika(void) _DLEXCEPT;
    T& ZpristupniPredchudce(void) _DLEXCEPT;

    T OdeberPrvni(void);
    T OdeberPosledni(void);
    T OdeberAktualni(void);
    T OdeberNaslednika(void);
    T OdeberPredchudce(void);

    void Prohlidka(UkFunkce) const;
    void Zrus(void);

    class iterator
    {
    public:
        iterator(_DLTYPE Prvek* x) : p(x) {}
        iterator(const iterator& it) : p(it.p) {};
        iterator& operator++() { p = p->naslednik; return *this; }
        bool operator==(const iterator& it) { return p == it.p; }
        bool operator!=(const iterator& it) { return p != it.p; }
        T& operator*() { return p->data; }
    private:
        _DLTYPE Prvek* p;
    };
    class const_iterator;
    iterator begin();
    iterator end();
    const_iterator cbegin();
    const_iterator cend();
private:
    _DLTYPE Prvek* VytvorPrvek(const T& data, _DLTYPE Prvek* p, _DLTYPE Prvek* n);
    void SmazPrvek(_DLTYPE Prvek* p);
    void KontrolaAktualniho(void) const _DLEXCEPT;

    size_t pocetPrvku;
    _DLTYPE Prvek* prvni;
    _DLTYPE Prvek* posledni;
    _DLTYPE Prvek* aktualni;
};

template<typename T>
_DLTEMP DoubleList(void)
    : pocetPrvku(0), prvni(NULL), posledni(NULL), aktualni(NULL)
{}

template<typename T>
_DLTEMP ~DoubleList(void)
{
    Zrus();
}

/************************************************************************/
/* Vkladaci metody                                                      */
/************************************************************************/
template<typename T>
void _DLTEMP VlozPrvni(const T& data)
{
    prvni = VytvorPrvek(data, NULL, prvni);
    if (pocetPrvku == 1)
        posledni = prvni;
}

template<typename T>
void _DLTEMP VlozPosledni(const T& data)
{
    if (pocetPrvku == 0)
        VlozPrvni(data);
    else
        VytvorPrvek(data, posledni, NULL);
}

template<typename T>
void _DLTEMP VlozNaslednika(const T& data) _DLEXCEPT
{
    KontrolaAktualniho();

    VytvorPrvek(data, aktualni, aktualni->naslednik);
}

template<typename T>
void _DLTEMP VlozPredchudce(const T& data) _DLEXCEPT
{
    KontrolaAktualniho();

    VytvorPrvek(data, aktualni->predchudce, aktualni);
}

/************************************************************************/
/* Zpristupnovaci metody                                                */
/************************************************************************/
template<typename T>
T& _DLTEMP ZpristupniAktualni(void) _DLEXCEPT
{
    KontrolaAktualniho();

    return aktualni->data;
}

template<typename T>
T& _DLTEMP ZpristupniPrvni(void) _DLEXCEPT
{

}

/************************************************************************/
/* Private methods                                                      */
/************************************************************************/
template<typename T>
_DLTYPE Prvek* _DLTEMP VytvorPrvek(const T& data, _DLTYPE Prvek* p, _DLTYPE Prvek* n)
{
    SemestralniPrace::DoubleList<T>::Prvek* np = new SemestralniPrace::DoubleList<T>::Prvek();
    np->data = data;
    np->predchudce = p;
    np->naslednik = n;

    if (p) p->naslednik = np;
    if (n) n->predchudce = np;
    ++pocetPrvku;

    return np;
}

template<typename T>
void _DLTEMP SmazPrvek(_DLTYPE Prvek* p)
{
    DoubleList<T>::Prvek* predchudce = p->predchudce;
    DoubleList<T>::Prvek* naslednik = p->naslednik;

    if (predchudce) predchudce->naslednik = naslednik;
    if (naslednik) naslednik->predchudce = predchudce;

    delete p;
    --pocetPrvku;
}

template<typename T>
void _DLTEMP KontrolaAktualniho(void) const _DLEXCEPT
{
    if (!aktualni)
        throw DoubleListException("Neni nastaven aktualni prvek.");
}

}