/***********************************************************************************************
 * Générateur de no 6/49 avec validation
 *********************************************************************************************** 
 * Par:David Bérubé
 * Date 12 juin 2006
 * Réviser le: 9 juillet 2006
 * *********************************************************************************************/ 
using System;

namespace TravailPratique2
{
	class Class1
	{

		static void Main()
		{
			try
			{
				do
				{
					Random rnd = new Random(unchecked((int)DateTime.Now.Ticks)); //initialise un compteur selon le temps
					int[,] tab_nombres = new int[10,6]; // Tableau des combinaisons tirer , 10ligne par 6 colonne
					int[,] tab_gains = new int[10,6]; // Tableau comparaison de tab_nombres
					int[] tab_combine_gagnante = new int[6]; // Tableau pour la combinaison gagnante de 6 chiffres
					int[] tab_extra= new int[11];//Tableau pour les 10combinaisons gagnante , 11 etant celle gagnante
					int[] tab_gains_extra = new int[11]; //Tableau de comparaison de tab_extra
					int[] tab_doublons = new int[50]; //Tableau avec tout les nbr utilisés, pour verif. de doublons
					int nbr_tirage=0; //Nombre de tirage a faire.
					saisir_nbr_tirage(ref nbr_tirage);//Fontion pour determiner le nombre de tirages
					initialiser_table(tab_nombres,nbr_tirage,tab_doublons,ref rnd);//Initialise un tableau multi-dimensionel
					initialiser_table(tab_extra,nbr_tirage,tab_doublons,ref rnd);//Initialise un tableau a une dimension
					trier_tableau(tab_nombres); //Trie d'un tableau multi-dimensionel en ordre croissant
					generer_combine_gagnante(tab_combine_gagnante,tab_doublons,ref rnd); //Genere la combinaison gagnante
					generer_Tab_gains(tab_combine_gagnante,tab_gains,tab_nombres); // Compare deux tableau multi-dimensionel
					generer_Tab_gains(tab_gains_extra,tab_extra); // Compare un tableau a une dimension
					afficher_table(tab_nombres,tab_gains,tab_extra,tab_gains_extra,nbr_tirage,tab_combine_gagnante); //Affichage des resultats et tableau
				}while(recommencer() == 'O');
			}
			catch(Exception){Console.WriteLine("Erreur inatendue");Console.ReadLine();Main();}
		}
		public static void initialiser_table(int[,] tab_nombres,int nbr_tirage,int[] tab_doublons,ref Random rnd)
		{
			//initialise un tableau aleatoire a plusieurs dimensions.
			int colonne,ligne,nbr_rnd;
			colonne=ligne=0;
			for(colonne = 0;colonne < nbr_tirage ;colonne++)
			{
				for(ligne = 0;ligne < tab_nombres.GetLength(1);ligne++)
				{
					nbr_rnd=rnd.Next(49)+1;
					tab_nombres[colonne,ligne]=nbr_rnd; //Assigne le nombre aléatoire
					if(verifier_doublons(tab_doublons,nbr_rnd)==true)
					{
						ligne--;//retourne a la ligne précédente
						continue;//recommence la boucle
					}
				}
				Effacer_Tabdoublons(tab_doublons);
			}
		}
		
		public static void initialiser_table(int[] tab_extra,int nbr_tirage,int[] tab_doublons,ref Random rnd)
		{
		//initialise un tableau aleatoire a une dimension
			int ligne,nbr_rnd;
			ligne=0;
				for(ligne = 0;ligne < tab_extra.Length;ligne++)
				{
					nbr_rnd=rnd.Next(49)+1;
					tab_extra[ligne]=nbr_rnd;//Assigne le nombre aléatoire
					if(ligne == 10) //la combinaison gagnante ne doit pas passer doublon
					break;
						if(verifier_doublons(tab_doublons,nbr_rnd)==true)  // si c'est un doublon
						{
							ligne--; //retourne a la ligne précédente
							continue; //recommence la boucle
						}
				}

				Effacer_Tabdoublons(tab_doublons);
		}

		public static void trier_tableau(int[,] tab_nombres)
		{
			//Trie le tableau en ordre croissant , apelle copier_ligne & trier_ligne
		int[] tab_CloneLigne = new int[tab_nombres.GetLength(1)];
		int ligne,colonne;
		ligne=colonne=0;
			for(colonne = 0;colonne < tab_nombres.GetLength(0);colonne++)
			{
				copier_ligne(ligne,colonne,tab_nombres,tab_CloneLigne);
				trier_ligne(tab_nombres,tab_CloneLigne,ligne,colonne);
			}	
		}
		public static void trier_ligne(int[,] tab_nombres ,int[] tab_CloneLigne,int ligne,int colonne)
		{
			//Trie une ligne , d'une copie de tableau
			Array.Sort(tab_CloneLigne);

				for(ligne = 0;ligne < tab_nombres.GetLength(1);ligne++)
				{
					tab_nombres[colonne,ligne]=tab_CloneLigne[ligne];
				}	
		}
		public static void copier_ligne(int ligne,int colonne,int[,] tab_nombres,int[] tab_CloneLigne)
		{
			//Copie une ligne dun tableau multi-dimensionel vers un tableau a une seule dimension , pour triage.
			for(int ind=0;ind<tab_CloneLigne.Length;ind++)
			{
				tab_CloneLigne[ind] = tab_nombres[colonne,ind];
			}
		}
		public static void Effacer_Tabdoublons(int[] tab_doublons)
		{
			//Initialise un tableau
			int ind;
			for(ind=0;ind<tab_doublons.Length;ind++)
			{
					tab_doublons[ind] = 0;
			}
		}
		public static bool verifier_doublons(int[] tab_doublons,int nbr_rnd)
		{
			//Verifie si un nombre a deja ete tirer , si c'est le cas il retourne vrai
			//sinon , le tab_doublons a l'indice du nombre tirer , prend la valeur 1
			bool reponse;
			if(tab_doublons[nbr_rnd] == 1)
			{
				reponse=true;
			}
				else 
				{
					reponse = false;
					tab_doublons[nbr_rnd] = 1;
				}
			return reponse;
		}
		public static void generer_combine_gagnante(int[] tab_combine_gagnante,int[] tab_doublons,ref Random rnd)
		{
			//Genere la combinaison gagnante de 6 chiffres.
			int ind=0;
			for(ind=0;ind<tab_combine_gagnante.Length;ind++)
			{
				tab_combine_gagnante[ind]=rnd.Next(49)+1;
			}
			Array.Sort(tab_combine_gagnante);
		}
		public static void saisir_nbr_tirage(ref int nbr_tirage)
		{
			//Demande a l'utilisateurs le nombre de tirages a effectuer.
				do
				{
					Console.WriteLine("Combien de combinaisons a tirer (1-10)?");
					nbr_tirage=int.Parse(Console.ReadLine());
				}while(nbr_tirage < 0 || nbr_tirage > 10);
		}
		public static void generer_Tab_gains(int[] tab_combine_gagnante,int[,] tab_gains,int[,] tab_nombres)
		{
			//Génère le tableau des combinaisons a tirer
			int colonne,ligne,ind;
			colonne=ligne=ind=0;
			for(colonne = 0;colonne < tab_nombres.GetLength(0);colonne++)
			{
				for(ligne = 0;ligne < tab_nombres.GetLength(1);ligne++)
				{
					for(ind=0;ind<tab_combine_gagnante.Length;ind++)
					{
						if(tab_nombres[colonne,ligne] == tab_combine_gagnante[ind])
							tab_gains[colonne,ligne] = 1;	
					}
				}
			}
		}
		public static void generer_Tab_gains(int[] tab_gains_extra,int[] tab_extra)
		{
			//Génère le tableau des combinaisons gagnantes				
			int ind;
			ind=0;

			for(ind=0;ind<tab_extra.Length;ind++)
			{
				if(tab_extra[ind] == tab_extra[tab_extra.Length-1])
					tab_gains_extra[ind] = 1;	
			}

		}
		public static void afficher_table(int[,] tab_nombres,int[,] tab_gains,int[] tab_extra,int[] tab_gains_extra,int nbr_tirage,int[] tab_combine_gagnante)
		{
			//Fonction d'affichage.
			int colonne,ligne;
			colonne=ligne=0;
			Console.Write("#########################################################\n");
			Console.Write("# 1\t 2\t 3\t 4\t 5\t 6\tExtra   #\n");
			Console.Write("#########################################################\n");
			for(colonne = 0;colonne < nbr_tirage ;colonne++)
			{
				Console.Write("#");
				for(ligne = 0;ligne < tab_nombres.GetLength(1);ligne++)
				{
					Console.Write("{0,2}\t",tab_nombres[colonne,ligne]);				
				}
					Console.Write("{0}\t",tab_extra[colonne]);
				Console.Write("#");
				Console.Write("\n");
			}
			Console.Write("#########################################################\n");
			int ind=0;
			Console.Write("#");
			for(ind=0;ind<tab_combine_gagnante.Length;ind++)
			{
				Console.Write("{0,2}\t",tab_combine_gagnante[ind]);
			}
			Console.Write("{0,2}\t",tab_extra[tab_extra.Length-1]);

			Console.Write("#\n");
			Console.Write("#########################################################\n");
			/* Tableau pour le debug
			 * affiche la table des gains pour tab_gains[]
			Console.Write("#########################################################\n");
			Console.Write("# 1\t 2\t 3\t 4\t 5\t 6\tExtra   #\n");
			Console.Write("#########################################################\n");
			for(colonne = 0;colonne < nbr_tirage ;colonne++)
			{
				Console.Write("#");
				for(ligne = 0;ligne < tab_gains.GetLength(1);ligne++)
				{
					Console.Write("{0,2}\t",tab_gains[colonne,ligne]);				
				}
				Console.Write("#");
				Console.Write("\n");
			}
			Console.Write("#########################################################\n");
			*/
			Resultat_stats(tab_gains,tab_gains_extra,nbr_tirage); //Apelle resultat_stats
		}
		public static void Resultat_stats(int[,] tab_gains,int[] tab_gains_extra,int nbr_tirage)
		{
			int addition,colonne,ligne;// Affiche les gains
			ligne=addition=colonne=0;
			for(colonne = 0;colonne < tab_gains.GetLength(0) ;colonne++)
			{
				for(ligne = 0;ligne < tab_gains.GetLength(1);ligne++)
				{
					addition += tab_gains[colonne,ligne];
				}
				if(nbr_tirage == colonne)break;
				Console.Write("\n");
				Console.Write("ligne{0}: {1} de 6 + {2}\t",colonne+1,addition,tab_gains_extra[colonne]);
				addition = 0;
			}
			Console.Write("\n");
		}
		public static char recommencer()
		{//Fonction qui demande a l'utilisateur s'il veu recomencer ou terminer.
			char recommence;
			do
			{
				Console.Write("Voulez vous recommencer ? (O/N):");
				recommence = Char.ToUpper(Char.Parse(Console.ReadLine()));
			}while(recommence != 'O' && recommence != 'N');
			return recommence;
		}
	}
}