#include <iostream>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <vector>
#include <cstdint>

bool flag = false;

std::vector<uint32_t> mult_matrix(const std::vector<uint32_t> &one, const std::vector<uint32_t> &two, uint32_t size) {

    auto result = std::vector<uint32_t>(size * size);
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) { // col
            for (int k = 0; k < size; k++) {
                result[i * size + j] += one[i * size + k] * two[j + size * k];
            }
        }
    }
    return result;
}

std::vector<uint32_t> get_one_matrix(uint32_t size) {
    std::vector<uint32_t> result(size * size, 0);
    for (int i = 0; i < size; i++) {
        result[i * size + i] = 1;
    }
    return result;
}

std::vector<uint32_t> binpow(const std::vector<uint32_t> &a, uint32_t n, uint32_t size) {
    if (n == 0) {
        return get_one_matrix(size);
    }
    if (n % 2 == 1) {
//        if (flag) std::cout << "[1] before mult " << n << std::endl;
        auto res = mult_matrix(binpow(a, n - 1, size), a, size);
//        if (flag) {
//            std::cout << "[1] after mult " << n << std::endl;
//            for (int i = 0; i < 10; i++) {
//                std::cout << res[i] << " ";
//            }
//            std::cout << '\n';
//        }
        return res;
    } else {
//        if (flag) std::cout << "[2] before mult " << n << std::endl;
        auto b = binpow(a, n / 2, size);

//        if (flag) {
//            std::cout << "[2] b: " << n << std::endl;
//            for (int i = 0; i < 10; i++) {
//                std::cout << b[i] << " ";
//            }
//            std::cout << '\n';
//        }

        auto res = mult_matrix(b, b, size);

//        if (flag) {
//            std::cout << "[2] after mult " << n << std::endl;
//            for (int i = 0; i < 10; i++) {
//                std::cout << res[i] << " ";
//            }
//            std::cout << '\n';
//        }

        return res;
    }
}


int main(int argc, char *argv[]) {
    auto memory_name = std::string(argv[1]);
    memory_name = "/" + memory_name;
    int fd = shm_open(memory_name.data(), O_RDWR, S_IRUSR | S_IWUSR);
    auto f = (char *) mmap(nullptr, 64 * 1024 * 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if ((char *) (-1) == f) {
        std::cout << errno << std::endl;
        exit(1);
    }

    auto status = reinterpret_cast<int *>(f);

    auto p = reinterpret_cast<uint32_t *>(f + 4);

    while (*status != -1) {
        while (*status != 0) {
        }
        std::cout << *status << " new portion\n";
//        sleep(5);
        auto n = *p;
        p++;
        auto m = *p;
        p++;
        if (n > 500) {
            flag = true;
        }
        std::cout << *status << " " << n << " " << m << "\n";


        std::vector<uint32_t> matrix(m * m);
        for (int i = 0; i < matrix.size(); i++, p++) {
            matrix[i] = *p;
        }

        std::cout << "from input get:\n";
        for (int i = 0; i < 8; i++) {
            std::cout << matrix[i] << " ";
        }
        std::cout << std::endl;
        *status = 1;

        matrix = binpow(matrix, n, m);

//        for (int i = 0; i < m; i++) {
//            for (int j = 0; j < m; j++) {
//                std::cout << matrix[i * m + j] << " ";
//            }
//            std::cout << '\n';
//        }

        std::cout << "writing....\n";
        for (int i = 0; i < matrix.size(); i++, p++) {
            if (flag && i < 10) std::cout << matrix[i] << " ";
            uint32_t val = matrix[i];
            *p = val;
        }
        std::cout << std::endl;

//        for (int i = 0; i < matrix.size() + 2; i++, old++){
//            std::cout << *old << " ";
//        }
//        std::cout << std::endl;
        *status = 2;
    }


    sleep(100000);
}