#include "test_runner.h"

#include <utility>
#include <vector>
#include <iostream>
#include <future>
#include <cstdint>

using namespace std;

template <typename Iterator>
class IteratorRange {
public:

    IteratorRange(Iterator begin, Iterator end) : Begin(begin), End(end), Size(distance(begin, end)) {}

    Iterator begin() const {
        return Begin;
    }

    Iterator end() const {
        return End;
    }

    size_t size() const {
        return distance(begin(), end());
    }

private:
    Iterator Begin;
    Iterator End;
    size_t Size;
};

template <typename Iterator>
class Paginator {
public:
    Paginator(Iterator begin, Iterator end, size_t page_size) {
        for (size_t left = distance(begin, end); left > 0; ) {
            size_t current_page_size = min(left, page_size);
            Iterator current_end = next(begin, current_page_size);
            pages.push_back({begin, current_end});

            left -= current_page_size;
            begin = current_end;
        }
    }

    auto begin() const {
        return pages.begin();
    }

    auto end() const {
        return pages.end();
    }

    size_t size() const {
        return pages.size();
    }

private:
    vector<IteratorRange<Iterator>> pages;
};

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


int64_t SumSingleThread(const vector<vector<int>>& matrix) {
    int64_t sum = 0;
    for (const auto& row : matrix) {
        for (auto item : row) {
            sum += item;
        }
    }
    return sum;
}


int64_t CalculateMatrixSum(const vector<vector<int>>& matrix) {
    vector<future<int64_t>> futures;
    for (auto page : Paginate(matrix, 2000)) {
        futures.push_back(async([=] { return SumSingleThread(page); }));
    }
    int64_t result = 0;
    for (auto& f : futures) {
        result += f.get();
    }
    return result;
}


void TestCalculateMatrixSum() {
  const vector<vector<int>> matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12},
    {13, 14, 15, 16}
  };
  ASSERT_EQUAL(CalculateMatrixSum(matrix), 136);
}

int main() {
  TestRunner tr;
  RUN_TEST(tr, TestCalculateMatrixSum);
}