using System;

namespace mm
{
	class MainClass
	{
		/* Retourne une combinaison aléatoire de nbChiffres compris 
		 * entre 1 et chiffreMax
		 * */
		
		public static int[] creerCombinaison(int nbChiffres, int chiffreMax, 
		                                     bool doublonsAutorises)
		{
			if (!doublonsAutorises && nbChiffres > chiffreMax)
			{
				Console.WriteLine("Impossible de créer la combinaison, " + 
				                  "le nombre de chiffres ne peut être supérieur au chiffre " +
				                  "max que si les doublons sont autorises.");
				Environment.Exit(0);
			}			
			int[] combinaison = new int[nbChiffres];
			bool [] numerosSortis = new bool[chiffreMax];
			if (!doublonsAutorises)
				for (int i = 0 ; i < chiffreMax ; i++)
					numerosSortis[i] = false;
			Random r = new Random();			
			for (int i = 0 ; i < nbChiffres ; i++)
			{
				do
				{
					combinaison[i] = r.Next()%chiffreMax + 1;					
				}
				while(!doublonsAutorises && numerosSortis[combinaison[i] - 1]);
				numerosSortis[combinaison[i] - 1] = true;
			}
			return combinaison;
		}		

		/*
		 * Retourne vrai ssi pour tout i, 1 <= t[i] <= chiffreMax
		 * */
		
		public static bool infChiffreMax(int [] t, int chiffreMax)
		{
			foreach(int v in t)
				if(v <= 0 || v > chiffreMax)
					return false;
			return true;
		}
		
		/*
		 * retourne un tableau contenant les nbChiffres saisis dans la chaîne s
		 * la chaîne s doit contenir les chiffres de la combinaison séparés par 
		 * des espaces. Retourne null si le tableau est impossible à parser.
		 * */
	
		public static int[] parseCombinaison(string s, int nbChiffres)
		{
			int[] t = new int[nbChiffres];
			int indiceS = 0;
			int indiceT = 0;
			int n = s.Length;
			while(indiceS < n && indiceT < nbChiffres)
			{
				if (s[indiceS] == ' ')
					indiceT++;
				else
					t[indiceT] = t[indiceT]*10 + (int)(s[indiceS] - '0');
				indiceS++;
			}
			if (indiceT == nbChiffres-1 && indiceS == n)
				return t;
			else
			{
				Console.WriteLine("Le nombre de valeurs saisies ne correspond pas.");
				return null;
			}
		}

		/*
		 * Retourne le nombre de chiffres identiques dans les deux tableaux
		 * ne compare que les valeurs de même indice, les deux tableaux 
		 * doivent être de même longueur.
		 * */
		
		public static int calculeBienPlaces(int[] a, int[] b)
		{
			int n = a.Length;
			int resultat = 0;
			for (int i = 0 ; i < n ; i++)
				if (a[i] == b[i])
					resultat++;
			return resultat;
		}
		
		/*
		 * Retourne un tableau x de chiffreMax éléments tel que x[i] est 
		 * le nombre d'occurrences de i dans t.
		*/
		
		public static int[] nbOccurrences(int[] t, int chiffreMax)
		{
			int[] x = new int[chiffreMax];
			int n = t.Length;
			for (int i = 0 ; i<n ; i++)
				x[t[i] - 1]++;
			return x;
		}
		
		/*
		 * Retourne le plus petit de ses arguments.
		 * */
		
		public static int min(int a, int b)
		{
			return (a < b) ? a : b;
		}
		
		/*
		 * Retourne un tableau t tq t[i] = min(a[i], b[i])
		 * a et b doivent être de même longueur.
		 * */
		
		public static int[] min(int[] a, int[] b)
		{
			int n  = a.Length;
			int[] res = new int[n];
			for (int i = 0 ; i < n ; i++)
				res[i] = min(a[i], b[i]);
			return res;
		}
		
		/*
		 * Retourne le nombre d'élements mal positionnés dans la combinaison. 
		 * Soit a et b les deux combinaisons à comparer, tabMin[x] doit être le nombre 
		 * d'occurrences de x présentes dans les deux tableaux à la fois.
		 * */
		
		public static int calculeMalPlaces(int[] tabMin, int bienPlaces)
		{
			int somme = 0;
			foreach(int v in tabMin)
				somme += v;
			return somme - bienPlaces;
		}
		
		/*
		 * Demande à l'utilisateur de saisir une combinaison de nbChiffres compris entre 1 et chiffreMax
		 * au format chaîne de caractère,
		 * contrôle la saisie et retourne un tableau contenant les éléments saisis.
		 * */
		
		public static int[] saisitCombinaison(int nbChiffres, int chiffreMax)
		{
			int[] combiSaisie;
			do
			{
				Console.Write("Saisissez les " + nbChiffres + " chiffres de la combinaison (entre "
				                  + "1 et " + chiffreMax + ") : ");
				string buffer = Console.ReadLine();
				combiSaisie = parseCombinaison(buffer, nbChiffres);
				if (combiSaisie != null
				    && !infChiffreMax(combiSaisie, chiffreMax))
				{
					Console.WriteLine("Erreur de saisie, toutes les valeurs doivent être comprises entre "
				                  + "1 et " + chiffreMax + " .");
					combiSaisie = null;
				}				
			}
			while(combiSaisie == null);
			return combiSaisie;
		}
		

		/*
		 * Affiche la combinaison. Ne revient pas à la ligne.
		 * */
		
		public static void afficheCombinaison(int[] combinaison)
		{	
			foreach (int e in combinaison)
				Console.Write(e + " ");			
		}

		/*
		 * Affiche un tableau récapitulatif des combinaisons précédentes.
		 * tour est le nombre de tours déjà effectués.
		 * combinaisons[i] contient la combinaison saisie par l'utilisateur au tour i.
		 * bienPlaces[i] est le nombre d'éléments bien placés dans combinaisons[i]
		 * malPlaces[i] est le nombre d'éléments mal placés dans combinaisons[i]
		 * */
		
		public static void afficheCombinaisonsPrecedentes(int[][] combinaisons, 
		                                                  int[] bienPlaces, int[] malPlaces, int tour)
		{
			Console.Clear();
			for(int i = 0 ; i <= tour ; i++)				
			{
				Console.Write(i+	1 + " | ");
				int[] combinaison = combinaisons[i];
				afficheCombinaison(combinaison);
				Console.Write("| bien placé" + 
				              ((bienPlaces[i] == 1) ? "" : "s") + " : " + bienPlaces[i]);
				Console.WriteLine(", mal placé" + 
				              ((malPlaces[i] == 1) ? "" : "s") + " : " + malPlaces[i]);
			}
		}		
		
		/*
		 * Fin d'une partie, affiche la réponse à l'utilisateur s'il a perdu.
		 */
		
		public static void afficheResultat(int[] combinaison, bool gagne)
		{
			if (gagne)
				Console.WriteLine("Bravo, vous avez trouvé la combinaison.");
			else
			{
				Console.WriteLine("Hélas, vous vous êtes planté... La solution était : ");
				afficheCombinaison(combinaison);
				Console.WriteLine();
			}
		}
		
		/*
		 * Lance une partie.
		 * nbChiffres est la taille de la combinaison à trouver
		 * ChiffreMax est le nombre le plus grand de la combinaison
		 * nbTour est le nombre d'essais laissés à l'utilisateur.
		 */
		
		public static void tousLesTours(int nbChiffres, int chiffreMax, 
		                                int nbTours, bool doublonsAutorises)
		{
			int[][] combinaisons = new int[nbTours][];
			int tour = 0;
			int[] combinaison = creerCombinaison(nbChiffres, chiffreMax, doublonsAutorises);
			int[] bienPlaces = new int[nbTours];
			int[] malPlaces = new int[nbTours];
			int[] occurrencesCombi = nbOccurrences(combinaison, chiffreMax);
			bool gagne = false;
			Console.Clear();
			do
			{
				combinaisons[tour] = saisitCombinaison(nbChiffres, chiffreMax);				
				bienPlaces[tour] = calculeBienPlaces(combinaisons[tour], combinaison);
				int[] occurrencesSaisie = nbOccurrences(combinaisons[tour], chiffreMax);
				int[] tabMin = min(occurrencesCombi, occurrencesSaisie);
				malPlaces[tour] = calculeMalPlaces(tabMin, bienPlaces[tour]);
				gagne = bienPlaces[tour] == nbChiffres;
				afficheCombinaisonsPrecedentes(combinaisons, bienPlaces, malPlaces, tour);
				tour ++;
			}
			while(tour < nbTours && !gagne);
			afficheResultat(combinaison, gagne);
		}
		
		/*
		 * Initialise les paramètres et lance une ou plusieurs parties.
		 * */
		
		public static void menuPrincipal()
		{
			bool doublonsAutorises = true;
			int nbChiffres = 4;
			int chiffreMax = 5;
			int nbTours = 10;
			string rejouer;
			do 
			{
				tousLesTours(nbChiffres, chiffreMax, nbTours, doublonsAutorises);
				Console.WriteLine("Voulez-vous rejouer ? (o/n)");
				rejouer = Console.ReadLine();	
			}
			while(rejouer != "n");
		}
		
		public static void Main (string[] args)
		{
			menuPrincipal();
		}
	}
}