#include "vecteur.h"

Vecteur initVecteur(double x, double y, double z){
	Vecteur vect(x, y, z);
	return vect;
}

using namespace std;

Vecteur::Vecteur(double vecX, double vecY, double vecZ){
	initialisationVecteur(vecX, vecY, vecZ);
}

Vecteur::Vecteur(const char * str){
	initialisationVecteur(0.0, 0.0, 0.0);
	loadFromConfig(str);
}

Vecteur::Vecteur(const Vecteur & vec){
	initialisationVecteur(vec.p_x, vec.p_y, vec.p_z);
}

Vecteur::~Vecteur(){}

void Vecteur::save(FILE* fp){
	fprintf(fp, "(%lf,", p_x);
	fprintf(fp, "%lf,", p_y);
	fprintf(fp, "%lf)", p_z);
}

void Vecteur::save2d(FILE* fp){
	fprintf(fp, "(%lf,", p_x);
	fprintf(fp, "%lf)", p_y);
}

void Vecteur::load(FILE* fp){
	double nb;
	if(fscanf(fp, "(%lf,", &nb) == 0) return;
	p_x = nb;
	if(fscanf(fp, " %lf,", &nb) == 0) return;
	p_y = nb;
	if(fscanf(fp, " %lf)", &nb) == 0) return;
	p_z = nb;
}

bool Vecteur::initString(const char * str){
	if(str == NULL) return false;
	if(sscanf(str,"(%lf,%lf,%lf)",&p_x,&p_y,&p_z) == 0){
		if(sscanf(str,"(%lf,%lf)",&p_x,&p_y) == 0){
			if(sscanf(str,"(%lf)",&p_x) == 0){
				return false;
			}else return true;
		}else return true;
	}else return true;
}

Vecteur & Vecteur::operator = ( const Vecteur & vect){
	initialisationVecteur(vect.p_x, vect.p_y, vect.p_z);
	return *this;
}

Vecteur & Vecteur::operator += ( const Vecteur & vect){
	p_x += vect.p_x;
	p_y += vect.p_y;
	p_z += vect.p_z;
	return *this;
}

Vecteur & Vecteur::operator -= ( const Vecteur & vect){
	p_x -= vect.p_x;
	p_y -= vect.p_y;
	p_z -= vect.p_z;
	return *this;
}

Vecteur & Vecteur::operator *= (double coef){    //redéfinition de l'opérateur *=
	p_x *= coef;
	p_y *= coef;
	p_z *= coef;
	return *this;
}

Vecteur & Vecteur::operator /= (double coef){   //redéfinition de l'opérateur /=
	p_x /= coef;
	p_y /= coef;
	p_z /= coef;
	return *this;
}

Vecteur Vecteur::operator - (){
	Vecteur v(-p_x,-p_y,-p_z);
	return v;
}

double Vecteur::taille() const{
	double taille = sqrt(p_x*p_x + p_y*p_y + p_z*p_z);
	return taille;
}

double Vecteur::tailleLeviCivita() const{
	return p_x*p_x + p_y*p_y;
}

double Vecteur::normeSQR() const{
	return p_x*p_x + p_y*p_y + p_z*p_z;
}

Vecteur Vecteur::abs() const{
	Vecteur vect(fabs(p_x), fabs(p_y), fabs(p_z));
	return vect;
}

Vecteur Vecteur::absX() const{
	Vecteur vect(fabs(p_x), p_y, p_z);
	return vect;
}

Vecteur Vecteur::absY() const{
	Vecteur vect(p_x, fabs(p_y), p_z);
	return vect;
}

Vecteur Vecteur::absZ() const{
	Vecteur vect(p_x, p_y, fabs(p_z));
	return vect;
}

Vecteur Vecteur::getVectX() const{
	Vecteur vect(p_x, 0, 0);
	return vect;
}

Vecteur Vecteur::getVectY() const{
	Vecteur vect(0, p_y, 0);
	return vect;
}

Vecteur Vecteur::getVectZ() const{
	Vecteur vect(0, 0, p_z);
	return vect;
}

Vecteur Vecteur::getVectXY() const{return Vecteur(p_x, p_y, 0.0);}
Vecteur Vecteur::getVectYZ() const{return Vecteur(0.0, p_y, p_z);}
Vecteur Vecteur::getVectXZ() const{return Vecteur(p_x, 0.0, p_z);}

Vecteur Vecteur::getUnit() const{
	if(p_x == 0.0 && p_y == 0.0 && p_z == 0.0) return VECT3D_NULL;
	double tailleVec = this->taille();
	Vecteur unit(p_x/tailleVec, p_y/tailleVec, p_z/tailleVec);
	return unit;
}

double Vecteur::getAngle(const Vecteur& normale) const{
	if(p_x == 0.0 && p_y == 0.0 && p_z == 0.0) return 0.0; 
	return acos(((*this)*normale)/this->taille());
}

Vecteur Vecteur::leviCivitaToVecteur() const{
	Vecteur vect(p_x*p_x - p_y*p_y, 2.0*p_x*p_y, 0.0);
	return vect;
}

void Vecteur::setXYZ(double vecX, double vecY, double vecZ){
	p_x = vecX;
	p_y = vecY;
	p_z = vecZ;
}

void Vecteur::setx(const double x){p_x = x;}
void Vecteur::sety(const double y){p_y = y;}
void Vecteur::setz(const double z){p_z = z;}

void Vecteur::addx(double dx){p_x += dx;}
void Vecteur::addy(double dy){p_y += dy;}
void Vecteur::addz(double dz){p_z += dz;}

void Vecteur::setRotation(double angleTeta, double anglePhi){
	double longueur = this->taille();
	p_x = sin(anglePhi)*cos(angleTeta)*longueur;
	p_y = sin(anglePhi)*sin(angleTeta)*longueur;
	p_z = cos(anglePhi)*longueur;
}

void Vecteur::setSpheric(double rho, double angleTeta, double anglePhi){
	p_x = sin(anglePhi)*cos(angleTeta)*rho;
	p_y = sin(anglePhi)*sin(angleTeta)*rho;
	p_z = cos(anglePhi)*rho;
}

void Vecteur::rotation(const Vecteur& axe, double angle){
	Vecteur tourner = cos(angle)*(*this) + (1 - cos(angle))*((*this)*axe)*axe + sin(angle)*(axe^(*this));
	(*this) = tourner;
}

double Vecteur::getAngleTeta() const{
	double longueur = this->taille();
	double anglePhi = acosf(p_z/longueur);
	double cosTeta = p_x /  (longueur*sinf(anglePhi));
	double sinTeta = p_y / (longueur*sinf(anglePhi));
	double complex zTeta = longueur*(cosTeta + I*sinTeta);  //I est le i des nombres complexes
	double angleTeta = cargf(zTeta);
	return angleTeta;
}

void Vecteur::reflexion(const Vecteur& normal){                //vecteur normal à une surface plane
	Vecteur xF = (normal*(-(*this)))/(normal.taille()*normal.taille())*normal;
	*this = xF*2 + (*this);
}

Vecteur operator + (const Vecteur & vect1, const Vecteur & vect2){
	Vecteur vect3(vect1.p_x + vect2.p_x, vect1.p_y + vect2.p_y, vect1.p_z + vect2.p_z);
	return vect3;
}

Vecteur operator - (const Vecteur & vect1, const Vecteur & vect2){
	Vecteur vect3(vect1.p_x - vect2.p_x, vect1.p_y - vect2.p_y, vect1.p_z - vect2.p_z);
	return vect3;
}

double operator * (const Vecteur & vect1, const Vecteur & vect2){
	return vect1.p_x*vect2.p_x + vect1.p_y*vect2.p_y + vect1.p_z*vect2.p_z;
}

Vecteur operator * (const Vecteur & vect, double scal){
	Vecteur vect2(vect.p_x*scal, vect.p_y*scal, vect.p_z*scal);
	return vect2;
}

Vecteur operator * (double scal, const Vecteur & vect){
	Vecteur vect2(vect.p_x*scal, vect.p_y*scal, vect.p_z*scal);
	return vect2;
}

Vecteur operator / (const Vecteur & vect, double scal){
	Vecteur vect2(vect.p_x/scal, vect.p_y/scal, vect.p_z/scal);
	return vect2;
}

Vecteur operator ^ (const Vecteur & vect1, const Vecteur & vect2){
	Vecteur vect(vect1.p_y*vect2.p_z - vect1.p_z*vect2.p_y, -vect1.p_x*vect2.p_z + vect1.p_z*vect2.p_x, vect1.p_x*vect2.p_y - vect1.p_y*vect2.p_x);
	return vect;
}

bool operator == (const Vecteur & vect1, const Vecteur & vect2){
	return (vect1.p_x == vect2.p_x && vect1.p_y == vect2.p_y && vect1.p_z == vect2.p_z);
}

bool operator != (const Vecteur & vect1, const Vecteur & vect2){
	return !(vect1.p_x == vect2.p_x && vect1.p_y == vect2.p_y && vect1.p_z == vect2.p_z);
}

std::ostream & operator << (std::ostream & out, const Vecteur & vecteur){
	out << "(" << vecteur.p_x << ", " << vecteur.p_y << ", " << vecteur.p_z << ")";
	return out;
}

std::istream & operator >> (std::istream & in, Vecteur & v){
	in >> v.p_x >> v.p_y  >> v.p_z;
	return in;
}

bool Vecteur::loadFromConfig(const char* source)
{
	return (sscanf(source,"(%lf,%lf,%lf)",&p_x,&p_y,&p_z) != 0);
}

void Vecteur::initialisationVecteur(double vecX, double vecY, double vecZ){
	p_x = vecX;
	p_y = vecY;
	p_z = vecZ;
}