// Connect4WithMinimax2.java
// Created on Thu Aug 7

// In this version, added minimax search.  See line 182.

// In the previous version, a slightly better (than random) heuristic evaluation function
// was added.  See evaluateBoard().

// We started with PreTetrisConnect4.java and made as few changes as
// possible to get a simple version of minimax running.

import javax.swing.Timer;
import java.util.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Connect4WithMinimax2 {
   public static void main(String[] args) {
      JFrame frame = new JFrame("PreTetris");
      MyComponent c = new MyComponent();
      frame.getContentPane().add(c);
      frame.setSize(420,360);
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setVisible(true);
   }
}

class MyComponent extends JComponent
                  implements MouseListener, KeyListener, ActionListener {
   // instance variables
   private int pageMargin = 5;
   private int rows = 6;
   private int cols = 7;
   private Color player1    = Color.red;
   private Color player2    = Color.black;
   private Color empty      = Color.white;
   private Color background = Color.blue;
   private Color gameStatusColor = Color.green;
   private Color[][] boardArray = new Color[rows][cols];
   private boolean player1turn = true;
   private int gameStatus;

   private static final int GAME_IN_PROGRESS = -1;
   private static final int TIE_GAME = 0;
   private static final int COMPUTER_WINS = 1;
   private static final int HUMAN_WINS = 2;

   // constructor
   public MyComponent() {
      initBoard();
      setFocusable(true);
      addKeyListener(this);
      addMouseListener(this);
      int delay = 100; //milliseconds
      Timer timer = new Timer(delay, null);
      timer.addActionListener(this);
      timer.start();
  }

  private void initBoard() {
     gameStatus = GAME_IN_PROGRESS;
     player1turn = true;
     for (int row=0; row<rows; row++)
        for (int col=0; col<cols; col++)
           boardArray[row][col] = empty;
  }

   /////////////////////////
   // Game play methods
   /////////////////////////

   private static final int WIN = Integer.MAX_VALUE;
   private static final int LOSE = Integer.MIN_VALUE;
   private static final int TIE = 0;

   private static final int MAX_DEPTH = 4;

   class ScoredMove {
      public Board board;
      public Move move;
      public int score;
      public String toString() { return "move=" + move + ",score=" + score; }
   }

   class Move {
      public Move(int col) {
         this.col = col;
      }
      private int col;
      public int getCol() {
         return this.col;
      }
      public String toString() { return "col=" + col; }
   }

   class Board {
      private Color[][] boardArray;

      public Board(Color[][] boardArray) {
         this.boardArray = boardArray;
      }

      public Color[][] getBoardArray() {
         return this.boardArray;
      }
   }

   private int getColumn(int x) {
      int width = getWidth();
      int innerWidth = width - 2*this.pageMargin;
      int cellWidth = innerWidth/this.cols;
      int col = (x - this.pageMargin) / cellWidth;
      if (col >= cols) return -1;
      return col;
   }

   private void doComputerMove() {
      Board board = new Board(boardArray);
      ScoredMove bestMove = doMove(board, player1turn);
      // call the "old" doMove with the bestMove
      if (bestMove == null)
         // computer has no move, so make it the human's turn
         player1turn = !player1turn;
      else
         doMove(bestMove.move.getCol());
   }

   // try every move and return the best one!
   private ScoredMove doMove(Board board, boolean player1turn) {
    return doMove(board, player1turn, 0); // initial call == depth of 0
   }

   // try every move and return the best one!
   private ScoredMove doMove(Board board, boolean player1turn, int depth) {
      ScoredMove bestMove = null;
      if (MAX_DEPTH < 3)
        System.out.println("doMove for " + (player1turn ? "human" : "computer") + " at depth " + depth);
      for (int col=0; col<cols; col++) {
         Move move = new Move(col);
         ScoredMove nextMove = doMove(board, move, player1turn, depth);
         if (MAX_DEPTH < 3)
            System.out.println("  nextMove:" + nextMove);
         if (bestMove == null)
            bestMove = nextMove;
         else if (((player1turn == true) &&  (nextMove.score < bestMove.score)) ||
                  ((player1turn == false) && (nextMove.score > bestMove.score)))
            bestMove = nextMove;
      }
      return bestMove;
   }

   private ScoredMove doMove(Board b, Move move, boolean player1turn, int depth) {
      // Make new board
      Color[][] oldBoardArray = b.getBoardArray();
      Color[][] boardArray = new Color[rows][cols];
      for (int row=0; row<rows; row++)
         for (int col=0; col<cols; col++)
            boardArray[row][col] = oldBoardArray[row][col];
      // Place the new board in our result (the ScoredMove)
      ScoredMove result = new ScoredMove();
      result.board = new Board(boardArray);
      result.move = move;
      result.score = (player1turn ? WIN : LOSE);
      // now make a move on the new board
      // make move
      int col = move.getCol();
      int row = lastBlankRow(boardArray, col);
      if (row < 0) {
          return result;
      }
      Color playerColor = (player1turn ? player1 : player2);
      boardArray[row][col] = playerColor;
      // now evaluate the move
      if (didWin(boardArray, playerColor)) {
         result.score = (player1turn ? LOSE : WIN);
      }
      else if (boardIsFull()) {
         result.score = TIE;
      }
      else if (depth < MAX_DEPTH) {
        ScoredMove otherPlayerMove = doMove(result.board, !player1turn, depth+1);
        result.score = otherPlayerMove.score;
      }
      else
         result.score = evaluateBoard(result.board, player1turn);
      return result;
   }

   private int evaluateBoard(Board board, boolean player1turn) {
     return eval(board.getBoardArray(), player1turn);
   }

   private int eval(Color[][] boardArray, Color color, int row, int col, int drow, int dcol) {
      if ((drow == 0) && (dcol == 0)) return 0;
      for (int counter=0; counter<4; counter++) {
         int r = row + counter*drow;
         int c = col + counter*dcol;
         if ((r < 0) || (r >= rows) || (c < 0) || (c >= cols)) return counter;
         if (boardArray[r][c] != color) return counter;
      }
      return 4;
   }

   private int eval(Color[][] boardArray, boolean player1turn) {
      Color c = (player1turn ? player1 : player2);
      int value = 0;
      for (int row=0; row<rows; row++)
         for (int col=0; col<cols; col++) {
            if (boardArray[row][col] == c) value -= Math.abs(cols/2 - col);
            for (int drow=-1; drow<=1; drow++)
               for (int dcol=-1; dcol<=1; dcol++)
                  value += 1000*eval(boardArray, c,row,col,drow,dcol);
         }
      if (player1turn) value = -value;
      return value;
   }

   private void doMove(int col) {
      int row = lastBlankRow(this.boardArray, col);
      if (row < 0) {
          beep();
          return;
      }
      Color playerColor = (player1turn ? player1 : player2);
      boardArray[row][col] = playerColor;
      if (didWin(this.boardArray, playerColor)) {
         System.out.println("You win!!!!");
         gameStatus = (player1turn ? HUMAN_WINS : COMPUTER_WINS);
      }
      else if (boardIsFull()) {
         System.out.println("Tie game!!!!");
         gameStatus = TIE_GAME;
      }
      else
         player1turn = !player1turn;

      if ((player1turn == false) && (gameStatus == GAME_IN_PROGRESS))
         doComputerMove();
   }

   private boolean boardIsFull() {
      for (int row=0; row<rows; row++)
         for (int col=0; col<cols; col++)
            if (boardArray[row][col] == empty)
               return false;
      return true;
   }

   private boolean didWin(Color[][] boardArray, Color color, int row, int col, int drow, int dcol) {
      if ((drow == 0) && (dcol == 0)) return false;
      for (int counter=0; counter<4; counter++) {
         int r = row + counter*drow;
         int c = col + counter*dcol;
         if ((r < 0) || (r >= rows) || (c < 0) || (c >= cols)) return false;
         if (boardArray[r][c] != color) return false;
      }
      return true;
   }

   private boolean didWin(Color[][] boardArray, Color c) {
      for (int row=0; row<rows; row++)
         for (int col=0; col<cols; col++)
            for (int drow=-1; drow<=1; drow++)
               for (int dcol=-1; dcol<=1; dcol++)
                  if (didWin(boardArray, c,row,col,drow,dcol))
                     return true;
      return false;
   }

   private int lastBlankRow(Color[][] boardArray, int col) {
      for (int row=this.rows-1; row>=0; row--)
         if (boardArray[row][col] == empty)
            return row;
      return -1;
   }

   /////////////////////////
   // ActionListener methods (used for timer)
   /////////////////////////

   public void doTimer() {
   }

   public void actionPerformed(ActionEvent e) {
      doTimer();
      repaint();
   }

   /////////////////////////
   // KeyListener methods
   /////////////////////////

   public void doUp() {
   }

   public void doDown() {
   }

   public void doLeft() {
   }

   public void doRight() {
   }

   public void doSpace() {
   }

   public void keyPressed(KeyEvent ke) {
      switch (ke.getKeyCode()) {
         case KeyEvent.VK_UP:    doUp(); break;
         case KeyEvent.VK_DOWN:  doDown(); break;
         case KeyEvent.VK_LEFT:  doLeft(); break;
         case KeyEvent.VK_RIGHT: doRight(); break;
         // default:  beep();
      }
      repaint();
   }

   public void keyReleased(KeyEvent ke) { }

   public void keyTyped(KeyEvent ke) {
      switch (ke.getKeyChar()) {
         case ' ': doSpace(); break;
         default: beep();
      }
      repaint();
   }


   /////////////////////////
   // MouseListener methods
   /////////////////////////

   public void mouseClicked(MouseEvent e) {
   }

   public void mouseEntered(MouseEvent e) {
   }

   public void mouseExited(MouseEvent e) {
   }

   public void mousePressed(MouseEvent e) {
      if (gameStatus != GAME_IN_PROGRESS) {
        initBoard();
      }
      else {
        int x = e.getX();
        int y = e.getY();
        int col = getColumn(x);
        if (col >= 0)
           doMove(col);
      }
      repaint();
   }

   public void mouseReleased(MouseEvent e) {
   }


   private void beep() {
      Toolkit.getDefaultToolkit().beep();
   }

   private void paintCell(Graphics page, int row, int col) {
      int width = getWidth();
      int height = getHeight();
      int innerWidth = width - 2*this.pageMargin;
      int innerHeight = height - 2*this.pageMargin;
      int cellWidth = innerWidth/this.cols;
      int cellHeight = innerHeight/this.rows;
      int cellLeft = this.pageMargin + cellWidth*col;
      int cellTop  = this.pageMargin + cellHeight*row;
      int cellMargin = 5;
      page.setColor(this.boardArray[row][col]);
      page.fillOval(cellLeft+cellMargin, cellTop+cellMargin,
                    cellWidth-2*cellMargin, cellHeight-2*cellMargin);
   }

   private void paintBoard(Graphics page) {
      for (int row=0; row<rows; row++)
         for (int col=0; col<cols; col++)
            paintCell(page, row, col);
   }

   private void paintGameStatus(Graphics page) {
      page.setColor(new Color(100,100,100,200));
      page.fillRect(40,15,170,40);
      String msg = "";
      switch (gameStatus) {
        case COMPUTER_WINS:  msg = "I win!!!"; break;
        case HUMAN_WINS:     msg = "You win!!!"; break;
        case TIE_GAME:       msg = "Tie game!!!"; break;
        default:          return;
      }
      page.setColor(gameStatusColor);
      page.setFont(new Font("Arial",Font.BOLD,32));
      page.drawString(msg,50,50);
   }

   public void paintComponent(Graphics page) {
      // first paint background
      int width = getWidth();
      int height = getHeight();
      page.setColor(this.background);
      page.fillRect(pageMargin,pageMargin,width-2*pageMargin,height-2*pageMargin);
      // then the board
      paintBoard(page);
      if (gameStatus != GAME_IN_PROGRESS) paintGameStatus(page);
   }
}