#include <iostream>
#include <fstream>
#include<string.h>
#include <cstdlib>
#include <ctime>
#include <tuple>
using namespace std;

/*class Exception: public exception
{
protected:
	//????????? ?? ??????
	char* str;
public:
	Exception(const char* s)
	{
		str = new char[strlen(s) + 1];
		strcpy_s(str, strlen(s) + 1, s);
	}
	Exception(const Exception& e)
	{
		str = new char[strlen(e.str) + 1];
		strcpy_s(str, strlen(e.str) + 1, e.str);
	}
	~Exception()
	{
		delete[] str;
	}

	virtual void print()
	{
		cout << "Exception: " << str<< "; "<<what();
	}
};*/

class Exception : public exception
{
protected:
	char* str;
public:
	Exception(const char* s)
	{
		str = new char[strlen(s) + 1];
		strcpy_s(str, strlen(s) + 1, s);
	}
	Exception(const Exception& e)
	{
		str = new char[strlen(e.str) + 1];
		strcpy_s(str, strlen(e.str) + 1, e.str);
	}
	~Exception()
	{
		delete[] str;
	}

	virtual void print()
	{
		cout << "Exception: " << str << "; " << what();
	}
};
class InvalidOperationException : public Exception {
public:
	InvalidOperationException(const char* s) : Exception(s) {}
	virtual void print()
	{
		cout << "InvalidOperationException: " << str << "; " << what();
	}
};


class WrongSizeException : public Exception
{
protected:
	int Row1, Col1, Row2, Col2;
public:
	WrongSizeException(const char* s, int row1, int col1, int row2, int col2) : Exception(s) { Row1 = row1; Col1 = col1; Row2 = row2; Col2 = col2; }
	virtual void print()
	{
		cout << "WrongSizeException: " << str << "; " << Row1 << ", " << Col1 << ", " << Row2 << ", " << Col2 << "; " << what();
	}
};

class IndexOutOfBoundsException : public Exception
{
protected:
	int Row, Col;
public:
	IndexOutOfBoundsException(const char* s, int row, int col) : Exception(s) { Row = row; Col = col; }
	virtual void print()
	{
		cout << "IndexOutOfBoundsException: " << str << "; " << Row << ", " << Col << "; " << what();
	}
};
class NonPositiveSizeException : public WrongSizeException {
public:
	NonPositiveSizeException(const char* s, int row1, int col1, int row2, int col2) : WrongSizeException(s, row1, col1, row2, col2) {}

	virtual void print()
	{
		cout << "NonPositiveSizeException: " << str << "; " << Row1 << ", " << Col1 << ", " << Row2 << ", " << Col2 << "; " << what();
	}
};

class TooLargeSizeException : public WrongSizeException {
public:
	TooLargeSizeException(const char* s, int row1, int col1, int row2, int col2) : WrongSizeException(s, row1, col1, row2, col2) {}

	virtual void print()
	{
		cout << "TooLargeSizeException: " << str << "; " << Row1 << ", " << Col1 << ", " << Row2 << ", " << Col2 << "; " << what();
	}
};

template<class T>
class BaseMatrix
{
protected:
	T** ptr;
	int height;
	int width;
public:
	BaseMatrix(int Height = 2, int Width = 2)
	{
		if (Height <= 0 || Width <= 0) {
			throw NonPositiveSizeException("Attempt to create a matrix of negative or zero size", Height, Width, -1, -1);
		}
		height = Height;
		width = Width;
		ptr = new T* [height];
		for (int i = 0; i < height; i++)
			ptr[i] = new T[width];
	}

	BaseMatrix(const BaseMatrix& M)
	{
		height = M.height;
		width = M.width;
		ptr = new T* [height];
		for (int i = 0; i < height; i++)
		{
			ptr[i] = new T[width];
			for (int j = 0; j < width; j++)
				ptr[i][j] = M.ptr[i][j];
		}
	}

	BaseMatrix operator=(BaseMatrix& V)
	{
		if (height != V.height && width != V.width)
		{
			if (ptr != NULL)
			{
				for (int i = 0; i < height; i++)
					delete[] ptr[i];
				delete[] ptr;
				ptr = NULL;
			}
			height = V.height;
			width = V.width;
			ptr = new double* [height];
			for (int i = 0; i < height; i++)
				ptr[i] = new double[width];
		}
		for (int i = 0; i < height; i++)
			for (int j = 0; j < width; j++)
				ptr[i][j] = V.ptr[i][j];
		return *this;
	}

	~BaseMatrix()
	{
		if (ptr != NULL)
		{
			for (int i = 0; i < height; i++)
				delete[] ptr[i];
			delete[] ptr;
			ptr = NULL;
		}
	}

	void print()
	{
		for (int i = 0; i < height; i++)
		{
			for (int j = 0; j < width; j++)
				cout << ptr[i][j] << " ";
			cout << "\n";
		}
	}

	double& operator()(int row, int col)
	{
		if (row < 0 || col < 0 || row >= height || col >= width)
			throw IndexOutOfBoundsException("IndexOutOfBoundsException in operator()", row, col);
		return ptr[row][col];
	}
};
template <class T>
class Matrix : public BaseMatrix<T>
{
public:
	using BaseMatrix<T>::ptr;
	using BaseMatrix<T>::height;
	using BaseMatrix<T>::width;
	Matrix(int Height = 2, int Width = 2) : BaseMatrix<T>(Height, Width) { cout << "\nMatrix constructor\n"; }
	~Matrix() { cout << "\nMatrix destructor\n"; }
	Matrix(T** array, int Height, int Width) : BaseMatrix<T>(Height, Width) {
		ptr = new T* [height];
		for (int i = 0; i < height; ++i) {
			ptr[i] = new T[width];
			for (int j = 0; j < width; ++j) {
				ptr[i][j] = array[i][j];
			}
		}
	}
	// Filling a matrix element by the sum of its indices
	void fillRandom(int a) {
		// Initialization of random number generator with current time
		srand(time(nullptr));

		for (int i = 0; i < height; ++i) {
			for (int j = 0; j < width; ++j) {
				// Random number generation
				ptr[i][j] = (rand() * (a + 1))%100;
			}
		}
	}


	pair<double, double> calculateCenterOfMass() {
		double totalMass = 0;
		double centerX = 0;
		double centerY = 0;

		for (int i = 0; i < this->height; ++i) {
			for (int j = 0; j < this->width; ++j) {
				totalMass += this->ptr[i][j];
				centerX += i * this->ptr[i][j]; 
				centerY += j * this->ptr[i][j]; 
			}
		}
		if (totalMass != 0) {
			centerX /= totalMass;
			centerY /= totalMass;
		}
		return make_pair(centerX, centerY);
	}


	double Trace()
	{
		if (height != width) {
			throw InvalidOperationException("The operation of finding the trace is not defined for a non-square matrix");
		}
		double summ = 0;
		for (int i = 0; i < height; i++)
			summ += ptr[i][i];
		return summ;
	}

	Matrix operator+(Matrix M)
	{
		if (height != M.height || width != M.width)
			throw WrongSizeException("Unequal size of matrices to add in operator+()", height, width, M.height, M.width);
		Matrix res(height, width);
		for (int i = 0; i < height; i++)
			for (int j = 0; j < width; j++)
				res(i, j) = ptr[i][j] + M.ptr[i][j];
		return res;
	}
	// Перегрузка оператора присваивания
	Matrix& operator=(const Matrix& other) {
		if (this != &other) {
			this->~Matrix();

			height = other.height;
			width = other.width;

			ptr = new double* [height];
			for (int i = 0; i < height; ++i) {
				ptr[i] = new double[width];
				for (int j = 0; j < width; ++j) {
					ptr[i][j] = other.ptr[i][j];
				}
			}
		}
		return *this;
	}
	template<class T>
	friend ostream& operator<<(ostream& s, Matrix<T> M);
	template<class T>
	friend istream& operator>>(istream& s, Matrix<T>& M);
};
template<class T>
ostream& operator<<(ostream& s, Matrix<T> M)
{
	if (typeid(s) == typeid(ofstream))
	{
		s << M.height << " " << M.width << " ";
		for (int i = 0; i < M.height; i++)
			for (int j = 0; j < M.width; j++)
				s << M.ptr[i][j] << " ";
		return s;
	}
	for (int i = 0; i < M.height; i++)
	{
		for (int j = 0; j < M.width; j++)
			s << M.ptr[i][j] << " ";
		s << "\n";
	}
	return s;
}
template<class T>
istream& operator>>(istream& s, Matrix<T>& M)
{
	if (typeid(s) == typeid(ifstream))
	{
		int w, h; s >> h >> w;
		if (h != M.height || w != M.width)
		{
			throw InvalidOperationException("The dimensions of the read matrix are different from those of the original matrix.");
		}
	}
	for (int i = 0; i < M.height; i++)
		for (int j = 0; j < M.width; j++)
			s >> M.ptr[i][j];
	return s;
}

int main() {
	try {
		Matrix<double> M[10];
		// Matrix filling and output
		for (int i = 0; i < 3; i++) {
			cout << "Matrix " << i + 1 << ":" << endl;
			M[i].fillRandom(i);
			cout << M[i] << endl;
		}

		// Saving a matrix array to a file
		ofstream fout("1.txt");
		if (fout) {
			fout << "3\n";
			for (int i = 0; i < 3; i++)
				fout << M[i] << "\n";
			fout.close();
		}

		// reading a matrix array from a file
		Matrix<double>* M1;
		ifstream fin("1.txt");
		if (fin) {
			int n;
			fin >> n;
			M1 = new Matrix<double>[n];
			for (int i = 0; i < 3; i++) {
				fin >> M1[i];
				cout << "Matrix from file " << i + 1 << ":" << endl;
				cout << M1[i] << endl;
			}
			delete[] M1;
		}
		Matrix<double> A(2, 2);
		A.fillRandom(4);
		A.print();
		Matrix<double> B(2, 2);
		B.fillRandom(3);
		B.print();
		Matrix<double> C = A + B; // matrix1+matrix2
		cout << "A + B:" << endl << C << endl;

		Matrix<double> D;
		D = A; //Assignment of matrix
		cout << "D (assigned from A):" << endl << D << endl;
		double a, b;
		A.print();
		tie(a,b)=A.calculateCenterOfMass(); //calculate Center Of Mass
		cout << "Center of Mass of A:" << endl;
		cout << a << ", " << b << "\n";
		double traceA = A.Trace(); // calculate trace
		cout << "Trace of A: " << traceA << endl;
	}
	catch (IndexOutOfBoundsException& ex) {
		cout << "IndexOutOfBoundsException has been caught: ";
		ex.print();
	}
	catch (Exception& ex) {
		cout << "Exception has been caught: ";
		ex.print();
	}
	catch (exception& ex) {
		cout << "Standard exception has been caught: " << ex.what();
	}

	// char c;
	// cin >> c;
	return 0;
}