#include "Matrix.h"

#include <algorithm>
#include <cassert>
#include <cmath>
#include <fstream>
#include <iostream>

Matrix::Matrix(const std::string& fileNameInput) {
	Load(fileNameInput);
}

Matrix::Matrix(std::size_t lignes, std::size_t colonnes) : m_Lignes(lignes), m_Colonnes(colonnes) {
	m_Data.resize(m_Lignes * m_Colonnes);
}

Matrix::Matrix(std::size_t lignes, std::size_t colonnes, std::initializer_list<long double>&& initList) :
	m_Lignes(lignes), m_Colonnes(colonnes) {
	m_Data = initList;
	m_Data.resize(m_Lignes * m_Colonnes);
}

Matrix::~Matrix() {}

Matrix Matrix::operator*(const Matrix& other) const {
	if (m_Colonnes != other.m_Lignes) {
		std::cerr << "Mutiplication impossible car la dimensions des matrices est incompatible" << std::endl;
		return {1, 1, {0}};
	}

	Matrix result(m_Lignes, other.m_Colonnes);

	for (std::size_t i = 0; i < m_Lignes; ++i) {
		for (std::size_t j = 0; j < other.m_Colonnes; ++j) {
			long double sum = 0;
			for (std::size_t k = 0; k < m_Colonnes; k++) {
				sum += at(i, k) * other.at(k, j);
			}
			result.at(i, j) = sum;
		}
	}
	return result;
}

void Matrix::Print() const {
	for (size_t i = 0; i < m_Lignes; ++i) {
		std::cout << "[ ";
		for (size_t j = 0; j < m_Colonnes; ++j) {
			std::size_t indice = i * m_Lignes + j;
			std::cout << at(i, j) << " ";
		}
		std::cout << "]";
		std::cout << std::endl;
	}
}

void Matrix::Insert() {
	for (size_t i = 0; i < m_Lignes; ++i) {
		for (size_t j = 0; j < m_Colonnes; ++j) {
			std::cin >> at(i, j);
		}
		std::cout << std::endl;
	}
}

void Matrix::Save(const std::string& fileName) {
	std::ofstream out {fileName};
	if (!out) {
		std::cerr << "Impossible de sauvegarder la matrice !\n";
		return;
	}
	out << *this;
}

void Matrix::Load(const std::string& filename) {
	std::ifstream in {filename};
	if (!in) {
		std::cerr << "Impossible de charger la matrice !\n";
		return;
	}
	in >> *this;
}

void Matrix::Transpose() {
	Matrix result {m_Colonnes, m_Lignes};
	for (std::size_t i = 0; i < m_Lignes; i++) {
		for (std::size_t j = 0; j < m_Colonnes; j++) {
			result.at(j, i) = at(i, j);
		}
	}
	*this = result;
}

Matrix Matrix::Identity(std::size_t taille) {
	Matrix id {taille, taille};
	for (std::size_t i = 0; i < taille; i++) {
		for (std::size_t j = i; j < taille; j++) {
			id.at(i, j) = (i == j);
		}
	}
	return id;
}

void Matrix::Augmenter(const Matrix& droite) {
	assert(droite.m_Lignes == m_Lignes);
	Matrix temp {m_Lignes, m_Colonnes + droite.m_Colonnes};

	for (std::size_t i = 0; i < m_Lignes; i++) {
		for (std::size_t j = 0; j < m_Colonnes; j++) {
			temp.at(i, j) = at(i, j);
		}
	}

	for (std::size_t i = 0; i < m_Lignes; i++) {
		for (std::size_t j = 0; j < droite.m_Colonnes; j++) {
			temp.at(i, j + m_Colonnes) = droite.at(i, j);
		}
	}

	*this = temp;
}

bool Matrix::operator==(const Matrix& other) const {
	if (m_Lignes != other.m_Lignes || m_Colonnes != other.m_Colonnes)
		return false;

	for (std::size_t i = 0; i < m_Lignes; i++) {
		for (std::size_t j = 0; j < m_Colonnes; j++) {
			if (!IsEqualZero(at(i, j) - other.at(i, j)))
				return false;
		}
	}

	return true;
}

long double& Matrix::operator[](std::size_t indice) {
	return m_Data[indice];
}

long double& Matrix::at(std::size_t ligne, std::size_t colonne) {
	return m_Data[ligne * m_Colonnes + colonne];
}

long double Matrix::at(std::size_t ligne, std::size_t colonne) const {
	return m_Data[ligne * m_Colonnes + colonne];
}

std::size_t Matrix::GetRawCount() const {
	return m_Lignes;
}

std::size_t Matrix::GetColumnCount() const {
	return m_Colonnes;
}

Matrix Matrix::SubMatrix(std::size_t origine_ligne, std::size_t origine_colonne, std::size_t ligne, std::size_t colonne) const {
	assert(m_Lignes >= ligne && m_Colonnes >= colonne);
	Matrix result {ligne, colonne};

	for (std::size_t i = 0; i < ligne; i++) {
		for (std::size_t j = 0; j < colonne; j++) {
			result.at(i, j) = at(i + origine_ligne, j + origine_colonne);
		}
	}

	return result;
}

std::ostream& operator<<(std::ostream& stream, const Matrix& mat) {
	stream << mat.m_Lignes << " " << mat.m_Colonnes << "\n";
	for (std::size_t i = 0; i < mat.m_Lignes; i++) {
		for (std::size_t j = 0; j < mat.m_Colonnes; j++) {
			stream << mat.at(i, j) << " ";
		}
		stream << "\n";
	}
	return stream;
}

std::istream& operator>>(std::istream& stream, Matrix& mat) {
	stream >> mat.m_Lignes >> mat.m_Colonnes;
	mat.m_Data.resize(mat.m_Lignes * mat.m_Colonnes);
	for (std::size_t i = 0; i < mat.m_Lignes; i++) {
		for (std::size_t j = 0; j < mat.m_Colonnes; j++) {
			stream >> mat.at(i, j);
		}
	}
	return stream;
}