#pragma once

/**
 * \file Matrix.h
 * \brief Contient la définition d'une matrice
 */

#include <cmath>
#include <cstddef>
#include <string>
#include <vector>

/**
 * \class Matrix
 * \brief Représente une matrice d'éléments
 */
class Matrix {
  public:
	typedef long double Element;

  private:
	std::size_t m_Raws;
	std::size_t m_Columns;
	std::vector<Element> m_Data;

  public:
	/**
	 * \brief Constructeur par défaut. Crée une matrice de taille nulle
	 */
	Matrix() : m_Raws(0), m_Columns(0) {}

	/**
	 * \brief Construit une matrice de taille donnée
	 * \param raws Le nombre de lignes
	 * \param columns Le nombre de colonne
	 */
	Matrix(std::size_t raws, std::size_t columns);

	/**
	 * \brief Construit une matrice de taille donnée avec des éléments donnés.\n
	 * Exemple :
	 * \code Matrix(2, 2, {1, 2, 3, 4}) \endcode construit la matrice \n
	 * [1, 2]\n
	 * [3, 4]
	 * \param raws Le nombre de lignes
	 * \param columns Le nombre de colonne
	 * \param initList Les élements à mettre
	 */
	Matrix(std::size_t raws, std::size_t columns, std::initializer_list<Element>&& initList);

	~Matrix() {}

	/**
	 * \brief Retourne le nombre de ligne de la matrice
	 */
	std::size_t GetRawCount() const;

	/**
	 * \brief Retourne le nombre de colonne de la matrice
	 */
	std::size_t GetColumnCount() const;

	/**
	 * \brief Transpose la matrice
	 */
	void Transpose();

	/**
	 * \brief Augmente la matrice actuelle avec une autre
	 * \param right Une matrice avec le bon nombre de lignes
	 * \pre GetRawCount() = right.GetRawCount()
	 */
	void Augment(const Matrix& right);

	/**
	 * \brief Retourne la sous-matrice spécifiée
	 * \param raw_origin L'indice de la première ligne de la matrice à récupérer
	 * \param column_origin L'indice de la première colonne de la matrice à récupérer
	 * \param raw Le nombre de lignes de la sous-matrice
	 * \param column Le nombre de colonnes de la sous-matrice
	 * \pre raw_origin + raw <= GetRawCount()
	 * \pre column_origin + column <= GetColumnCount()
	 */
	Matrix SubMatrix(std::size_t raw_origin, std::size_t column_origin, std::size_t raw, std::size_t column) const;

	Matrix operator+(const Matrix& other) const;
	Matrix operator-(const Matrix& other) const;

	bool operator==(const Matrix& other) const;

	/**
	 * \brief Effectue un produit matriciel
	 */
	Matrix operator*(const Matrix& other) const;

	/**
	 * \brief Retourne l'élément à l'indice recherché
	 * \param raw L'indice de la ligne
	 * \param column L'indice de la colonne
	 */
	Element& at(std::size_t raw, std::size_t column);

	/**
	 * \brief Retourne l'élément à l'indice recherché (version constante)
	 * \param raw L'indice de la ligne
	 * \param column L'indice de la colonne
	 */
	Element at(std::size_t raw, std::size_t column) const;

	/**
	 * \brief Construit une matrice identité de taille donnée
	 * \param size La taille de la matrice carrée
	 */
	static Matrix Identity(std::size_t size);

	/**
	 * \brief Construit une matrice colonne à partir de données existantes.\n
	 * Exemple :
	 * \code
	 * Matrix::ColumnVector({1, 2, 3, 4});
	 * \endcode
	 * construit une matrice de 4 lignes et 1 colonne de coordonnées (1, 2, 3, 4)
	 */
	static Matrix ColumnVector(std::initializer_list<Element>&&);

	/**
	 * \brief Construit une matrice ligne à partir de données existantes.\n
	 * Exemple :
	 * \code
	 * Matrix::RawVector({1, 2, 3, 4});
	 * \endcode
	 * construit une matrice de 1 ligne et 4 colonnes de coordonnées (1, 2, 3, 4)
	 */
	static Matrix RawVector(std::initializer_list<Element>&&);
};

template <typename T>
bool IsEqualZero(T var) {
	return std::abs(var) < std::pow(10, -5);
}