#include <vector>
#include <iostream>
#include <memory>
#include <utility>
#include <cstdlib>

template<typename T>
void reverse_v1(std::vector<T> &v)
{
    size_t N = v.size();
    size_t i = 0, f = N-1;
    while (i < f) {
        std::swap(v[i], v[f]);
        ++i; --f;
    }
}

template<typename T>
void mostra(std::vector<T> const &v)
{
    for (auto x: v) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

// Esta e uma especializacao do template mostra para o caso em que o vector
// guarda unique_ptr.
template<typename C>
void mostra(std::vector<std::unique_ptr<C>> const &v)
{
    for (auto &x: v) {
        std::cout << *x << " ";
    }
    std::cout << std::endl;
}

struct NaoFunciona {

};

std::ostream &operator<<(std::ostream &os, NaoFunciona n)
{
    os << ".";
    return os;
}

template<typename T>
class CircularBuffer {
    std::vector<T> _elements;
    size_t _first, _n;
public:
    CircularBuffer(size_t n);
    void push(T v);
    T front() const;
    void pop();
    size_t size() const;
};

template<typename T>
CircularBuffer<T>::CircularBuffer(size_t n)
    : _elements(n), _first(0), _n(0)
{
}

template<typename T>
T CircularBuffer<T>::front() const
{
    if (_n > 0) {
        return _elements[_first];
    }
    else {
        std::cerr << "Tentativa de tirar de onde nao existe\n";
        exit(1);
    }
}

template<typename T>
void CircularBuffer<T>::push(T v)
{
    _elements[(_first + _n) % _elements.size()] = v;
    if (_n < _elements.size()) {
        ++_n;
    }
    else {
        _first = (_first + 1) % _elements.size();
    }
}

template<typename T>
void CircularBuffer<T>::pop()
{
    if (_n > 0) {
        ++_first;
        --_n;
    }
}

template<typename T>
size_t CircularBuffer<T>::size() const
{
    return _n;
}

int main(int , char *[])
{
    std::vector<double> v{1., 2., 3., 4., 5., 6., 7.};
    reverse_v1(v);
    mostra(v);
    std::vector<int> v2{9, 7, 5, 3, 1};
    reverse_v1(v2);
    mostra(v2);
    std::vector<NaoFunciona> v3(10);
    reverse_v1(v3);
    mostra(v3);
    std::vector<std::unique_ptr<int>> v4;
    v4.emplace_back(std::make_unique<int>(2));
    v4.emplace_back(std::make_unique<int>(4));
    v4.emplace_back(std::make_unique<int>(8));
    reverse_v1(v4);
    mostra(v4);

    CircularBuffer<int> cb(5);
    std::cout << "Tamanho atual " << cb.size() << std::endl;
    for (int i = 1; i < 20; i+=2) {
        cb.push(i);
        std::cout << "Tamanho atual " << cb.size() << std::endl;
    }

    std::cout << "Conteudo: ";
    while (cb.size() > 0) {
        std::cout << cb.front() << " ";
        cb.pop();
    }
    std::cout << std::endl;
    return 0;
}