/*

Design Patterns Used:
- Singelton for Board
- Factory for pieces
- Observer for game updates

*/

import javafx.geometry.Pos;

import java.util.List;
import java.util.Scanner;

enum PieceType{
    Pawn, King, Rook, Queen
}

enum PieceColor{
    White, Black
}

class Player{
    String id;
    String name;
    PieceColor pieceColor;
}

class Position{
    int x,y;

    Position(int x, int y){
        this.x=x;
        this.y=y;
    }
}

class Cell{
    Position position;
    Piece piece;
}

abstract class Piece{
    PieceColor pieceColor;
    PieceType pieceType;

    Piece(PieceColor pieceColor, PieceType pieceType){
        this.pieceColor=pieceColor;
        this.pieceType=pieceType;
    }

    abstract boolean isValidMove(Position from, Position to, Board board);
}

class King extends Piece{
    King(PieceColor pieceColor){
        super(pieceColor,PieceType.King);
    }

    @Override
    boolean isValidMove(Position from, Position to, Board board){

    }
}

class PieceFactory{
    static Piece getPiece(PieceType pieceType, PieceColor color){
        switch (pieceType){
            case King: return new King(color);
            default: throw new IllegalArgumentException("Invalid Piece Type");
        }
    }
}

class Board{
    static Board instance;
    Piece[][] board=new Piece[8][8];

    Board(){
        initializeBoard();
    }

    static Board getInstance(){
        if(instance==null) instance=new Board();
        return instance;
    }

    void setPiece(Position position, Piece piece){

    }

    Piece getPiece(Position position){

    }

    void move(Position from, Position to){

    }

    void initializeBoard(){

    }

    void displayBoard(){

    }
}

interface GameObserver{
    void hasDoneCheck(Player player);
    void hasDoneCheckMate(Player player);
    void hasStaleMate();
}

class ConsoleObserver implements GameObserver{
    @Override
    public void hasDoneCheck(Player player){
        System.out.println(player.name+" is under Check");
    }

    @Override
    public void hasDoneCheckMate(Player player){
        System.out.println(player.name+" is under CheckMate");
    }

    @Override
    public void hasStaleMate(){
        System.out.println("Match ends in draw");
    }
}

class RuleEngine{
    Board board;

    boolean isCheck(Player player){

    }

    boolean isCheckMate(Player player){

    }

    boolean isStaleMate(Player player){

    }
}

class Game{
    Board board;
    Player player1, player2;
    Player currPlayer;
    RuleEngine ruleEngine;
    boolean isGameOver;
    List<GameObserver> gameObserver;

    Game(Player p1, Player p2){
        this.player1=p1;
        this.player2=p2;
        this.currPlayer=p1;
        board=Board.getInstance();
        isGameOver=false;
    }

    void addGameObserver(GameObserver observer){
        gameObserver.add(observer);
    }

    void play(){
        Scanner sc=new Scanner(System.in);
        while(true){
            if(isGameOver) break;
            board.displayBoard();

            System.out.println("Enter position of piece want to move");
            int xi=sc.nextInt();
            int yi=sc.nextInt();

            System.out.println("Enter destination position");
            int xf=sc.nextInt();
            int yf=sc.nextInt();

            Position from=new Position(xi,yi);
            Position to=new Position(xf,yf);

            Piece piece=board.getPiece(from);

            if(piece==null || piece.pieceColor!=currPlayer.pieceColor){
                System.out.println("Invalid Piece Selection");
                continue;
            }

            if(!piece.isValidMove(from,to,board)){
                System.out.println("Please enter valid move");
                continue;
            }

            board.move(from,to);

            if(ruleEngine.isCheck(opponent())){
                notifyCheck();
            }

            if(ruleEngine.isCheckMate(opponent())){
                notifyCheckMate();
                isGameOver=true;
                break;
            }

            if(ruleEngine.isStaleMate(opponent())){
                notifyStaleMate();
                isGameOver=true;
                break;
            }

            switchTurn();
        }
    }

    void notifyCheck(){
        for(GameObserver obs:gameObserver){
            obs.hasDoneCheck(opponent());
        }
    }

    void notifyCheckMate(){
        for(GameObserver obs:gameObserver){
            obs.hasDoneCheckMate(opponent());
        }
    }

    void notifyStaleMate(){
        for(GameObserver obs:gameObserver){
            obs.hasStaleMate();
        }
    }

    void switchTurn(){
        currPlayer=(currPlayer==player1) ? player2:player1;
    }

    Player opponent(){
        Player opp=(currPlayer==player1) ? player2:player1;
        return opp;
    }
}

public class Chess2 {
    public static void main(String[] args) {
        Player p1=new Player();
        Player p2=new Player();
        Game game=new Game(p1,p2);
        game.addGameObserver(new ConsoleObserver());
        game.play();
    }
}