#ifndef __UTILS_RANGE_H
#define __UTILS_RANGE_H

template<class T>
class Range{
    T start=0, step=1, stop;
public:
    constexpr Range(const T start, const T stop, const T step): start(start), step(step), stop(stop){};

    class iterator{
        T pos;
        T step; // fuer ++. feste werte werden wegoptimiert.
        friend class Range<T>;
        constexpr iterator(T pos, T step): pos(pos), step(step){};
    public:
        iterator &operator ++(){
            pos += step;
            return *this;
        }
        T operator *(){ return pos; }
        bool operator !=(const iterator &that){
            if(step >= 0) {
                return pos < that.pos;
            }
            else { // muss < 0 sein, es wurde dadurch geteilt.
                return pos > that.pos;
            }
        }
    };

    iterator begin() const{
        return iterator(start,step);
    }

    iterator end() const{
        return iterator(stop,step);
    }
    class reverse_iterator{
        T pos, step;
        friend class Range<T>;
        constexpr reverse_iterator(T pos, T step): pos(pos), step(step){};
    public:
        reverse_iterator &operator ++(){
            pos -= step;
            return *this;
        }
        T operator *(){ return pos-step; }
        bool operator !=(const reverse_iterator &that) const{
            if(step >= 0){
                return pos < that.pos;
            }
            else{
                return pos > that.pos;
            }
        }
    };
    reverse_iterator rbegin() const{
        T realstop = start + (stop-start) / step * step; // round down to next step
        if(realstop < stop && step > 0) realstop += step;
        else if (realstop > stop && step < 0) realstop -= step;

        return reverse_iterator(realstop, step);
    }

    reverse_iterator rend() const{
        return reverse_iterator(start, step);
    }
};

template<class T> Range<T> range(T stop) {return Range<T>(0, stop, 1); }
template<class T> Range<T> range(T start, T stop) {return Range<T>(start, stop, 1); }
template<class T> Range<T> range(T start, T stop, T step) {return Range<T>(start, stop, step); }

#endif //__UTILS_RANGE_H