#include <iostream>
#include <cstdint>
#include <vector>
#include <algorithm>

using namespace std;
using int32 = int32_t;

template <typename T>
class Matrix {
private:
    vector<T> data_;
    size_t row_, column_;

public:
    Matrix(const vector<vector<T>>& matrix) {
        row_ = matrix.size();
        column_ = matrix[0].size();
        data_.reserve(row_ * column_);
        for (size_t i = 0; i != row_; ++i) {
            for (size_t j = 0; j != column_; ++j) {
                data_.push_back(matrix[i][j]);
            }
        }
    }

    pair<size_t, size_t> size() const {
        return {row_, column_};
    }

    const T& operator[](const size_t& number_element) const {
        return data_[number_element];
    }

    Matrix& operator+=(const Matrix<T>& second) {
        for (size_t i = 0; i < row_ * column_; ++i) {
            data_[i] += second[i];
        }
        return *this;
    }

    Matrix operator+(const Matrix<T>& second) const {
        Matrix<T> buffer = *this;
        return buffer += second;
    }

    template <typename V>
    Matrix& operator*=(const V& second) {
        for (size_t i = 0; i < row_ * column_; ++i) {
            data_[i] *= second;
        }
        return *this;
    }

    template <typename V>
    Matrix operator*(const V& second) const {
        Matrix<T> buffer = *this;
        return buffer *= second;
    }

    Matrix& transpose() {
        vector<vector<int32>> buffer;
        buffer.resize(column_);
        for (size_t row = 0; row < column_; ++row) {
            buffer[row].reserve(row_);
        }

        int32 count_row = 0;
        for (size_t i = 0; i < row_ * column_; ++i) {
            if (!(count_row % column_)) {
                count_row += 1;
            }
            buffer[i % column_].push_back(data_[i]);
        }

        cout << "This is buffer:\n";
        for (auto i : buffer) {
            for (auto j : i) {
                cout << j << ' ';
            }
            cout << '\n';
        }
        cout << '\n';
        cout << "This is *this before transpose():\n" << *this << "\n\n";

        swap(row_, column_);
        int32 paste_in = 0;
        data_.resize(row_);
        for (size_t i = 0; i < row_; ++i) {
            data_.reserve(column_);
            for (size_t j = 0; j < column_; ++j) {
                data_[paste_in] = buffer[i][j];
                ++paste_in;
            }
        }

        cout << "This is *this after transpose():\n" << *this << "\n\n";



        return *this;
    }

    const Matrix transposed() const {
        Matrix<T> new_matrix = *this;
        new_matrix.transpose();
        return new_matrix;
    }
};

template <typename T>
ostream& operator<<(ostream& out, const Matrix<T>& m) {
    auto row = m.size().first;
    auto column = m.size().second;
    out << m[0];
    for (size_t i = 1; i < column; ++i) {
        out << "\t" << m[i];
    }
    for (size_t i = column; i < row * column; ++i) {
        if (!(i % column)) {
            out <<  "\n" << m[i];
        } else {
            out << "\t" << m[i];
        }
    }
    return out;
}



int main() {
    vector<vector<int32>> v = {{0, 1, 2, 3},
                               {4, 5, 6, 7},
                               {8, 9, 10, 11}};
    vector<vector<int32>> w = {{1}};
    vector<vector<int32>> u = {{1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12}, {-1, -2, -3, -4, -5, -6}};
    Matrix<int32> mat1(w);
    Matrix<int32> mat2(w);
    w = {{0, -1},
         {-6, 2},
         {1, 7}};
    mat1.transpose();
    //cout << mat1.transpose() << "\n\n";
    //Matrix<int32> mat3 = mat1.transposed();
    //cout << mat1.transposed() << "\n\n" << mat3 << "\n\n" << mat1.transpose() << "\n\n" << mat1 << "\n\n";
    return 0;
}