#include "test_runner.h"

#include <numeric>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

template <typename Iterator>
struct IteratorRange {
  Iterator first_;
  Iterator last_;

  Iterator begin() {
    return first_;
  }

  Iterator end() {
    return last_;
  }
};

template <typename Iterator>
class Paginator {
public:
  Paginator(Iterator begin, Iterator end, size_t page_size)
    : begin_(begin)
    , end_(end)
    , page_size_(page_size) {}

  IteratorRange<Iterator> begin() {
    size_t offset = min<size_t>(end_ - begin_, page_size_);
    return {begin_, begin_ + offset};
  }

  IteratorRange<Iterator> end() {
    return {end_, end_};
  }

  void operator++() {
    page_size_++;
  }

  size_t size() const {
    size_t size = (end_ - begin_) / page_size_;
    if ((end_ - begin_) % page_size_ != 0) {
      size++;
    }
    return size;
  }

private:
  Iterator begin_;
  Iterator end_;
  size_t page_size_;
  size_t curr_;
};

template <typename C>
Paginator<typename C::iterator> Paginate(C& c, size_t page_size) {
  auto p = Paginator<typename C::iterator>(c.begin(), c.end(), page_size);
  return p;
}

void TestPageCounts() {
  vector<int> v(15);

  ASSERT_EQUAL(Paginate(v, 1).size(), v.size());
  ASSERT_EQUAL(Paginate(v, 3).size(), 5u);
  ASSERT_EQUAL(Paginate(v, 5).size(), 3u);
  ASSERT_EQUAL(Paginate(v, 4).size(), 4u);
  ASSERT_EQUAL(Paginate(v, 15).size(), 1u);
  ASSERT_EQUAL(Paginate(v, 150).size(), 1u);
  ASSERT_EQUAL(Paginate(v, 14).size(), 2u);
}

void TestLooping() {
  vector<int> v(15);
  iota(begin(v), end(v), 1);

  Paginator<vector<int>::iterator> paginate_v(v.begin(), v.end(), 6);
  ostringstream os;
  for (const auto& page : paginate_v) {
    for (int x : page) {
      os << x << ' ';
    }
    os << '\n';
  }

  ASSERT_EQUAL(os.str(), "1 2 3 4 5 6 \n7 8 9 10 11 12 \n13 14 15 \n");
}

int main() {
  TestRunner tr;
  RUN_TEST(tr, TestPageCounts);
  RUN_TEST(tr, TestLooping);
}