#ifndef VECTOR_H
#define VECTOR_H

#include <iostream>
#include <stdexcept>
#include <initializer_list>

class Vector {

 public:
    class ConstIterator;
    class Iterator;

    using value_type = double;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type&;
    using const_reference = const value_type&;
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using iterator = Vector::Iterator;
    using const_iterator = Vector::ConstIterator;

 private:
    size_type sz; //Anzahl an der Elementen in der Vector
    size_type max_sz; // Maxiamale Anzahl an Elemnten
    pointer values; // Zeigt auf den ersten Element in der Vector in  unserem Fall(double)
    static constexpr size_type min_sz {5}; // Mindestens grosse fur sz;

 public:

    class Iterator{
        public:
            using value_type = Vector::value_type;
            using reference = Vector::reference;
            using pointer = Vector::pointer;
            using difference_type = Vector::difference_type;
            using iterator_category = std::forward_iterator_tag;

        private:
            pointer ptr; // Zeigt auf ein Element im Vector (Instanzvariablen)


        public:
            Iterator() : ptr{nullptr} {} // Liefert einen Iterator auf nullptr
            Iterator (pointer ptr) : ptr{ptr} {}

            //Methoden
            reference operator*() const{return *ptr;}
            pointer operator->() const {return this->ptr;}
            friend bool operator==(const iterator& lop, const iterator& rop)
             {
                return lop.ptr == rop.ptr;
             }
            friend bool operator!=(const iterator&lop, const iterator&rop)
             {
                return lop.ptr != rop.ptr;
             }
            iterator& operator++()
            {
                ++ptr;
                return *this;
            }
            iterator operator++(int)
            {
                auto temp = *this;
                ++(*this);
                return temp;
            }
            operator const_iterator() const {return ConstIterator{ptr};}
            friend difference_type operator-(const iterator& lop, const iterator& rop){
                return lop.ptr - rop.ptr;
            }


    };
    class ConstIterator {
        public:
            using value_type = Vector::value_type;
            using reference = Vector::const_reference;
            using pointer = Vector::const_pointer;
            using difference_type = Vector::difference_type;
            using iterator_category = std::forward_iterator_tag;

        private:
            pointer ptr;
        public:
            ConstIterator() : ptr{nullptr} {}
            ConstIterator(pointer ptr) : ptr{ptr}{}

            const_reference operator*() const { return *ptr;}
            const_pointer operator-> () const {  return this->ptr;}
            friend bool operator==(const const_iterator&lop, const const_iterator&rop)
            {
                return lop.ptr == rop.ptr;
            }
            friend bool operator!=(const const_iterator&lop, const const_iterator&rop)
            {
                return lop.ptr != rop.ptr;
            }
            const_iterator& operator++()
            {
                ++ptr;
                return *this;
            }
            const_iterator operator++(int)
            {
                auto temp = *this;
                ++(*this);
                return temp;
            }

            friend difference_type operator-(const const_iterator& lop, const const_iterator& rop){
                return lop.ptr - rop.ptr;
            }
    };

     //Konstruktor ohne Argumenten (leeren Vector)
    Vector() : sz{0}, max_sz{min_sz}, values{ new value_type[max_sz]} {}


  //Konstruktor mit einem Arg. //
    Vector(size_type n) : sz{0}
    {
        if(n < min_sz) n = min_sz;
        max_sz = n;
        values = new value_type[max_sz];
    }
  //Vector mit sprezifizirtem Inhalt
    Vector(std::initializer_list<value_type>liste) :  Vector (liste.size())
    {
        for(const auto &i : liste)
            values[sz++] = i;
    /*
    for(size_t i=0;i<liste.size();i++)
      values[sz++]=liste[i]; */

    }
  //Copy Konstruktor
    Vector (const Vector &source ) : Vector (source.size())
    {

        sz = source.sz;
        for(size_t i{0}; i<sz; i++)
            values[i] = source.values[i];
    }
  //Destruktor
    ~Vector()
    {
        delete [] values;
    }

    iterator begin() { return Iterator(values);}
    iterator end() { return Iterator(values+sz);}

    const_iterator begin() const {return ConstIterator(values);}
    const_iterator end() const {return ConstIterator(values+sz);}

    iterator erase (const_iterator pos) {
      auto diff = pos-begin();
      if(diff<0 || static_cast<size_type>(diff)>sz)
        throw std::runtime_error("Iterator out of bounds");
      size_type current{static_cast<size_type>(diff)};

      for(size_type i{current}; i<sz-1; ++i)
        values[i]=values[i+1];
      --sz;
      return iterator{values+current};
    }

     iterator insert (const_iterator pos, const_reference val) {
      auto diff = pos-begin();
      if(diff<0 || static_cast<size_type>(diff)>sz)
        throw std::runtime_error("Iterator out of bounds");
      size_type current{static_cast<size_type>(diff)};
      if(sz>=max_sz)
        reserve(max_sz*2);
      for(size_type i{sz}; i-- > current;)
        values[i+1]=values[i];
      values[current]=val;
      ++sz;
      return iterator{values+current};
    }


  //Returniert Anzahl der gespeicherten Elementen
    size_type size() const
    {
        return sz;
    }
  //Retuniert true falls der Vector leer ist
    bool empty() const
    {
        return !sz;
    }
  //Loest alle Elemente aus dem Vektor
    void clear()
    {
        sz = 0;
    }
  //Kapazitaet auf n vergroesen falls noetig
    void reserve(size_type n)
    {
        if(n <= max_sz) return;
        if(empty()) return;
        pointer temp = new value_type [n];
        for(size_type i{0}; i<sz; i++)
            temp[i] = values[i];
        delete [] values;
        values = temp;
        max_sz = n;
    }
  //Kapazitaet wird auf Anzahl der Elemente reduziert // fazon ima ih 9 i njemu treba 5 i 5 i napise
    void shrink_to_fit()
    {

        pointer temp = new value_type [sz];
        for(size_type i{0}; i<sz; i++)
            temp[i] = values [i];
        delete [] values;
        max_sz = sz;
        values = temp;
    }
    //Fuegt eine Kopie von x am Ende des Vectors hinzu npr na values[9] = 5 na devetoj poziciji ce stavaviti 5 na kraj naravno
    void push_back(value_type x)
    {
          if(sz >= max_sz) reserve(sz*2);
        values[sz++] = x;
    }
    //Entfert das letze Element im Vector
    void pop_back()
    {
        if(empty()) throw std::runtime_error(" Der Vector ist leer : Error");
        --sz;

    }
    //Kopiezuweisungsoperator(operator=)- Das this Objekt übernimmt die Werte vom Parameter
    Vector operator=(Vector obj)
    {
// 1. ptr freigeben
// 2. neuen Speicher anfordern
// 3. Variablen kopieren
//  Elemente rueberkopieren
             std::swap(sz, obj.sz);
            std::swap(max_sz,obj.max_sz);
            std::swap(values, obj.values);

      return *this;
    }
    //Retourniert das Element an der gegebenen Position (index),out of Bounds auserhalb der Grenzen
    reference operator [](size_type index)
    {
       if(index < 0 || index >= max_sz)
        throw std::runtime_error ("Out of Bounds");
     return values[index];

    }
    //Retourniert das Element an der gegebenen Position (index),out of Bounds auserhalb der Grenzen
    const_reference operator[](size_type index) const // index manje od sajza znaci da postoji
    {
       if(index < 0 || index >= max_sz)
        throw std::runtime_error ("Out of Bounds");
      return values[index];
    }
    // Retourniet aktuelle kapazietaet des Vectors
    size_type capacity() const
    {
      return max_sz;
    }



   friend  std::ostream& operator<<(std::ostream& os, const Vector& vec)
  {
      os << "[";
      for(size_type i{0}; i<vec.sz; i++)
      {
        if(i) os << ", ";
      os << vec.values[i];
      }
      os << "]";
      return os;
  }

};
#endif