#include "Vect.h"

#include "Gauss.h"
#include "Solver.h"
#include <cassert>
#include <iostream>

static bool IsColumnNull(Matrix& mat, std::size_t column) {
	for (std::size_t i = 0; i < mat.GetRawCount(); i++) {
		if (!IsEqualZero(mat.at(i, column))) {
			return false;
		}
	}
	return true;
}

Vect::Vect(const Matrix& mat) : m_Data(mat) {
	Simplify();
}

void Vect::Simplify() {
	Matrix mat = m_Data;
	for (std::size_t j = 0; j < mat.GetColumnCount(); j++) {
		if (IsColumnNull(mat, j)) {
			m_Data = mat.SubMatrix(0, 0, mat.GetRawCount(), j);
			return;
		}
	}
	m_Data = mat;
}

Matrix Vect::GetVector(std::size_t index) const {
	return m_Data.SubMatrix(0, index, m_Data.GetRawCount(), 1);
}

std::size_t Vect::GetCardinal() const {
	return m_Data.GetColumnCount();
}

bool Vect::IsElementOf(const Matrix& vec) const {
	Vect base = *this;
	base.AddVector(vec);
	return base.GetCardinal() == GetCardinal();
}

bool Vect::operator==(const Vect& other) const {
	if (GetDimension() != other.GetDimension() || GetCardinal() != other.GetCardinal())
		return false;

	// on vérifie si chaque vecteur de la deuxième base appartient à l'espace vectoriel engendré par la première base
	for (std::size_t i = 0; i < GetCardinal(); i++) {
		if (!IsElementOf(other.GetVector(i)))
			return false;
	}
	return true;
}

void Vect::AddVector(const Matrix& mat) {
	m_Data.Augment(mat);
	m_Data.Transpose();
	Gauss::GaussJordan(m_Data, false, false);
	m_Data.Transpose();
	Simplify();
}

bool Vect::operator!=(const Vect& other) const {
	return !(*this == other);
}

Matrix Vect::GetLinearSystem() const {
	Matrix vect = m_Data;
	vect.Transpose();

	Solver solver {vect};
	vect = solver.Kernel().m_Data;
	vect.Transpose();
	return vect;
}

std::size_t Vect::GetDimension() const {
	return m_Data.GetRawCount();
}

VectAffine::VectAffine(const Vect& base, const Matrix& origine) :
	m_Base(base), m_Origin(origine.SubMatrix(0, 0, m_Base.GetDimension(), 1)) {}

bool VectAffine::IsElementOf(const Matrix& vec) const {
	return m_Base.IsElementOf(vec - m_Origin);
}