package piecesEchiquier;
//voir equalsIgnoreCase
import joueurs.Joueur;

public class Echiquier {
	
	//ATTRIBUTS
	private String[][] codes = //pour définir quel code correspond a quel case
{ 
	{"a8","b8","c8","d8","e8","f8","g8","h8"},
	{"a7","b7","c7","d7","e7","f7","g7","h7"},
	{"a6","b6","c6","d6","e6","f6","g6","h6"},
	{"a5","b5","c5","d5","e5","f5","g5","h5"},
	{"a4","b4","c4","d4","e4","f4","g4","h4"},
	{"a3","b3","c3","d3","e3","f3","g3","h3"},
	{"a2","b2","c2","d2","e2","f2","g2","h2"},
	{"a1","b1","c1","d1","e1","f1","g1","h1"}
};

	//declaration de toutes les pieces de l'echiquier
	private Pion pionB1 = new Pion("Blanc","PB",new Position(1,2));
	private Pion pionB2 = new Pion("Blanc","PB",new Position(2,2));
	private Pion pionB3 = new Pion("Blanc","PB",new Position(3,2));
	private Pion pionB4 = new Pion("Blanc","PB",new Position(4,2));
	private Pion pionB5 = new Pion("Blanc","PB",new Position(5,2));
	private Pion pionB6 = new Pion("Blanc","PB",new Position(6,2));
	private Pion pionB7 = new Pion("Blanc","PB",new Position(7,2));
	private Pion pionB8 = new Pion("Blanc","PB",new Position(8,2));
	
	private Pion pionN1 = new Pion("Noir","PN",new Position(1,7));
	private Pion pionN2 = new Pion("Noir","PN",new Position(2,7));
	private Pion pionN3 = new Pion("Noir","PN",new Position(3,7));
	private Pion pionN4 = new Pion("Noir","PN",new Position(4,7));
	private Pion pionN5 = new Pion("Noir","PN",new Position(5,7));
	private Pion pionN6 = new Pion("Noir","PN",new Position(6,7));
	private Pion pionN7 = new Pion("Noir","PN",new Position(7,7));
	private Pion pionN8 = new Pion("Noir","PN",new Position(8,7));
	
	private Tour TourB1 = new Tour("Blanc","TB",new Position(1,1));
	private Tour TourB2 = new Tour("Blanc","TB",new Position(8,1));
	private Tour TourN1 = new Tour("Noir","TN",new Position(1,8));
	private Tour TourN2 = new Tour("Noir","TN",new Position(8,8));
	
	private Cavalier CavalierB1 = new Cavalier("Blanc","CB",new Position(2,1));
	private Cavalier CavalierB2 = new Cavalier("Blanc","CB",new Position(7,1));
	private Cavalier CavalierN1 = new Cavalier("Noir","CN",new Position(2,8));
	private Cavalier CavalierN2 = new Cavalier("Noir","CN",new Position(7,8));
	
	private Fou FouB1 = new Fou("Blanc","FB",new Position(3,1));
	private Fou FouB2 = new Fou("Blanc","FB",new Position(6,1));
	private Fou FouN1 = new Fou("Noir","FN",new Position(3,8));
	private Fou FouN2 = new Fou("Noir","FN",new Position(6,8));
	
	private Reine ReineB1 = new Reine("Blanc","QB",new Position(4,1));
	private Reine ReineN1 = new Reine("Noir","QN",new Position(4,8));
	
	private Roi RoiB1 = new Roi("Blanc","KB",new Position(5,1));
	private Roi RoiN1 = new Roi("Noir","KN",new Position(5,8));
	
	//remplissage de l'echiquier
	private Piece[][] echiquier = 
		{
			{TourN1,CavalierN1,FouN1,ReineN1,RoiN1,FouN2,CavalierN2,TourN2},
			{pionN1,pionN2,pionN3,pionN4,pionN5,pionN6,pionN7,pionN8},
			{new Piece(new Position(1,6)),new Piece(new Position(2,6)),new Piece(new Position(3,6)),new Piece(new Position(4,6)),new Piece(new Position(5,6)),new Piece(new Position(6,6)),new Piece(new Position(7,6)),new Piece(new Position(8,6))},
			{new Piece(new Position(1,5)),new Piece(new Position(2,5)),new Piece(new Position(3,5)),new Piece(new Position(4,5)),new Piece(new Position(5,5)),new Piece(new Position(6,5)),new Piece(new Position(7,5)),new Piece(new Position(8,5))},
			{new Piece(new Position(1,4)),new Piece(new Position(2,4)),new Piece(new Position(3,4)),new Piece(new Position(4,4)),new Piece(new Position(5,4)),new Piece(new Position(6,4)),new Piece(new Position(7,4)),new Piece(new Position(8,4))},
			{new Piece(new Position(1,3)),new Piece(new Position(2,3)),new Piece(new Position(3,3)),new Piece(new Position(4,3)),new Piece(new Position(5,3)),new Piece(new Position(6,3)),new Piece(new Position(7,3)),new Piece(new Position(8,3))},
			{pionB1,pionB2,pionB3,pionB4,pionB5,pionB6,pionB7,pionB8},
			{TourB1,CavalierB1,FouB1,ReineB1,RoiB1,FouB2,CavalierB2,TourB2}
		};
	
	//CONSTRUCTEURS
	public Echiquier() {
	
	}

	public String toString()	// FONCTION AFFICHAGE
	{
		char alphabet[]= {'A','B','C','D','E','F','G','H'};
		String echec = "";
		int compteur=8;
		for (int i = 0; i < 8;i++) //pour chaque ligne
		{
			echec+= compteur + " "; //afichage num ligne
			for (int j = 0; j < 8;j++) //pour chaque colonne
			{
				echec +=echiquier[i][j].getNom();
				echec += " ";
			}
			echec += "\n";
			compteur--;
		}
		for (int i=0; i<8;i++)
		{
			echec+= "  " + alphabet[i]; //affichage des lettres
		}
		return echec;
	}
	
	public boolean verificationMouvement(Joueur J, String A, String B)	// FONCTION TRADUCTION, VERIF + DEPLACEMENTS SI POSSIBLE
	{// String A = coordonées de A; String B = coordonées de B 
		A.toLowerCase();
		B.toLowerCase();
		
		int i = -1;
		int j = -1;
		int k;
		int l;
		Position stock;
		Position stock2;
		
		/// TEST 1ERE SOURCE
		do {  							
			i++;
			j = -1;
			
			
			do {
				j++;
				if (getCodes()[i][j].equals(A))		//Si la coors entré est un code possible
				{
					if (this.getEchiquier()[i][j].getNom().equalsIgnoreCase("..")) // Verifie si la case choisie n'est pas vide
					{
						System.err.println("Vous avez choisi une case vide. Recommencez.");
						return false;
					}
					else if (this.getEchiquier()[i][j].getCouleur() != J.getCouleur()) // Verifie si la piece choisie n'est pas de la faction opposée
					{
						System.err.println("Le pion choisi n'est pas de votre faction. Recommencez !");
						return false;
					}	
				}
			}while(( (getCodes()[i][j].equalsIgnoreCase(A)) == false) && (j+1 < codes.length));
		}while((getCodes()[i][j].equalsIgnoreCase(A) == false) && (i+1 < codes.length));
		
		/// TEST 2EME DESTINATION
		for (k = 0; k < codes.length;k++)	
		{
			for (l = 0; l < codes.length;l++) 
			{
				if (getCodes()[k][l].equalsIgnoreCase(B) == true)
				{
					if (this.getEchiquier()[k][l].getCouleur() == J.getCouleur())  // Verifie si la  piece visée est de ta faction
					{
						System.err.println("Le pion que vous voulez manger est de votre faction. Recommencez !");
						return false;
					}
					
					if(this.getEchiquier()[i][j].getNom() == "KB" || this.getEchiquier()[i][j].getNom() == "KN") //test si le roi ne se colle pas à un autre roi
						{
							if (this.getEchiquier()[i][j].getNom() == "KB")
							{
								if(!(this.getEchiquier()[k+1][l].getPosition().getX()>7 ||this.getEchiquier()[k][l+1].getPosition().getY()>7 ||this.getEchiquier()[k-1][l].getPosition().getX()<0
										||this.getEchiquier()[k][l-1].getPosition().getY()<0))//test le cas ou le roi se deplace sur une bordure
								{
								if(this.getEchiquier()[k][l+1].getNom() == "KN" || this.getEchiquier()[k+1][l+1].getNom()=="KN" 
										|| this.getEchiquier()[k-1][l+1].getNom()== "KN" || this.getEchiquier()[k-1][l].getNom()== "KN" || this.getEchiquier()[k+1][l].getNom()== "KN" 
										|| this.getEchiquier()[k-1][l-1].getNom()== "KN" || this.getEchiquier()[k][l-1].getNom()== "KN" || this.getEchiquier()[k+1][l-1].getNom()== "KN")
								{
									System.err.println("Le roi ne peut pas se coller à l'autre roi");
									return false;
								}
								}
							}
							if (this.getEchiquier()[i][j].getNom() == "KN")
							{
								if(!(this.getEchiquier()[k+1][l].getPosition().getX()>7 ||this.getEchiquier()[k][l+1].getPosition().getY()>7 ||this.getEchiquier()[k-1][l].getPosition().getX()<0
										||this.getEchiquier()[k][l-1].getPosition().getY()<0))//test le cas ou le roi se deplace sur une bordure
								{
								if(this.getEchiquier()[k][l+1].getNom() == "KB" || this.getEchiquier()[k+1][l+1].getNom()=="KB" 
										|| this.getEchiquier()[k-1][l+1].getNom()== "KB" || this.getEchiquier()[k-1][l].getNom()== "KB" || this.getEchiquier()[k+1][l].getNom()== "KB" 
										|| this.getEchiquier()[k-1][l-1].getNom()== "KB" || this.getEchiquier()[k][l-1].getNom()== "KB" || this.getEchiquier()[k+1][l-1].getNom()== "KB")
								{
									System.err.println("Le roi ne peut pas se coller à l'autre roi");
									return false;
								}
							}
							}
						}
					 if (this.getEchiquier()[i][j].deplacable(this,this.getEchiquier()[k][l]) == false) // VERIFICATION AVEC FONCTION DEPLACABLE
					{
						System.err.println("Déplacement impossible. Recommencez ! \n");
						return false;
					}
					
					
					else //PARTIE DEPLACEMENT DE LA PIECE
					{
					System.out.println("Choix validé ! Déplacement en cours.");
					stock = new Position(l+1,8-k); //stockage de la pos destination
					stock2 = new Position(j+1,8-i); //stockage de la pos source 
					this.getEchiquier()[k][l] = this.getEchiquier()[i][j]; //deplacement de la piece
					this.getEchiquier()[k][l].setPosition(stock); //donner nouvelle position a la piece déplacer
					this.getEchiquier()[i][j] = new Piece(stock2); //mettre piece vide dans la pos source, car la case est maintenant vide
					int p; 
					int q; 
					Piece stockageRoi=null;				
					if( this.getEchiquier( )[k][l].getCouleur().equals("Blanc") ) {  
						for ( p=0; p < codes.length;p++)            //cherche le roi noir dans la matrice
						{
							for ( q=0; q < codes.length;q++)
							{
								if(this.getEchiquier()[p][q].getNom().equals("KN"))
								{
									stockageRoi=this.getEchiquier()[p][q];
								}
							}
						}
					}
					else
					{
						for ( p=0; p < codes.length;p++)    //cherche le roi blanc dans la matrice
						{
							for ( q=0; q < codes.length;q++)
							{
								if(this.getEchiquier()[p][q].getNom().equals("KB"))
								{
									stockageRoi=this.getEchiquier()[p][q];
								}
							}
						}
					}
					
						if (this.getEchiquier()[k][l].metEnEchec(this,stockageRoi) == true) //Verifie si le roi sera en echec
						{
							System.out.println("Le roi adverse est en échec");
						}
						return true;
					}
				}
			}
		}
	System.err.println("Un de vos codes est faux. Recommencez.");			// si coors entré inexistante
	return false;
	}

	
	public boolean estVide(Position position) { //Voir si la piece dans la position indiqué est vide
		int x = position.getX();
		int y = position.getY();

		if(this.echiquier[8-y][x-1].getNom()=="..") 
		{
			return true;
		}
		return false;
	}


	//GETTESRS AND SETTERS
	public Piece[][] getEchiquier() {
		return echiquier;
	}


	public String[][] getCodes() {
		return codes;
	}
	
	//////////////////
	
	public Pion getPionB1() {
		return pionB1;
	}



	public void setPionB1(Pion pionB1) {
		this.pionB1 = pionB1;
	}



	public Pion getPionB2() {
		return pionB2;
	}



	public void setPionB2(Pion pionB2) {
		this.pionB2 = pionB2;
	}



	public Pion getPionB3() {
		return pionB3;
	}



	public void setPionB3(Pion pionB3) {
		this.pionB3 = pionB3;
	}



	public Pion getPionB4() {
		return pionB4;
	}



	public void setPionB4(Pion pionB4) {
		this.pionB4 = pionB4;
	}



	public Pion getPionB5() {
		return pionB5;
	}



	public void setPionB5(Pion pionB5) {
		this.pionB5 = pionB5;
	}



	public Pion getPionB6() {
		return pionB6;
	}



	public void setPionB6(Pion pionB6) {
		this.pionB6 = pionB6;
	}



	public Pion getPionB7() {
		return pionB7;
	}



	public void setPionB7(Pion pionB7) {
		this.pionB7 = pionB7;
	}



	public Pion getPionB8() {
		return pionB8;
	}



	public void setPionB8(Pion pionB8) {
		this.pionB8 = pionB8;
	}

	//////////////////

	public Pion getPionN1() {
		return pionN1;
	}



	public void setPionN1(Pion pionN1) {
		this.pionN1 = pionN1;
	}



	public Pion getPionN2() {
		return pionN2;
	}



	public void setPionN2(Pion pionN2) {
		this.pionN2 = pionN2;
	}



	public Pion getPionN3() {
		return pionN3;
	}



	public void setPionN3(Pion pionN3) {
		this.pionN3 = pionN3;
	}



	public Pion getPionN4() {
		return pionN4;
	}



	public void setPionN4(Pion pionN4) {
		this.pionN4 = pionN4;
	}



	public Pion getPionN5() {
		return pionN5;
	}



	public void setPionN5(Pion pionN5) {
		this.pionN5 = pionN5;
	}



	public Pion getPionN6() {
		return pionN6;
	}



	public void setPionN6(Pion pionN6) {
		this.pionN6 = pionN6;
	}



	public Pion getPionN7() {
		return pionN7;
	}



	public void setPionN7(Pion pionN7) {
		this.pionN7 = pionN7;
	}



	public Pion getPionN8() {
		return pionN8;
	}



	public void setPionN8(Pion pionN8) {
		this.pionN8 = pionN8;
	}



	public Tour getTourB1() {
		return TourB1;
	}



	public void setTourB1(Tour tourB1) {
		TourB1 = tourB1;
	}



	public Tour getTourB2() {
		return TourB2;
	}



	public void setTourB2(Tour tourB2) {
		TourB2 = tourB2;
	}



	public Tour getTourN1() {
		return TourN1;
	}



	public void setTourN1(Tour tourN1) {
		TourN1 = tourN1;
	}



	public Tour getTourN2() {
		return TourN2;
	}



	public void setTourN2(Tour tourN2) {
		TourN2 = tourN2;
	}



	public Cavalier getCavalierB1() {
		return CavalierB1;
	}



	public void setCavalierB1(Cavalier cavalierB1) {
		CavalierB1 = cavalierB1;
	}



	public Cavalier getCavalierB2() {
		return CavalierB2;
	}



	public void setCavalierB2(Cavalier cavalierB2) {
		CavalierB2 = cavalierB2;
	}



	public Cavalier getCavalierN1() {
		return CavalierN1;
	}



	public void setCavalierN1(Cavalier cavalierN1) {
		CavalierN1 = cavalierN1;
	}



	public Cavalier getCavalierN2() {
		return CavalierN2;
	}



	public void setCavalierN2(Cavalier cavalierN2) {
		CavalierN2 = cavalierN2;
	}



	public Fou getFouB1() {
		return FouB1;
	}



	public void setFouB1(Fou fouB1) {
		FouB1 = fouB1;
	}



	public Fou getFouB2() {
		return FouB2;
	}



	public void setFouB2(Fou fouB2) {
		FouB2 = fouB2;
	}



	public Fou getFouN1() {
		return FouN1;
	}



	public void setFouN1(Fou fouN1) {
		FouN1 = fouN1;
	}



	public Fou getFouN2() {
		return FouN2;
	}



	public void setFouN2(Fou fouN2) {
		FouN2 = fouN2;
	}



	public Reine getReineB1() {
		return ReineB1;
	}



	public void setReineB1(Reine reineB1) {
		ReineB1 = reineB1;
	}



	public Reine getReineN1() {
		return ReineN1;
	}



	public void setReineN1(Reine reineN1) {
		ReineN1 = reineN1;
	}



	public Roi getRoiB1() {
		return RoiB1;
	}



	public void setRoiB1(Roi roiB1) {
		RoiB1 = roiB1;
	}



	public Roi getRoiN1() {
		return RoiN1;
	}



	public void setRoiN1(Roi roiN1) {
		RoiN1 = roiN1;
	}



	public void setCodes(String[][] codes) {
		this.codes = codes;
	}



	public void setEchiquier(Piece[][] echiquier) {
		this.echiquier = echiquier;
	}
}