#pragma once

#include <sstream>
#include <cstddef>
#include <iostream>

template <size_t R, size_t C, typename T = float>
struct Matrix {
public:
    Matrix<R, C, T>() : elements{} {};

    Matrix<R, C, T>(T scalar) {
        std::fill(elements, elements + R * C, scalar);
    };

    template<typename ...Args>
    Matrix<R, C, T>(Args... args): elements{ args... } {};

    Matrix<R, C, T>(T values[R * C]) {
        std::copy(values, values + R * C, elements);
    };

    static Matrix<R, R, T> identity() {
        Matrix<R, R, T> result{};
        for (int i = 0; i < R; i++) {
            result(i, i) = 1;
        }
        return result;
    }

    Vector<C, T> row(size_t index) {
        return { &elements[index * C] };
    }

    Vector<R, T> col(size_t index) {
        Vector<R, T> result{};
        for (int i = 0; i < R; i++) {
            result[i] = this->operator()(index, i);
        }
        return result;
    }

    Matrix<R, C, T> operator+(Matrix<R, C, T> other) {
        Matrix<R, C, T> result{};
        for (int i = 0; i < R * C; i++) {
            result.elements[i] = elements[i] + other.elements[i];
        }
        return result;
    }

    Matrix<R, C, T> operator*(float scalar) {
        Matrix<R, C, T> result{};
        for (int i = 0; i < R * C; i++) {
            result.elements[i] = elements[i] * scalar;
        }
        return result;
    }

    template<size_t N>
    Matrix<R, N, T> operator*(Matrix<C, N, T> other) {
        Matrix<R, N, T> result{};
        for (int y = 0; y < R; y++) {
            for (int x = 0; x < N; x++) {
                auto r = row(y);
                auto c = other.col(x);

                auto dot = r * c;

                result(x, y) = dot;
            }
        }
        return result;
    }

    Vector<R, T> operator*(Vector<R, T> vector) {
        Matrix<R, 1, T> matrix(vector.elements);
        matrix = this->operator*(matrix);
        return { matrix.elements };
    }

    auto& operator()(size_t x, size_t y) {
        return elements[y * C + x];
    }

    std::string string() {
        std::stringstream str{};
        for (int x = 0; x < R; x++) {
            for (int y = 0; y < C; y++) {
                str << this->operator()(x, y) << " ";
            }

            str << "\n";
        }

        return str.str();
    }

    T elements[R * C];
};