/***************************************************************************
golf.c
 ***************************************************************************/
#include "golf.h"


/*
  *  paramètre d'entrées  : 	le nombre actuel d'element(s) du tableau
  *
  *  en entrées :
  *
  *  paramètre de sortie
  *
  *  paramètre  d'E/S 		un tableau de pointeur(s) sur parcours
  *
  * en sortie :

  *  valeur retournée :		le nouveau nombre de parcours present dans le tableau
  *
  *  DESCRIPTION	: 	creation dynamique d'un parcours, initialisation
  *				et ajout de ce dernier dans le tableau des parcours
  *
  */
int creerParcours( typeParcours *tab[], int nbParcours )
{
	int i;
	// creation du parcours a l'indice nbParcours
	tab[nbParcours] = ( typeParcours* ) malloc( sizeof( typeParcours ) );
	printf( "\nnom du parcours " );
	scanf( "%s", tab[nbParcours]->nom );
	printf( "nombre de trous " );
	scanf( "%d", &tab[nbParcours]->nbTrou );

	// initialisation des trous
	for ( i = 0;i < tab[nbParcours]->nbTrou;i++ )
	{
		printf( "numero du trou : %d\n", i + 1 );
		tab[nbParcours]->listeTrous[i].numero = i + 1;
		printf( "distance (en metre) : " );
		scanf( "%f", &tab[nbParcours]->listeTrous[i].distance );
		printf( "valeur du par : " );
		scanf( "%d", &tab[nbParcours]->listeTrous[i].par );
		printf( "nombre maximum de coups pour ce trou : " );
		scanf( "%d", &tab[nbParcours]->listeTrous[i].nbMaxCoups );
	}

	return nbParcours + 1;
}

/*
  *  paramètre d'entrées  : 	un tableau de pointeur(s) sur parcours
  				le numero d'index du parcours a afficher
  *
  *  en entrées :
  *
  *  paramètre de sortie
  *
  *  paramètre  d'E/S
  *
  * en sortie :			affichage de info à l'ecran

  *  valeur retournée :
  *
  *  DESCRIPTION	: 	afficher les informations d'un parcours particulier
  *
  */
void afficherUnParcours( typeParcours *tab[], int nro )
{
	int i;
	printf( "\nnom du parcours %s\n", tab[nro]->nom );
	printf( "nombre de trous %d\n", tab[nro]->nbTrou );

	// afficher le detail de chaque trou du parcours
	for ( i = 0;i < tab[nro]->nbTrou;i++ )
	{
		afficherInfoTrou( tab[nro]->listeTrous[i] );
	}
}


/*
  *  paramètre d'entrées  : 	un tableau de pointeur(s) sur parcours
  				le nombre actuel d'element(s) du tableau
  *
  *  en entrées :
  *
  *  paramètre de sortie
  *
  *  paramètre  d'E/S
  *
  * en sortie :			fichier contenant l'ensemble des parcours

  *  valeur retournée :
  *
  *  DESCRIPTION	: 	sauvegarder les donnees des parcours dans un fichier
  *
  */
void sauvegarderParcours( typeParcours *tab[], int nbParcours )
{
    FILE *fd;
    int i;
    int nbEnregistrement;
    int retourFclose;
    // ouverture du fichier des parcours en ecriture
    fd = fopen( FICHIER_PARCOURS, "w+" );
    if ( fd == NULL )
    {
        printf( "%s\n", strerror( errno ) );
        exit( errno );
    }

    //ecriture de chacun des parcours
    for ( i = 0; i < nbParcours; i++ )
    {
        nbEnregistrement=fwrite( tab[i], sizeof( typeParcours ), 1, fd );
        if (nbEnregistrement!=1)
        {
            printf( " pb sauvegarde parcours%s\n", strerror( errno ) );
            exit( errno );

        }
    }

    retourFclose=fclose( fd );
    if(retourFclose==EOF)
    {
        printf( " pb fermeture sauvegarde parcours%s\n", strerror( errno ) );
        exit( errno );
    }
}

/*
  *  paramètre d'entrées  :

  *
  *  en entrées :		fichier contenant l'ensemble des parcours
  *
  *  paramètre de sortie :	un tableau de pointeur(s) sur parcours
  *
  *  paramètre  d'E/S
  *
  * en sortie :

  *  valeur retournée :		le nombre actuel d'element(s) du tableau des parcours
  *
  *  DESCRIPTION	: 	initialiser le tableau des parcours
  *				à partir d'un fichier
  *
  */
int chargerParcours( typeParcours *tab[] )
{
	FILE *fd;
	int nbEnregistrement;
	int i = 0;
	int retourFclose;
	// ouverture du fichier des parcours en lecture
	fd = fopen( FICHIER_PARCOURS, "r" );

	if ( fd == NULL )
	{
		printf( "%s\n", strerror( errno ) );
		exit( errno );
	}

	// lecture et stockage de tous les parcours
    while ( !feof( fd ) )
    {
        // reservation memoire pour stokcer un parcours
        tab[i] = ( typeParcours* ) malloc( sizeof( typeParcours ) );
        //lecture d'un parcours
        nbEnregistrement=fread( tab[i], sizeof( typeParcours ), 1, fd );
        if (nbEnregistrement!=1)    // pb de lecture
        {
            if (!feof(fd))
            {
                printf( " pb lecture charger parcours%s\n", strerror( errno ) );
                exit( errno );
            }
            else
            {
                // c'est la fin de fichier
                // on a donc réserve une case en trop pour les parcours
                // il faut la supprimer
                    free( tab[i] );

            }

        }
        else
        {
            // augmentation du nombre de parcours lu
            i++;
        }


    }

    retourFclose=fclose( fd );
    if(retourFclose==EOF)
    {
        printf( " pb fermeture charger parcours%s\n", strerror( errno ) );
        exit( errno );
    }

	// je retourne le nombre de parcours maintenant present dans mon tableau
	return i;
}


/*
 *	retourne une valeur entiere E[0..maxAlea[
 */
float aleatoire( float maxAlea )
{
	/* struct timeb {
	    time_t         time;
	    unsigned short millitm;
	    short          timezone;
	    short          dstflag;
	};*/

	struct timeb t;
	//long t;
	float a, b ;
	unsigned int nbmilli;
	ftime( &t );
	nbmilli = t.time * 1000 + t.millitm;
	srand( nbmilli );
	a = rand();
	b = ( maxAlea * a ) / RAND_MAX;
	return ( b );


}
/*
 *	retourne un entier entre min et max
*/
float lancement( float min, float max )
{
	float lancee;
	lancee = min + aleatoire( max - min );
	return ( lancee );
}


/*
  *  paramètre d'entrées  : 	un trou
  *				la difficulte sur le green
  *
  *
  *  en entrées :		le choix du club utilise
  *
  *  paramètre de sortie :
  *
  *  paramètre  d'E/S
  *
  * en sortie :			affichage de la distance restante
  *				et du nombre de points

  *  valeur retournée :		le nombre de coups effectue pour arriver au trou
  *
  *  DESCRIPTION	: 	jouer un trou ->
  *					demander autant de fois que necessaire
  *					le type de club a utilise
  *					jusqu'à arriver au trou.
  *				->la difficulte est de determiner à partir de
  *					combien de metres du trou
  *					une balle est consideree dans le trou.
  *
  */
int jouerTrou( typeTrou t, float difficulte )
{
	int fin = 1; // la balle n'est pas dans le trou
	float dist = t.distance;
	int nbCoups = 1;
	char choix;

	do
	{
		printf( "=============== coups nro %d\n", nbCoups );
		printf( "choix du club : \n[D]river\n[B]ois\n[F]er\n[P]utter\n" );
		scanf( " %c", &choix );
		choix = toupper( choix );
		// en fonction du choix de club, je reduis la distance avec le trou

		switch ( choix )
		{

			case 'D':
				dist -= lancement( DRIVER_MIN, DRIVER_MAX );
				break;

			case 'B':
				dist -= lancement( BOIS_MIN, BOIS_MAX );
				break;

			case 'F':
				dist -= lancement( FER_MIN, FER_MAX );
				break;

			case 'P':
				dist -= lancement( PUTTER_MIN, PUTTER_MAX );
				break;
		}

		if ( dist <= 0.0 )
		{// si je depasse le trou je remets une distance positive
			dist = -dist;

			if ( dist > difficulte )
				printf( "%svous avez depasse le trou%s\n", RED, GREY );
		}

		if ( dist <= difficulte && dist >= 0.0 )
		{// la balle est dans le trou
			fin = 0;
		}
		if ( nbCoups == t.nbMaxCoups )
		{// j'ai atteint le nombre maxi de coups pour le trou
			if ( fin != 0 )
			{// et en plus la balle n'est toujours pas dans le trou
				printf( "%sNombre de coups maxi atteint!! abandon de ce trou%s\n", RED, GREY );
			}

			fin = 0;
		}

		if ( fin != 0 )
		{// je dois rejouer, j'affiche la distance restante
			nbCoups++;
			printf( "=================================================\n" );
			printf( "il vous reste %.1f metres avant le trou\n", dist );
			printf( "=================================================\n" );
		}
	}
	while ( fin != 0 );

	printf( "\n\n\n" );

	// suivant le nombre de coups joue par rapport au "par" du trou
	// j'affiche la designation correspondante
	switch ( nbCoups - t.par )
	{

		case CONDOR:
			printf( "%s CONDOR !!!! %d\n%s", YELLOW, CONDOR, GREY );
			break;

		case ALBATROS:
			printf( "%s ALBATROS!!! %d\n%s", YELLOW, ALBATROS, GREY );
			break;

		case EAGLE:
			printf( "%sEAGLE!! %d%s\n", YELLOW, EAGLE, GREY );
			break;

		case BIRDIE:
			printf( "%sBIRDIE! %d%s\n", YELLOW, BIRDIE, GREY );
			break;

		case PAR:
			printf( "PAR %d\n", PAR );
			break;

		case BOGEY:
			printf( "%sBOGEY +%d%s\n", RED, BOGEY, GREY );
			break;

		case DOUBLE_BOGEY:
			printf( "%sDOUBLE_BOGEY +%d%s\n", RED, DOUBLE_BOGEY, GREY );
			break;

		case TRIPLE_BOGEY:
			printf( "%sTRIPLE_BOGEY +%d%s\n", RED, TRIPLE_BOGEY, GREY );
			break;

		default:
			printf( "%s+%d%s\n", RED, nbCoups - t.par, GREY );
	}

	printf( "\n\n\n" );

	// retourne le nombre de coups joue pour ce trou
	return ( nbCoups );
}




/*
  *  paramètre d'entrées  : 	un pointeur sur un score
  *
  *  en entrées :
  *
  *  paramètre de sortie :
  *
  *  paramètre  d'E/S
  *
  * en sortie :			affichage du score d'un joueur pour un parcours
  *  valeur retournée :
  *
  *  DESCRIPTION	: 	affichage du score d'un joueur pour un parcours
  *
  */
void afficherScore( typeScore *s )
{
	int i, total = 0;

	printf( "score de%s %s:%s\n", CYAN, s->nomJoueur, GREY );
	printf( "parcours : %s     difficulte : ", s->parcoursJoue.nom );

	// suivant la valeur de la difficulte, afficher la difficulte en toute lettre
	switch ( s->difficulte )
	{

		case 0:
			printf( "infernale\n" );

		case 1:
			printf( "tres difficile\n" );

		case 2:
			printf( "difficile\n" );

		case 3:
			printf( "normale\n" );

		case 4:
			printf( "facile\n" );

		case 5:
			printf( "tres facile\n" );
	}

	// affichage de la grille avec le numero des trous, les valeurs des "par" et le score du joueur
	printf( "--------------" );

	for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ )
	{
		printf( "----" );
	}

	printf( "\n" );

	//affichage des numeros de trou
	printf( "nro Trou      " );

	for ( i = 0;i < s->parcoursJoue.nbTrou;i++ )
	{
		if ( i < 10 )
		{
			printf( "| %.1d ", i + 1 );
		}
		else
		{
			printf( "| %.2d", i + 1 );
		}
	}

	printf( "|TOT" );

	printf( "\n" );
	printf( "--------------" );

	for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ )
	{
		printf( "----" );
	}

	printf( "\n" );

	//affichage des valeurs de "par" pour chaque trou
	printf( "valeur du par " );

	for ( i = 0;i < s->parcoursJoue.nbTrou;i++ )
	{
		printf( "| %.1d ", s->parcoursJoue.listeTrous[i].par );
		total += s->parcoursJoue.listeTrous[i].par;
	}

	printf( "| %.2d", total );

	printf( "\n" );
	total = 0;
	printf( "--------------" );

	for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ )
	{
		printf( "----" );
	}

	printf( "\n" );

	//affichage du score du joueur
	printf( "score         " );

	for ( i = 0;i < s->parcoursJoue.nbTrou;i++ )
	{
		printf( "| " );

		if ( s->points[i] > ( s->parcoursJoue.listeTrous[i].par ) )
			printf( "%s", RED );

		if ( s->points[i] < ( s->parcoursJoue.listeTrous[i].par ) )
			printf( "%s", YELLOW );

		printf( "%.1d %s", s->points[i], GREY );

		total += s->points[i];
	}

	printf( "| %.2d", total );

	printf( "\n" );
	printf( "--------------" );

	for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ )
	{
		printf( "----" );
	}

	printf( "\n" );
}


/*
  *  paramètre d'entrées  : 	le nombre de scores present dans le tableau des scores
  *
  *  en entrées :
  *
  *  paramètre de sortie :
  *
  *  paramètre  d'E/S 		tableau de pointeurs sur des scores
  *
  * en sortie :			le tableau des scores trie
  *					selon la somme des coups par ordre croissant
  *  valeur retournée :
  *
  *  DESCRIPTION	: 	trier les scores du meilleur au plus mauvais
  *
  */
void classement( typeScore *tab[], int nbScore )
{
	int i, j, k;
	typeScore *tmp;
	int sommei = 0, sommej = 0;

	for ( i = 0;i < nbScore;i++ )
	{
		sommei = 0;
		// calcul de la somme des points au rang i
		for ( k = 0;k < tab[i]->parcoursJoue.nbTrou;k++ )
			sommei += tab[i]->points[k];

		for ( j = i;j < nbScore;j++ )
		{
			sommej = 0;
			// calcul de la somme des points au rang j
			for ( k = 0;k < tab[j]->parcoursJoue.nbTrou;k++ )
				sommej += tab[j]->points[k];

			// si le score au rang j est plus petit qu'au rang i swapper les pointeurs
			if ( sommej < sommei )
			{
				tmp = tab[i];
				tab[i] = tab[j];
				tab[j] = tmp;
			}

		}
	}

}


/****************************************************************************************************
****************************************************************************************************
****************************************************************************************************
	fonctions a coder/completer
****************************************************************************************************
****************************************************************************************************
****************************************************************************************************/

void afficherMenu(int nbParcours, int nbScores)
{
    if(nbParcours > 0)
    {
        printf("[J] Jouer un parcours\n");
        printf("[D] Jouer un parcours avec 2 joueurs\n");
        printf("[V] Afficher un parcours\n");
    }

    if(nbScores > 0)
    {
        printf("[Z] Classement\n");
    }

    printf("[C] Creer un parcours\n");
    printf("[Q] Quitter\n");

    printf("Votre choix :");
}


/*
  *  paramètre d'entrées  : 	un trou
  *
  *  en entrées :
  *
  *
  *  paramètre de sortie :
  *
  *  paramètre  d'E/S
  *
  * en sortie : Affichage des champs du trou

  *  valeur retournée :
  *
  *  DESCRIPTION	: 	Affichage des caracteristiques d'un trou
  *
  *
  */
void afficherInfoTrou( typeTrou unTrou)
{
    printf("[Trou numero %d |", unTrou.numero);
    printf(" Distance %.2f metres |", unTrou.distance);
    printf(" Par %d |", unTrou.par);
    printf(" %d coups maximum]\n", unTrou.nbMaxCoups);
}


/*
  *  paramètre d'entrées  : 	tableau de pointeur sur des parcours
								nombre de parcours actuellement dans le tableau
  *
  *  en entrées :
  *
  *
  *  paramètre de sortie :
  *
  *  paramètre  d'E/S
  *
  * en sortie :	affichage de l'index(numero d'indice) de chaque parcours suivi de son nom

  *  valeur retournée :
  *
  *  DESCRIPTION	: 	Affichage des différents parcours disponibles
  *
  *
  */
void afficherLesParcours( typeParcours *tab[], int nbParcours )
{
    int i;

    for(i = 0; i <
 nbParcours; i++)
    {
        printf("%d - %s\n", i, tab[i]->nom);
    }
}



/*
  *  paramètre d'entrées  : 	un pointeur sur le parcours a jouer
  *
  *  en entrées :		nom du joueur
  *				difficulte de la partie
  *
  *  paramètre de sortie :
  *
  *  paramètre  d'E/S
  *
  * en sortie :			affichage des differents coups joues
  				affichage du score
  				mise à jour du fichier des scores

  *  valeur retournée :		un pointeur sur le score du joueur
  *
  *  DESCRIPTION	: 	creation d'un joueur avec son score,
  *				joue chaque trou du parcours.
  *
  */
typeScore *jouerParcours( typeParcours *p )
{
	typeScore *sc;
	int i;
	float niveau;
	// creation d'un nouveau score
	sc = ( typeScore* ) malloc( sizeof( typeScore ) );

	printf( "votre nom :" );
	scanf( "%s", sc->nomJoueur );
	printf( "difficulte [0-infernale .. 5-tres facile]" );
	scanf( "%d", &sc->difficulte );
	niveau = 1.0 + 3.0 * ( float ) sc->difficulte;
	// recopie des donnees du parcours fait par le joueur
	memcpy( &sc->parcoursJoue, p, sizeof( typeParcours ) );

	printf( "parcour %s\n", p->nom );
/*****************************************************************************************/
	// pour chaque trou du parcours
	// afficher les informations concernant le trou
	// jouer le trou et sauvegarder le nombre de coups joue dans le tableau
	// des points du joueur
	for ( i = 0;i < p->nbTrou;i++ )
	{
		afficherInfoTrou( p->listeTrous[i] );
		sc->points[i] = jouerTrou( p->listeTrous[i], niveau );
	}

	// afficher le score du joueur pour ce parcours
    afficherScore( sc );

	// sauvegarder ce score

	sauvegarderScore(sc);

/*****************************************************************************************/
	return sc;
}

void sauvegarderScore( typeScore *sc )
{
    FILE *fd;
    int erreurEcriture;
    int erreurFClose;

    fd = fopen( FICHIER_SCORE, "w+");

    erreurEcriture = fwrite(sc, sizeof(typeScore), 1, fd);
    if(erreurEcriture != 1)
    {
        printf("Probleme sauvegarde scores%s\n", strerror(errno));
        exit(errno);
    }

    erreurFClose = fclose(fd);
    if(erreurFClose == EOF)
    {
        printf("Probleme fermeture sauvegarde scores%s\n", strerror(errno));
        exit(errno);
    }
}

int chargerLesScores( typeScore *tab[] )
{
    FILE *fd;
    int i = 0;
    int erreurLecture;
    int erreurFClose;

    fd = fopen(FICHIER_SCORE, "r");
    if(fd == NULL)
    {
        printf("%s\n", strerror(errno));
        exit(errno);
    }

    while(!feof(fd))
    {
        tab[i] = (typeScore*) malloc(sizeof(typeScore));

        erreurLecture = fread(tab[i], sizeof(typeScore), 1, fd);
        if(erreurLecture != 1)
        {
            if(!feof(fd))
            {
                printf("Probleme lecture chargement scores%s\n", strerror(errno));
                exit(errno);
            }
            else
            {
                free(tab[i]);
            }
        }
        else
        {
            i++;
        }
    }
    erreurFClose = fclose(fd);
    if(erreurFClose == EOF)
    {
        printf("Probleme fermeture chargement scores%s\n", strerror(errno));
        exit(errno);
    }

    return i;

}

void jouerParcoursADeux( typeParcours *p )
{
    typeScore *scP1;
    typeScore *scP2;
	int i;
	float niveauP1;
	float niveauP2;
	// creation d'un nouveau score
	scP1 = ( typeScore* ) malloc( sizeof( typeScore ) );
	scP2 = ( typeScore* ) malloc( sizeof( typeScore ) );

	printf( "Nom player 1 :" );
	scanf( "%s", scP1->nomJoueur );
	printf( "difficulte player 1 [0-infernale .. 5-tres facile]" );
	scanf( "%d", &scP1->difficulte );

	printf( "Nom player 2 :" );
	scanf( "%s", scP2->nomJoueur );
	printf( "difficulte player 2 [0-infernale .. 5-tres facile]" );
	scanf( "%d", &scP2->difficulte );

	niveauP1 = 1.0 + 3.0 * ( float ) scP1->difficulte;
	niveauP2 = 1.0 + 3.0 * ( float ) scP2->difficulte;

	// recopie des donnees du parcours fait par le joueur
	memcpy( &scP1->parcoursJoue, p, sizeof( typeParcours ) );
	memcpy( &scP2->parcoursJoue, p, sizeof( typeParcours ) );

	printf( "parcour %s\n", p->nom );

	// pour chaque trou du parcours
	// afficher les informations concernant le trou
	// jouer le trou et sauvegarder le nombre de coups joue dans le tableau
	// des points du joueur
	for ( i = 0;i < p->nbTrou;i++ )
	{
		afficherInfoTrou( p->listeTrous[i] );
		printf("%s", scP1->nomJoueur);
		scP1->points[i] = jouerTrou( p->listeTrous[i], niveauP1 );
		printf("%s", scP2->nomJoueur);
		scP2->points[i] = jouerTrou( p->listeTrous[i], niveauP2 );
	}

	afficherScore( scP1 );
	afficherScore( scP2 );
}