#include "test_runner.h"

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

template <typename It>
class IteratorRange {
public:
  IteratorRange(It begin, It end, int page_size)
    : begin_(begin)
    , end_(end)
    , page_size_(page_size) {
    page_start_ = begin;
    size_t offset = min<size_t>(end_ - begin_, page_size_);
    page_end_ = begin + offset;
  }

  It begin() {
    return page_start_;
  }

  It end() {
    return page_end_;
  }

  void operator++() {
    size_t offset = min<size_t>(page_end_ - page_start_, page_size_);
    page_start_ = page_end_;
    page_end_ = page_end_ + offset;
  }

  bool operator!=(const IteratorRange other) {
    return page_start_ != other.page_start_ || page_end_ != other.page_end_;
  }

private:
  It page_start_;
  It page_end_;
  const It begin_;
  const It end_;
  int page_size_;
};

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

  IteratorRange<It> begin() {
    return IteratorRange<It>(begin_, end_, page_size_);
  }

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

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

private:
  It begin_;
  It end_;
  size_t page_size_;
};

template <typename Container>
using Iterator =  decltype(std::declval<Container>().begin());

template <typename C>
Paginator<Iterator<C>> Paginate(C& c, size_t page_size) {
    return Paginator<Iterator<C>>(begin(c), end(c), page_size);
}

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';
  }

}

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