#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#include <sstream>

using namespace std;

template <typename Type>
class Matrix {
private:
    size_t rows, columns;
public:
    vector<vector<Type>> values;
    Matrix();
    Matrix(size_t, size_t);
    Matrix(ifstream&);
    Matrix(Matrix<Type>&);
    ~Matrix();
    static Matrix<int> null_matrix(size_t);
    static Matrix<int> identity_matrix(size_t);
    void load_matrix(ifstream&);
    ofstream& save_matrix(ofstream&);
    double find_determinant();
    void print_matrix();

    friend Matrix<Type> operator * (Matrix<Type> m1, Matrix<Type> m2) {
        if (m1.columns != m2.rows) {
            cerr << "ERROR: invalid arguments";
            exit(-1);
        }
        Matrix<Type> prod(m1.rows, m2.columns);
        for (size_t i = 0; i < prod.rows; ++i) {
            for (size_t j = 0; j < prod.columns; ++j) {
                for (size_t k = 0; k < m1.columns; ++k) {
                    prod.values[i][j] += m1.values[i][k] * m2.values[k][j];
                }
            }
        }
        return prod;
    };

    friend Matrix<Type> operator * (Matrix<Type> m, double p) {
        Matrix<Type> prod(m.rows, m.columns);
        for (size_t i = 0; i < prod.rows; ++i) {
            for (size_t j = 0; j < prod.columns; ++j) {
                prod.values[i][j] = m.values[i][j] * p;
            }
        }
        return prod;
    };
    friend Matrix<Type> operator * (double p, Matrix<Type> m) {
        return m * p;
    };
    friend Matrix<Type> operator + (Matrix<Type> m1, Matrix<Type> m2) {
        if ((m1.columns != m2.columns) || (m1.rows != m2.rows)) {
            cerr << "ERROR: invalid arguments";
            exit(-1);
        }
        Matrix<Type> sum(m1.rows, m1.columns);
        for (size_t i = 0; i < sum.rows; ++i) {
            for (size_t j = 0; j < sum.columns; ++j) {
                sum.values[i][j] = m1.values[i][j] + m2.values[i][j];
            }
        }
        return sum;
    };

    friend Matrix<Type> operator - (Matrix<Type> m1, Matrix<Type> m2) {
        if ((m1.columns != m2.columns) || (m1.rows != m2.rows)) {
            cerr << "ERROR: invalid arguments";
            exit(-1);
        }
        Matrix<Type> sum(m1.rows, m1.columns);
        for (size_t i = 0; i < sum.rows; ++i) {
            for (size_t j = 0; j < sum.columns; ++j) {
                sum.values[i][j] = m1.values[i][j] - m2.values[i][j];
            }
        }
        return sum;
    };

    friend bool operator == (Matrix<Type> m1, Matrix<Type> m2) {
        if ((m1.columns != m2.columns) || (m1.rows != m2.rows)) {
            return false;
        }
        for (size_t i = 0; i < m1.rows; ++i) {
            for (size_t j = 0; j < m1.columns; ++j) {
                if (m1.values[i][j] != m2.values[i][j]) {
                    return false;
                }
            }
        }
        return true;
    };

    friend bool operator == (Matrix<Type> m, int p) {
        if ((p != 0) && (p != 1)) {
            cerr << "ERROR: invalid arguments";
            exit(-1);
        }
        if (p == 0) {
            for (size_t i = 0; i < m.rows; ++i) {
                for (size_t j = 0; j < m.columns; ++j) {
                    if (m.values[i][j] != 0) {
                        return false;
                    }
                }
            }
        }
        else {
            for (size_t i = 0; i < m.rows; ++i) {
                for (size_t j = 0; j < m.columns; ++j) {
                    if (i == j) {
                        if (m.values[i][j] != 1) {
                            return false;
                        }
                    }
                    else if (m.values[i][j] != 0) {
                        return false;
                    }
                }
            }
        }
        return true;
    };
    friend bool operator == (int p, Matrix<Type> m) {
        return m == p;
    };

    Matrix<Type>& operator = (Matrix<Type>& m) {
        this->rows = m.rows;
        this->columns = m.columns;
        cout << m.values.size() << endl;
        this->values = m.values;
        return *this;
    };

    friend void operator >> (ifstream& in, Matrix<Type>& m) {
        string s;
        int k, i = 0;
        m.values.clear();
        vector<Type> v;
        while (getline(in, s)) {
            m.values.push_back(v);
            stringstream ss;
            ss << s << endl;
            while (ss >> k) {
                m.values[i].push_back(k);
            }
            i++;
        }
        m.rows = i;
        m.columns = m.values[0].size();
    }

    friend ofstream& operator << (ofstream& out, Matrix<Type>& m) {
        for (size_t i = 0; i < m.rows; ++i) {
            for (size_t j = 0; j < m.columns; ++j) {
                out << m.values[i][j] << " ";
            }
            out << endl;
        }
        return out;
    }

    friend Matrix<double> operator ! (Matrix<Type> m) {
        double det = m.find_determinant();
        if (det == 0) {
            std::cerr << "ERROR: determinant = 0";
            exit(-1);
        }
        size_t order = m.rows;
        Matrix<double> minors_matrix(order, order);
        for (size_t i = 0; i < order; ++i) {
            for (size_t j = 0; j < order; ++j) {
                Matrix<Type> minor(order - 1, order - 1);
                for (size_t k = 0; k < order; ++k) {
                    for (size_t l = 0; l < order; ++l) {
                        if ((l != j) && (k != i)) {
                            minor.values[k - 1 * (k > i)][l - 1 * (l > j)] = m.values[k][l];
                        }
                    }
                }
                minors_matrix.values[i][j] = minor.find_determinant();
            }
        }
        for (size_t i = 0; i < order; ++i) {
            for (size_t j = 0; j < order; ++j) {
                minors_matrix.values[i][j] *= pow(-1, i + j);
            }
        }
        Matrix<double> tr_minors_matrix(order, order);
        for (size_t i = 0; i < order; ++i) {
            for (size_t j = 0; j < order; ++j) {
                tr_minors_matrix.values[i][j] = minors_matrix.values[j][i] * (1 / det);
            }
        }
        return tr_minors_matrix;
    }
};

template <typename Type>
Matrix<Type>::Matrix() : rows(0), columns(0) {};

template <typename Type>
Matrix<Type>::Matrix(size_t rows, size_t columns) : rows(rows), columns(columns) {
    Type* a = new Type();
    for (size_t i = 0; i < this->rows; ++i) {
        vector<Type> v;
        this->values.push_back(v);
        for (size_t j = 0; j < this->columns; ++j) {
            this->values[i].push_back(*a);
        }
    }
};

template <typename Type>
Matrix<Type>::Matrix(ifstream& in) {
    if (!(in >> this->rows >> this->columns)) {
        cerr << "ERROR: invalid value";
        exit(-1);
    }
    Type data;
    for (size_t i = 0; i < this->rows; ++i) {
        vector<Type> v;
        this->values.push_back(v);
        for (size_t j = 0; j < this->columns; ++j) {
            if (!(in >> data)) {
                cerr << "ERROR: invalid value";
                exit(-1);
            }
            this->values[i].push_back(data);
        }
    }
}

template<typename Type>
Matrix<Type>::Matrix(Matrix<Type>& m) : rows(m.rows), columns(m.columns), values(m.values) {};

template <typename Type>
Matrix<Type>::~Matrix() {};

template <typename Type>
Matrix<int> Matrix<Type>::null_matrix(size_t n) {
    Matrix<int> m(n, n);
    return m;
}

template <typename Type>
Matrix<int> Matrix<Type>::identity_matrix(size_t n) {
    Matrix<int> m(n, n);
    for (size_t i = 0; i < n; ++i) {
        for (size_t j = 0; j < n; ++j) {
            m.values[i][j] += i == j;
        }
    }
    return m;
}

template <typename Type>
void Matrix<Type>::load_matrix(ifstream& in) {
    if (!(in >> this->rows >> this->columns)) {
        cerr << "ERROR: invalid value";
        exit(-1);
    }
    this->values.clear();
    vector<Type> v;
    Type elem;
    for (size_t i = 0; i < this->rows; ++i) {
        this->values.push_back(v);
        for (size_t j = 0; j < this->columns; ++j) {
            if (!(in >> elem)) {
                cerr << "ERROR: invalid value";
                exit(-1);
            }
            this->values[i].push_back(elem);
        }
    }
}

template <typename Type>
ofstream& Matrix<Type>::save_matrix(ofstream& out) {
    out << this->rows << " " << this->columns << endl;
    for (size_t i = 0; i < this->rows; ++i) {
        for (size_t j = 0; j < this->columns; ++j) {
            out << this->values[i][j] << " ";
        }
        out << endl;
    }
    return out;
}

template <typename Type>
double Matrix<Type>::find_determinant() {
    if (rows != columns) {
        cerr << "ERROR: not square matrix";
        exit(-1);
    }
    size_t order = rows;
    double det = 0;
    if (order == 2) {
        det = values[0][0] * values[1][1] - values[0][1] * values[1][0];
    }
    else {
        for (size_t j = 0; j < order; ++j) {
            Matrix<Type> minor(order - 1, order - 1);
            for (size_t k = 1; k < order; ++k) {
                for (size_t l = 0; l < order; ++l) {
                    if (l != j) {
                        minor.values[k - 1][l - 1 * (l > j)] = values[k][l];
                    }
                }
            }
            det += pow(-1, j % 2) * values[0][j] * minor.find_determinant();
        }
    }
    return det;
}

template <typename Type>
void Matrix<Type>::print_matrix() {
    for (size_t i = 0; i < this->rows; ++i) {
        for (size_t j = 0; j < this->columns; ++j) {
            cout << this->values[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

int main() {
    ifstream in("D:/Documents/txt/input_matrix.txt");
    ofstream out("D:/Documents/txt/output_matrix.txt");
    if (!in || !out) {
        cerr << "ERROR: error opening file";
        return -1;
    }
    else {
        cout << "files opened" << std::endl;
    }
    Matrix<int> a(in);
    Matrix<double> b;
    b = !a;
    b.print_matrix();
}