package fr.blankoworld.plateau;

import java.util.Vector;

/**
 * @author Olivier DOSSMANN
 *
 */
/**
 * Classe plateau qui permet de creer un plateau de jeu
 */
public class PlateauPuissance4 {

	private Jeton[][] grille;
	private int[] positions;
	private boolean alternanceJoueur = true;
	private Joueurs j1;
	private Joueurs j2;
	private Joueurs j0;
	private Vector CollectionJoueurs;
	
	public int nbreColonnes = 7;
	public int nbreLignes = 6;
	
/**
 * 
 * @param args - Arguments passes en parametre
 */
/**
 * Methode principale MAIN
 */
	public static void main(String args[]){
//		System.out.println("Bienvenue dans Blankuissance4, le nouveau jeu fecal de puissance 4 !");
		
		// Instanciation de l'objet a partir de la classe PlateauPuissance4
		PlateauPuissance4 p4 = new PlateauPuissance4();
		
		p4.lancer();
	}

	/**
	 * Initialisation des variables, des joueurs, de la grille, etc ...
	 *
	 */
	public void initialiser()
	{
		// Initialisation des joueurs
		j1 = new Joueurs("Joueur Un", "R");
		j2 = new Joueurs("Joueur Deux", "J");
		j0 = new Joueurs("Joueur inexistant", " ");
		
		// On remplit la collection de joueurs
		CollectionJoueurs = new Vector();
		CollectionJoueurs.add(j0);
		CollectionJoueurs.add(j1);
		CollectionJoueurs.add(j2);
		
		// Creation de la grille
		grille = new Jeton[nbreColonnes][nbreLignes];
		
		// Creation tu tableau de positionnement
		positions = new int[7];
		
		// Initialisation du tableau
		for (int i = 0; i < nbreColonnes; i++){
			for(int j = 0; j < nbreLignes; j++){
				grille[i][j] = j0.donneJeton();
			}
		}
		
		// Initialisation des positions
		for (int i = 0; i < nbreColonnes; i++){
			positions[i] = 0;
		}
	}
	
	/**
	 * Permet de relancer le jeu (prevu pour l'ajout supplementaire d'un menu)
	 *
	 */
	public void reinitialiser(){
		lancer();
	}
	
	/**
	 * Affiche la grille de jeu
	 *
	 */
	public void afficherGrille(){
		for (int i = nbreLignes - 1; i >= 0; i--){
			for(int j = 0; j < nbreColonnes; j++){
				System.out.print(grille[j][i].getCouleur() + "|");
			}
			System.out.print("\n");
		}
		for (int k = 0; k < nbreColonnes; k++){
			System.out.print("--");
		}
		System.out.print("\n");
		
		for (int l = 0; l < nbreColonnes; l++){
			System.out.print(Integer.toString(l + 1) + "|");
		}
		System.out.print("\n");
	}
	
	/**
	 * C'est ici que le jeu se deroule, que les appels sont faits, etc ...
	 * Tout est la !
	 *
	 */
	public void lancer(){
		System.out.println("Lancement du jeu de plateau");
		
		// Initialisation du plateau
		this.initialiser();
		
		// Affichage du plateau pour verification
		this.afficherGrille();
		
		// Creation d'une aide pour les entrees de l'utilisateur
		AideSaisie aide = new AideSaisie();
		
		// Affichage des joueurs
		System.out.println("Affichage des deux joueurs : ");
		System.out.println(" - " + j1.toString() + ".");
		System.out.println(" - " + j2.toString() + ".");
		
		// Creation d'un joueur generique
		Joueurs joueur = new Joueurs("joueur de base", " ");
		
		// Numero de colonne choisi
		int colonne = 0;
		
		// incrementeur de jetons
		int i = 0;
		
		// Contrele d'entree de boucle
		boolean aGagne = false;
		
		while (aGagne == false && i < (nbreColonnes * nbreLignes))
		{

			// Methode pour alterner de joueur : entre le joueur Un et le joueur Deux
			joueur = alterneJoueur(j1,j2);
			
			boolean ok = true;
			// Recuperation de la proposition de colonne de l'utilisateur
			while(ok){
				String proposition = aide.getEntreeUtilisateur("Colonne (entre 1 et " + nbreColonnes + ") : ");
				System.out.println("Colonne choisie par " + joueur.getNom() + " : " + proposition);
				
				// Traduction en entier du numero de colonne
				if (proposition == null){
					colonne = nbreColonnes;
				}
				else{
					colonne = Integer.parseInt(proposition);
					
					// Mise a niveau de la colonne vis a vis de la structure Java
					colonne --;
				}
				
				// Verification que la colonne n'est pas pleine ou hors limite
				if (colonne > nbreColonnes - 1 || colonne < 0){
					ok = true;
					System.out.println("Hors limites !");
				}
				else if (!grille[colonne][5].getCouleur().equals(" ")){
					ok = true;
					System.out.println("Colonne a ras bord !");
				}
				else{
					ok = false;
					System.out.println("Longueur du tableau : " + grille[colonne].length);
					
					// Si colonne pas pleine, verifier a quel position les pions precedents sont poses
					// Si aucun pion, alors poser tout en bas
					
					this.ajoutPion(colonne, joueur.donneJeton().getCouleur());
					this.afficherGrille();
				}
			}
			
			// Il faut minimum 7 pions poses, avant de savoir si le joueur a gagne ou pas
			// Comme nous commencons a 0 l'incr�menteur (7 - 1 = 6), et que le jeton actuel 
			// n'est pas encore compte (6 - 1 = 5),
			//  alors on met la valeur a 5. C'est a dire que nous aurons deja i a 7 au minimum quand on fera
			//  ce test, et que nous serons dans le cas du 8i�me jeton.
			if (i > 5){
				
				// Verification si le joueur gagne
				//	On decremente de 1 positions[colonne] car nous y avons ajoute 1 pour le pion suivant
				aGagne = gagnant(colonne, positions[colonne] - 1);
			}
			
			// Instanciation de i pour confirmer que le coup est lance
			i++;
			// Idem mais alternance du joueur
			alternanceJoueur = !alternanceJoueur;
			System.out.println("Coup numero " + i + " joue !");
			System.out.print("\n");
		}
	
		if (i < (nbreColonnes * nbreLignes)){
			System.out.println(joueur.getNom() + " a gagne !");
			System.out.println("Merci au joueur de l'autre equipe d'avoir participe.");
		}
		else{
			System.out.println("Jeu termine, aucun gagnant !");
			System.out.println("Merci d'avoir joue.");
		}
	}
	
	/**
	 * 
	 * @param jUn - Joueur Un
	 * @param jDeux - Joueur Deux
	 * @return Joueur qui dois jouer
	 */
	/**
	 * On recupere le joueur qui doit jouer
	 */
	public Joueurs alterneJoueur(Joueurs jUn, Joueurs jDeux){
		
		if (alternanceJoueur){
			return jUn;
		}
		else{
			return jDeux;
		}
	}
	
	/**
	 * 
	 * @param positionColonne - Position de la colonne choisie
	 * @param couleur - Couleur du pion pose
	 */
	/**
	 * Ajoute un pion dans la colonne choisie en donnant la couleur dudit pion
	 */
	public void ajoutPion(int positionColonne, String couleur){
		Jeton nouveauPion = new Jeton(couleur);
		int positionJeton = positions[positionColonne];
		
		grille[positionColonne][positionJeton] = nouveauPion;
		positions[positionColonne] ++;
	}
	
	/**
	 * 
	 * @param colonneChoisie - Colonne que l'utilisateur a choisi
	 * @param positionPion - Position du pion dans ladite colonne
	 * @return Avons nous un gagnant ? Oui ou non ?
	 */
	/**
	 * Determine si le pion pose donne un jeu gagnant au joueur qui l'a pose ou pas
	 */
	public boolean gagnant(int colonneChoisie, int positionPion){
		
		// Entier qui permet de definir le nombre de puissance 4 effectues
		int puissance4 = 1;
		
		puissance4 = estAligne(2,0,colonneChoisie,positionPion) + estAligne(1,0,colonneChoisie,positionPion) + 1;
		if( puissance4 < 4){
			//System.out.println(puissance4);
			puissance4 = estAligne(0,2,colonneChoisie,positionPion) + estAligne(0,1,colonneChoisie,positionPion) + 1;
			if(puissance4 < 4){
				//System.out.println(puissance4);
				puissance4 = estAligne(2,2,colonneChoisie,positionPion) + estAligne(1,1,colonneChoisie,positionPion) + 1;
				if(puissance4 < 4){
					//System.out.println(puissance4);
					puissance4 = estAligne(1,2,colonneChoisie,positionPion) + estAligne(2,1,colonneChoisie,positionPion) + 1;
					if(puissance4 < 4){
						//System.out.println(puissance4);
						return false;
					}
					else return true;
				}
				else return true;
			}
			else return true;
		}
		else return true;
	}
	
	/**
	 * 
	 * @param X - Valeur 0,1 ou 2. Avec 1 nous incrementons, avec 2 l'inverse, et avec 0 nous ne faisons rien
	 * @param Y - Idem que X
	 * @param colonneChoisie - Colonne de laquelle nous partons
	 * @param positionPion - position du pion de lequel nous partons
	 * @return Avons nous une ligne de puissance 4 ? Combien de pions alors ?
	 */
	/**
	 * Renvoie le nombre de pions de meme couleur alignes
	 */
	public int estAligne(int X, int Y, int colonneChoisie, int positionPion){
		int puissance4 = 0;
		boolean ok = true;
		int colonneTestee = colonneChoisie, ligneTestee = positionPion;

		// Verification à l'écran que nous nous trouvons au bon endroit
		//System.out.println("X: " + X + " Y: " + Y + " Colonne choisie: " + colonneChoisie + " Position choisie: " + positionPion);
		
		if(Y == 1){
			colonneTestee++;
		}
		else if(Y == 2){
			colonneTestee--;
		}
		else{
			// Rien
		}
		if(X == 1){
			ligneTestee++;
		}
		else if(X == 2){
			ligneTestee--;
		}
		else{
			// Rien
		}
		
		if(colonneTestee < 0 || colonneTestee > nbreColonnes - 1){
			ok = false;
		}
		if(ligneTestee < 0 || ligneTestee > nbreLignes - 1){
			ok = false;
		}
		
		//System.out.println("Debut des tests : " + ligneTestee);
		while(ok == true && grille[colonneTestee][ligneTestee].getCouleur().equals(grille[colonneChoisie][positionPion].getCouleur())){
			puissance4++;
			if(Y == 1){
				colonneTestee++;
			}
			else if(Y == 2){
				colonneTestee--;
			}
			else{
				// Rien
			}
			if(X == 1){
				ligneTestee++;
			}
			else if(X == 2){
				ligneTestee--;
			}
			else{
				// Rien
			}
			//System.out.println("Colonne : " + colonneTestee + ". Ligne : " + ligneTestee);
			if(colonneTestee < 0 || colonneTestee > nbreColonnes - 1){
				ok = false;
			}
			if(ligneTestee < 0 || ligneTestee > nbreLignes - 1){
				ok = false;
			}
		}
		
		return puissance4;
	}
	
	/**
	 * 
	 * @param colonne - Colonne choisise
	 * @return Position du pion dans la colonne
	 */
	/**
	 * Permet de recuperer la position du pion dans une colonne donnee
	 */
	public int getPosition(int colonne)
	{
		return positions[colonne];
	}
	
	/**
	 * 
	 * @return Collection de joueurs
	 */
	/**
	 * On recupere une collection de joueurs sous forme de Vecteurs
	 */
	public Vector getJoueurs(){
		return CollectionJoueurs;
	}
	
	/**
	 * Affirme que nous changeons de joueurs (ce qui n'inclue pas le fait que nous ayons a le recuperer !)
	 *
	 */
	public void setAlternanceJoueur(){
		alternanceJoueur = !alternanceJoueur;
	}
}