package Pieces;

import Game.*;

public class BoardSquare {

    public int x;
    public int y;

    /**
     * ASCII char representing the piece for PGN notation and the CLI
     */
    public char symbol;

    /**
     * The name of the image for this piece
     */
    public String imagename;

    /**
     * Specifies if the piece can move horizontally.
     */
    boolean horiz;

    /**
     * Specifies if the piece can move vertically.
     */
    boolean vert;

    /**
     * Specifies if the piece can move diagonally.
     */
    boolean diag;
    /**
     * Specifies if the piece can move bidirectioanlly.
     */
    boolean bidirectional;

    /**
     * Number of squares the piece can move, 0 if infinite.
     */
    int limit;


    /**
     * Player who owns this piece.
     */
    public Player owner;

    /**
     * Used for pawn first move.
     */
    public boolean hasMoved;

    public BoardSquare(){
        this.hasMoved = false;
        horiz = false;
        vert = false;
        diag = false;
        bidirectional = false;
        limit = 1;

        symbol = ' ';
        imagename = null;
    }
    public BoardSquare(int x, int y, Player player){
        this();
        this.x = x;
        this.y = y;
        this.owner = player;
    }

    /**
    Make a copy of the current piece.
     */
    public BoardSquare copy(BoardSquare old){
        BoardSquare ret = null;
        try {
             ret = old.getClass().newInstance();
        } catch (InstantiationException e){
            System.out.println("Exception!");
        } catch (IllegalAccessException e){
            System.out.println("Exception!");
        }

        return ret;
    }

    /**
    Check if this move is allowed with this Piece's moveset.

    This function can be replaced in inherited classes if needed, for the default chess pieces this was only overridden for the Pieces.Knight.

    @param gameBoard The game board to check the move with
    @param startSquare Starting position
    @param destSquare ending position
    @return true on success, false on not allowed move.
     */
    public boolean MoveThis(Board gameBoard, BoardSquare startSquare, BoardSquare destSquare){

        MoveType moveType = MoveHandler.DetermineType(startSquare, destSquare);
        //Attempt special moves such as pawn capture, pawn first move
        SpecialMoveReturn special = startSquare.SpecialMove(startSquare, destSquare, moveType, gameBoard);
        if(special == SpecialMoveReturn.INVALID)
            return false;
        if(special == SpecialMoveReturn.VALID)
            return true;


        //Return 0 if this Piece is not allowed to move vertically.
        if(moveType.direction == MoveType.Direction.VERT && !startSquare.vert)
            return false;

        if(moveType.direction == MoveType.Direction.HORIZ && !startSquare.horiz)//Return 0 if this Piece is not allowed to move horizontally.
            return false;

        if(moveType.direction == MoveType.Direction.DIAG && !startSquare.diag)//Return 0 if this Piece is not allowed to move diagonally.
            return false;

        if(gameBoard.findPieces(startSquare, destSquare, Math.abs(moveType.distance)))//Return 0 if pieces are in the way
            return false;

        if(moveType.distance==0)//Return 0 if distance is 0.
            return false;

        if(moveType.distance<0 && !startSquare.bidirectional)//Return 0 if this Piece is not allowed to move backwards.
            return false;

        if(startSquare.limit != 0 && startSquare.limit < Math.abs(moveType.distance))//Return if the Piece attempts to move farther than allowed.
            return false;//move refused


        return true;

    }

    /**
    Function to use a piece's special/custom defined move.

    The only default chess Piece using this function is the Pieces.Pawn.

     @param startSquare Starting position
     @param destSquare ending position
     @param moveType a MoveType containing the type of move being attempted.
     @return a SpecialMoveReturn enum.
     */
    public SpecialMoveReturn SpecialMove(BoardSquare startSquare, BoardSquare destSquare, MoveType moveType, Board gameBoard){
        return SpecialMoveReturn.NONEXISTANT;
    }

    /**
     * Signifies if a special move was not found, not allowed, or is allowed.
     */
    public enum SpecialMoveReturn{
        VALID, INVALID, NONEXISTANT
    }

}