package backend;

import java.util.ArrayList;

public class Board {
	
    private int width;
    private int height;
    private int turnNumber = 0;
    private int selectedX = -1;
    private int selectedY = -1;
    private ArrayList<Piece> pieces = new ArrayList<>();
    private ArrayList<int[]> highlightedSquares = new ArrayList<>();
    private ArrayList<Move> moveHistory = new ArrayList<>();


    
    

	public Board(int colNum, int lineNum) {
        this.width = colNum;
        this.height = lineNum;
	}

	public int getWidth() {
		return width;
	}

	public int getHeight() {
		return height;
	}

	public int getTurnNumber() {
		return turnNumber;
	}

	public boolean isTurnWhite() {
		return (turnNumber % 2 == 0);
	}

	public void setPiece(boolean isWhite, PieceType type, int x, int y) {
	    Piece piece = new Piece(type, isWhite, x, y);
	    pieces.add(piece);
	}

	public void populateBoard() {
	    cleanBoard(); // on vide d'abord le plateau

	    // Pions
	    for (int i = 0; i < 8; i++) {
	        setPiece(true, PieceType.Pawn, i, 6); // Blancs
	        setPiece(false, PieceType.Pawn, i, 1); // Noirs
	    }

	    // Pièces noires
	    setPiece(false, PieceType.Rook, 0, 0);
	    setPiece(false, PieceType.Knight, 1, 0);
	    setPiece(false, PieceType.Bishop, 2, 0);
	    setPiece(false, PieceType.Queen, 3, 0);
	    setPiece(false, PieceType.King, 4, 0);
	    setPiece(false, PieceType.Bishop, 5, 0);
	    setPiece(false, PieceType.Knight, 6, 0);
	    setPiece(false, PieceType.Rook, 7, 0);

	    // Pièces blanches
	    setPiece(true, PieceType.Rook, 0, 7);
	    setPiece(true, PieceType.Knight, 1, 7);
	    setPiece(true, PieceType.Bishop, 2, 7);
	    setPiece(true, PieceType.Queen, 3, 7);
	    setPiece(true, PieceType.King, 4, 7);
	    setPiece(true, PieceType.Bishop, 5, 7);
	    setPiece(true, PieceType.Knight, 6, 7);
	    setPiece(true, PieceType.Rook, 7, 7);
	}

	public void cleanBoard() {
		pieces.clear();
	}
	
	public String toString() {
	    StringBuilder sb = new StringBuilder();
	    for (Piece p : pieces) {
	        sb.append(p.getType()).append(" ")
	          .append(p.isWhite() ? "white" : "black")
	          .append(" at (").append(p.getX()).append(", ").append(p.getY()).append(")\n");
	    }
	    return sb.toString();
	}

	
	public ArrayList<Piece> getPieces() {
		return pieces;
	}


	public void userTouch(int x, int y) {
	    Piece clickedPiece = getPieceAt(x, y);

	    // Aucune sélection active
	    if (selectedX == -1 && selectedY == -1) {
	        if (clickedPiece != null && clickedPiece.isWhite() == isTurnWhite()) {
	            // Sélection de la pièce
	            selectedX = x;
	            selectedY = y;

	            // Calcul des déplacements valides
	            highlightedSquares = Move.getPossibleMoves(this, clickedPiece);
	        }
	    }

	    // Une pièce est déjà sélectionnée
	    else {
	        // Si on clique à nouveau sur la case sélectionnée  on annule
	        if (x == selectedX && y == selectedY) {
	            selectedX = -1;
	            selectedY = -1;
	            highlightedSquares.clear();
	        }

	        // Sinon on tente de bouger la pièce sélectionnée vers (x, y)
	        else {
	            Piece selectedPiece = getPieceAt(selectedX, selectedY);

	            if (selectedPiece != null && selectedPiece.isWhite() == isTurnWhite()) {
	                // Est-ce une destination valide ?
	                boolean valid = false;
	                for (int[] move : highlightedSquares) {
	                    if (move[0] == x && move[1] == y) {
	                        valid = true;
	                        break;
	                    }
	                }

	                if (valid) {
	                    Piece destPiece = getPieceAt(x, y);

	                    // Enregistrer le coup dans l'historique
	                    Move move = new Move(selectedPiece, selectedX, selectedY, x, y, destPiece);
	                    moveHistory.add(move);

	                    // Appliquer le déplacement
	                    pieces.remove(selectedPiece);
	                    if (destPiece != null) pieces.remove(destPiece);
	                    pieces.add(new Piece(selectedPiece.getType(), selectedPiece.isWhite(), x, y));

	                    turnNumber++;
	                }

	                // Dans tous les cas, on désélectionne
	                selectedX = -1;
	                selectedY = -1;
	                highlightedSquares.clear();
	            }
	        }
	    }
	}



	public boolean isSelected(int x, int y) {
	    return x == selectedX && y == selectedY;
	}


	
	/* saving-loading feature :*/

	public String[] toFileRep() {
	    String[] lines = new String[height + 1];

	    for (int y = 0; y < height; y++) {
	        StringBuilder row = new StringBuilder();
	        for (int x = 0; x < width; x++) {
	            Piece p = getPieceAt(x, y);
	            if (p != null) {
	                row.append(p.isWhite() ? "W" : "B").append(p.getType().getSummary());
	            }
	            row.append(x < width - 1 ? "," : "");
	        }
	        lines[y] = row.toString();
	    }

	    // Dernière ligne : couleur du joueur actif
	    lines[height] = isTurnWhite() ? "W" : "B";

	    return lines;
	}

	public Board(String[] array) {
	    this.width = 8;
	    this.height = 8;
	    this.pieces = new ArrayList<>();
	    this.highlightedSquares = new ArrayList<>();
	    this.selectedX = -1;
	    this.selectedY = -1;

	    for (int y = 0; y < height; y++) {
	        String[] cells = array[y].split(",", -1);
	        for (int x = 0; x < cells.length; x++) {
	            String cell = cells[x];
	            if (cell.length() == 2) {
	                boolean isWhite = cell.charAt(0) == 'W';
	                PieceType type = PieceType.fromSummary(cell.charAt(1));
	                setPiece(isWhite, type, x, y);
	            }
	        }
	    }

	    // Ligne 9 : couleur du joueur actif
	    this.turnNumber = array[height].equals("W") ? 0 : 1;
	}

	/* The following methods require more work ! */

	public boolean isHighlighted(int x, int y) {
	    for (int[] pos : highlightedSquares) {
	        if (pos[0] == x && pos[1] == y) {
	            return true;
	        }
	    }
	    return false;
	}


	public void undoLastMove() {
	    if (moveHistory.isEmpty()) return;

	    Move last = moveHistory.remove(moveHistory.size() - 1);

	    // Supprimer la pièce déplacée
	    Piece current = getPieceAt(last.getToX(), last.getToY());
	    if (current != null) {
	        pieces.remove(current);
	    }

	    // Restaurer la pièce déplacée
	    pieces.add(new Piece(
	        last.getMovedPiece().getType(),
	        last.getMovedPiece().isWhite(),
	        last.getFromX(), last.getFromY()
	    ));

	    // Réinsérer la pièce capturée si besoin
	    if (last.getCapturedPiece() != null) {
	        Piece c = last.getCapturedPiece();
	        pieces.add(new Piece(c.getType(), c.isWhite(), c.getX(), c.getY()));
	    }

	    turnNumber--;
	}

	public Board(Board board) {
		//TODO

	}
	
	public void playMove(Move move) {
		//TODO

	}
	
	public Piece getPieceAt(int x, int y) {
	    for (Piece p : pieces) {
	        if (p.getX() == x && p.getY() == y) {
	            return p;
	        }
	    }
	    return null;
	}

}