#include <iostream>
#include "Balle.h"


using namespace std;

#define LONGUEUR_MAX 244.0 //Longueur de la table
#define LARGEUR_MAX 122.0  //Largeur de la table
#define PI 3.1416		 //Pi

static double distPrec; //Programmation louche, besoin dans 2 fonctions


/*
* Fonction qui initialise les balles avec des vecteurs
* entrant de vitesse et de position
*
*/
int Initialiser( Vecteur2 balle1VectPos, Vecteur2 balle1VectVit,
				  Vecteur2 balle2VectPos, Vecteur2 balle2VectVit,
				  Balle& balle1, Balle& balle2){

  //Déterminera s'il y a erreur ou non
	bool isError = false;

	//Changement de valeur entre largeur et longueur
	int mesureMax;

	//Vérifie les conditions de la spécification
	for(int i=0;i<2;i++)
	{
		//Spec de longueur et largeur
		if(i == 0) mesureMax = LONGUEUR_MAX;
		else    mesureMax = LARGEUR_MAX;

		//
		if(balle1VectPos[i] < 0.0 || balle2VectPos[i] < 0.0)
			isError = true;
		if(balle1VectPos[i] > mesureMax || balle2VectPos[i] > mesureMax)
			isError = true;
	}

	//On initialise les coordonnees de position et vitesse des balles
	if(!isError)
	{
		balle1.setPosition(balle1VectPos);
		balle1.setVitesse(balle1VectVit);

		balle2.setPosition(balle2VectPos);
		balle2.setVitesse(balle2VectVit);
		
		//Pas d'erreur
		return 0;

	}else{
		//Erreur
		return -1;

	}
}


/*
* Fonction qui n'est pas utilisé, mais qui pourrait
* servire. Imprime le point d'impact à l'écrant
*/
void pointDeCollision(Balle &balle1, Balle &balle2 )
{
	//affichage du point de collision
	Vecteur2 ptDeColl( (balle2.getPosition()[0] - balle1.getPosition()[0])/2.0, 
                  (balle2.getPosition()[1] - balle1.getPosition()[1])/2.0);
		cout << endl;
		cout << "Point de Collision en x :" << ptDeColl[0] << endl;
		cout << "Point de Collision en y :" << ptDeColl[1] << endl;
}



/*
* Fonction qui évalue s'il y a collision ou pas.
* Met à jour automatiquement les nouvelles positions 
* des balles.
*
* Retourne 0, 1, ou 2 : !collision, collision, collision évité
*/
int detecterCollision(Balle &balle1, Balle &balle2)
{
	//Distance actuelle
  double distAct;
	distAct = sqrt( pow((balle1.getPosition()[0] - balle2.getPosition()[0]),2) + 
               pow((balle1.getPosition()[1] - balle2.getPosition()[1]),2));

	//Detecte la collision si les deux balles sont a une distance du diametre de lune des balles
	if( distAct <= balle1.getDiametre() ){
		cout << endl << "Collision" << endl;
		pointDeCollision(balle1, balle2);
		return 1;
	}else if(distAct >= distPrec)
	{
		cout << "collision evite" << endl;
		return 2;
	}

	distPrec = distAct;

	return 0;

}

/*
* Fonction qui évalue les nouvelles vitesses après
* une collision. Mathématique reprise d'un site web.
*
* Retourne rien, mais change les valeurs de vXx, vYx
*/
void calculerVecteur(double m1, double m2,
         double pX1, double pY1, double pX2, double pY2,
         double& vX1, double& vY1, double& vX2, double& vY2)   
{

    double m21,dvx2,a,x21,y21,vx21,vy21,fy21,sign;

    m21 = m2 / m1;
    x21 = pX2 - pX1;
    y21 = pY2 - pY1;
    vx21 = vX2 - vX1;
    vy21 = vY2 - vY1;
 
    fy21 = 1.0E-12 * fabs(y21);  

	  //Détermination du signe de la nouvelle direction
    if ( fabs(x21)<fy21 ) 
	  { 
      if (x21 < 0) {
			  sign=-1; 
		  } else {
			  sign=1;
		  } 
      x21=fy21*sign; 
    } 

	  //Calcul des vitesses finales
    a  = y21/x21;
    dvx2 = -2*(vx21 + a*vy21)/((1 + pow(a,2))*(1 + m21)) ;
    vX2 = vX2 + dvx2;
    vY2 = vY2 + a*dvx2;
    vX1 = vX1 - m21*dvx2;
    vY1 = vY1 - a*m21*dvx2;

}


/*
* Fonction Main qui simule les déplacements et initialise
* les variables utile à la simulation.
*/
int main()
{
	//Initialisation de quelques variables
	bool futureColl = true;
	int initRetValue, collisionValue;
	double incrementTemps = 0.01;
	Balle balle1, balle2;
	
	double vX1, vX2, vY1, vY2, pX1, pX2, pY1, pY2, m1, m2;

	//Propriété des balles (p: position, v: vitesse, m: masse)
	pX1 = 0.0;
	pY1 = 0.0;
	vX1 = 0.0;
	vY1 = 0.0;
	pX2 = 0.0;
	pY2 = 0.0;
	vX2 = 0.0;
	vY2 = 0.0;
	m1 = balle1.getMasse();
	m2 = balle2.getMasse();
	
	//Initialisation des balles
	initRetValue = Initialiser(Vecteur2(pX1,pY1), Vecteur2(vX1,vY1), 
		            Vecteur2(pX2,pY2), Vecteur2(vX2,vY2),
							  balle1, balle2);
	
	//Erreur d'initialisation (hors limite)
	if(initRetValue < 0)
	{
		cout << "ERREUR - Initialisation" << endl;
		system("pause");
		return -1;
	}

	//Technique de programmation louche
	distPrec = sqrt( pow((balle1.getPosition()[0] - balle2.getPosition()[0]),2) + 
               pow((balle1.getPosition()[1] - balle2.getPosition()[1]),2));

	//Simule le mouvement des billes
	for(;futureColl == true;)
	{
		//Mise a jour du déplacement
		balle1.rafraichirPosition(incrementTemps);
		balle2.rafraichirPosition(incrementTemps);
		
		//Détection de la collision
		collisionValue = detecterCollision(balle1,balle2);
		
		//S'il y a collision ou s'il y a évitement, on sort de la boucle
		if(collisionValue == 1 || collisionValue == 2)
		{
			break;
		}
	}

	//Changer les coordonnée pour le calcul
	pX1 = balle1.getPosition()[0];
	pY1 = balle1.getPosition()[1];
	pX2 = balle2.getPosition()[0];
	pY2 = balle2.getPosition()[1];

	//Les vitesses restent les même
	
	//Calcul des vitesses finales
	calculerVecteur(m1,m2,pX1,pY1,pX2,pY2,vX1,vY1,vX2,vY2);
	
	balle1.setVitesse(Vecteur2(vX1,vY1));
	balle2.setVitesse(Vecteur2(vX2,vY2));

	//Affichage des résultats des vecteurs (valeur par défaut si pas de collision)
	cout <<"Vitesse balle 1: " << sqrt(pow(vX1,2) + pow(vY1,2)) << "m/s  
           Angle balle 1: "<< atan(vY1/vX1) *180 /PI<<" degre" << endl;
	cout <<"Vitesse balle 2: " << sqrt(pow(vX2,2) + pow(vY2,2)) << "m/s  
           Angle balle 2: "<< atan(vY2/vX2) *180 /PI<<" degre" << endl;

	//Permet de voir ce qu'il y a à l'écran
	system("pause");
}