/* En-tête du programme
=======================
Programme :		triHeureEnsoleillement.cpp
Auteur :		Jean-Philippe Tremblay
Conception :	21/03/2017
Description :	lit le nombre d'heures d'ensoleillement dans un fichier pour chaque mois et jours et calcule ainsi le total des heures,
				la moyenne des heures et trouve la meilleure journée et le meilleur mois.
*/

/*Directives au pré-processeur
========================= */
#include <iostream>
#include <saisieSecurisee.h>
#include <iomanip>

using namespace std;

const int NBJOURS = 31;
const int NBMOIS = 12;

/* Prototype de fonctions
=================== */

void lireMois(ifstream &entree, int nbHeure[NBMOIS][NBJOURS]);
void calculerTotalHeure(int totalHeure[NBMOIS], int nbHeure[NBMOIS][NBJOURS]);
void calculerMoy(float moyenne[NBMOIS], int totalHeure[NBMOIS], int nbJoursParMois[NBMOIS]);
void afficherResultatMois(ostream &sortie, char nomM[NBMOIS][14], int totalHeure[NBMOIS], float moyenne[NBMOIS]);
void afficherStats(ostream &sortie, char nomMM[14], int totalHeureMM, int dateMJ, char nomMJ[14], int nbHeureMJ);
void afficher6MeilleurMois(ostream &sortie, char nomM[NBMOIS][14]);
void meilleurJourAnnee(int nbHeure[NBMOIS][NBJOURS], int &meilleurMois, int &meilleurJour);
int meilleurMoisAnnee(int totalHeure[NBMOIS]);
void trier6MeilleursMois(int totalHeure[NBMOIS], char nomM[NBMOIS][14]);
/* Programme principale
======================= */



void main()
{

	// Création et initialisation des variables

	int nbHeure[NBMOIS][NBJOURS];
	int nbJoursParMois[NBMOIS] = { 31, 29, 31, 30 ,31, 30, 31, 31, 30, 31, 30, 31 };
	int totalHeure[NBMOIS] = { 0 };
	int ligneMeilleurJour,
		colMeilleurJour,
		meilleurMois;

	float moyenne[NBMOIS];

	char nomM[NBMOIS][14] = { "Janvier", "Fevrier", "Mars", "Avril", "Mai", "Juin", "Juillet", "Aout", "Septembre", "Octobre",
						  "Novembre", "Decembre" };

	ofstream sortie;
	ifstream entree;

	if (ouvrirFichier(entree, "soleil.txt") == true)
	{
		sortie.open("sortie.txt");

		lireMois(entree, nbHeure);

		calculerTotalHeure(totalHeure, nbHeure);
		calculerMoy(moyenne, totalHeure, nbJoursParMois);

		afficherResultatMois(cout, nomM, totalHeure, moyenne);
		afficherResultatMois(sortie, nomM, totalHeure, moyenne);

		meilleurJourAnnee(nbHeure, ligneMeilleurJour, colMeilleurJour);
		meilleurMois = meilleurMoisAnnee(totalHeure);

		afficherStats(cout, nomM[meilleurMois], totalHeure[meilleurMois], colMeilleurJour + 1, nomM[ligneMeilleurJour] , nbHeure[ligneMeilleurJour][colMeilleurJour]);
		afficherStats(sortie, nomM[meilleurMois], totalHeure[meilleurMois], colMeilleurJour + 1, nomM[ligneMeilleurJour], nbHeure[ligneMeilleurJour][colMeilleurJour]);

		trier6MeilleursMois(totalHeure, nomM);
		afficher6MeilleurMois(cout, nomM);
		afficher6MeilleurMois(sortie, nomM);
	}

	entree.close();
	sortie.close();
	pause();
}
// pour lire le nombre d'heure d'ensoleillement dans chaque mois sur leurs nombre de jours
void lireMois(ifstream &entree, int nbHeure[NBMOIS][NBJOURS])
{
	for (int i = 0; i < NBMOIS; i++)
	{
		for (int j = 0; j < NBJOURS; j++)		// lit le nombre d'heures d'ensoleillement pour chaque jours de chaque mois
		{
			entree >> nbHeure[i][j];
		}
	}
}
// pour calculer le nombre total d'heures d'ensoleillement
void calculerTotalHeure(int totalHeure[NBMOIS], int nbHeure[NBMOIS][NBJOURS])
{
	for (int i = 0; i < NBMOIS; i++)
	{											// calcule le nb d'heure totale par jour pour chaque mois
		for (int j = 0; j < NBJOURS; j++)
		{
			totalHeure[i] += nbHeure[i][j];
		}
	}

}
// calcule la moyenne d'heure d'ensoleillement pour chaque mois
void calculerMoy(float moyenne[NBMOIS], int totalHeure[NBMOIS], int nbJoursParMois[NBMOIS])
{
	for (int i = 0; i < NBMOIS; i++)		// calcule la moyenne pour chaque mois
	{
		moyenne[i] = (float)totalHeure[i] / nbJoursParMois[i];
	}

}
// pour afficher les résultats du total et de la moyenne des heures d'ensoleillement
void afficherResultatMois(ostream &sortie, char nomM[NBMOIS][14], int totalHeure[NBMOIS], float moyenne[NBMOIS])
{
	char nomTemp[14];

	sortie << setw(80) << "Liste des statistiques sur l'ensoleillement" << endl
		   << setw(80) << "*******************************************" << endl << endl
		   << "Heures d'ensoleillement par mois" << endl << endl
		   << setw(22) << "Total" << setw(10) << "Moyenne" << endl;


	for (int i = 0; i < NBMOIS; i++)
	{									// on utilise strcat_s pour s'assurer que les : ne sont pas affectés par le setw
		strcpy_s(nomTemp, nomM[i]);
		strcat_s(nomTemp, " :");
		sortie << left << setw(11) << nomTemp << right << setw(10) << totalHeure[i] << fixed << setprecision(2)
			   << setw(10) << moyenne[i] << endl;
	}
}
// trouve la journée où il y a eu le plus d'heure d'ensoleillement dans l'année
void meilleurJourAnnee(int nbHeure[NBMOIS][NBJOURS], int &meilleurJourDuMois, int &meilleurJour)
{
	int meilleureHeure = 0;
	for (int i = 0; i < NBMOIS; i++)
	{
		for (int j = 0; j < NBJOURS; j++)
		{
			if (meilleureHeure < nbHeure[i][j])		// si la meilleureHeure est plus petite
			{
				meilleureHeure = nbHeure[i][j];
				meilleurJourDuMois = i;				// on remplit les variables meilleurJour avec i et j
				meilleurJour = j;
			}
		}
	}
}
// trouve et retourne le mois avec le plus d'heure d'ensoleillement de l'année
int meilleurMoisAnnee(int totalHeure[NBMOIS])
{
	int tempMois = 0;
	int pos = 0;

	for (int i = 0; i < NBMOIS; i++)
	{
		if (tempMois < totalHeure[i])		// si temp mois est plus petit que le total d'heure d'un des 12 mois
		{
			tempMois = totalHeure[i];		// on prend sa valeur et on retourne sa position
			pos = i;
		}
	}
	return pos;
}
// pour afficher les statistiques d'ensoleillement à l'écran et dans le fichier sortie
void afficherStats(ostream &sortie, char nomMM[14], int totalHeureMM,	int dateMJ, char nomMJ[14], int nbHeureMJ)
{
	sortie << endl << "La meilleure journee de l'annee est le " << dateMJ << " " << char(tolower(nomMJ[dateMJ]))
		   << nomMJ[0] + 1 << endl << "et il y a eu " << nbHeureMJ
		   << " heures d'ensoleillement" << endl << endl;

	sortie << "Le mois de " << char(tolower(nomMM[dateMJ])) << nomMM[0] << " fut le plus ensoleille avec "
		   << totalHeureMM << " heures" << endl << endl;

}
// pour trier les mois en ordre décroissant de leurs heures total d'ensoleillement
void trier6MeilleursMois(int totalHeure[NBMOIS], char nomM[NBMOIS][14])
{
	for (int i = 0; i < NBMOIS - 1; i++)			// on compare les deux premiers nombres
	{
		for (int j = i + 1; j < NBMOIS; j++)		// on compare ensuite le premier avec le troisième et ainsi de suite
		{
			if (totalHeure[i] < totalHeure[j])		// si on i plus grand que j
			{
				swap(totalHeure[i], totalHeure[j]);			// on interchange le total d'heure mais aussi le nom du mois car on trie les 2
				swap(nomM[i], nomM[j]);
			}
		}
	}

}
// pour afficher les 6 meilleurs mois triés
void afficher6MeilleurMois(ostream &sortie, char nomM[NBMOIS][14])
{

	char puces[6][4] = { "1. ", "2. ", "3. ", "4. ", "5. ", "6. " };

	sortie << "Les 6 meilleurs mois d'ensoleillement" << endl;

	for (int i = 0; i < 6; i++)										// affiche seulement 6 mois
	{

		sortie << right << setw(8) << puces[i] << setw(2) << nomM[i] << endl;
	}

}