package TicTac;
import java.awt.*;import java.awt.event.*;
import java.util.Vector;

public final class TTManager extends MouseAdapter{  private static TTManager singleton = new TTManager();
  public  static TTManager Singleton()
  {
    return singleton;
  }

	private TTBoard tt_board;
	private TTEngine tt_engine;

  private static class Player
  {
    public char player_mark;
    public TTPlayer player;

    public Player(char playerMark, TTPlayer player)    {      this.player_mark = playerMark;
      this.player = player;
    }
  }

  private Player x_player;  private Player o_player;
  private Player machine_player;

  class Timer implements Runnable  {    //static
    final int MOVE_TIME = 100;    private char player_mark;
    Thread  timer_thread;
    private boolean disable_timer;

    private Timer()    {      timer_thread = null;
      disable_timer = false;
    }

    void DisableTimer()
    {
      disable_timer = true;
    }

    void StartTimer(char player_mark)    {      if (disable_timer) return;
      if (timer_thread !=null)
      {
	      timer_thread = null;
      }
      this.player_mark = player_mark;
      timer_thread = new Thread(this);
      timer_thread.start();
    }

    void StopTimer()    {      if (timer_thread !=null)
      {
	      timer_thread = null;
      }
    }

    public void run()    {      try
      {
	      Thread.sleep(MOVE_TIME);
      }
      catch (InterruptedException e)
      {
      }
      if (timer_thread == null)
	   return;
      String player = (player_mark == TTPlayer.X)?
                                       new String("X"): new String("O");
      String opponent_player = (player_mark == TTPlayer.X)?
                                       new String("O"): new String("X");
      System.out.println(player+" runs out of time. Game over!");
      System.out.println(opponent_player+" win!");
      System.exit(1);
    }
  }

  private Timer timer;
  private TTManager()  {    tt_engine = new TTEngine();
    tt_board = new TTBoard(tt_engine.GetBoardStatus());
    timer = new TTManager.Timer();
    timer.DisableTimer();
  }

  private TTPlayer GetPlayer(char player_mark)  {    return (player_mark == TTPlayer.X)? x_player.player:o_player.player;
  }

  private void PrintPass(char player_mark)  {    String player = (player_mark == TTPlayer.X)? new String("black"): new String("white");
    System.out.println(player+" "+"pass\n");
  }

  private void PrintOneMove (char player_mark, TTMove move)  {    String player = (player_mark == TTPlayer.X)?
                                    new String("black"): new String("white");
    System.out.println(player+" goes "+move);
    tt_engine.PrintBoard();
    System.out.println();
  }

  /* return true if one move taken,   * return false if pass
   */
  private boolean PlayOneMove (char player_mark)
  {
    if (tt_engine.DetectMoreMove(player_mark))
    {
      timer.StartTimer(player_mark);
      TTMove move = GetPlayer(player_mark).NextMove(tt_engine.GetBoardStatus());
      timer.StopTimer();
      tt_engine.MakeMove(player_mark, move);
      PrintOneMove(player_mark, move);
      tt_board.DisableMove(move);
      tt_board.DisplayBoard();
      /* add some delay to show board */
      {
	      int wait_time = 1000;
	      try
         {
	         Thread.sleep(wait_time);
   	   }
         catch (InterruptedException e)
         {
	      }
      }
      return true;
    }
    return false;
  }

  private void SignalGameOver()  {    System.out.println("Game over! ");
    if (tt_engine.playerWins(TTPlayer.X))
    {
      tt_board.SetFinalMessage("X win!");
      System.out.println("X win!");
    }
    else if (tt_engine.playerWins(TTPlayer.O))
    {
      tt_board.SetFinalMessage("O win!");
      System.out.println("O win!");
    }
    else
    {
      tt_board.SetFinalMessage("tie!");
      System.out.println("tie!");
    }
  }

  public void PlayTicTac (TTPlayer black, TTPlayer white)  {    x_player = new Player(TTPlayer.X, black);
    o_player = new Player(TTPlayer.O, white);
    boolean game_over = false;
    char turn = TTPlayer.X;
    while (!game_over)
    {
      if (!PlayOneMove(turn))
      {
	      if (tt_engine.DetectMoreMove(TTEngine.GetOpponentMark(turn)))
         {
	         PrintPass(turn);
	      }
	      turn = TTEngine.GetOpponentMark(turn);
	      if (!PlayOneMove(turn))
         {
	         game_over = true;
   	   }
      }
      turn = TTEngine.GetOpponentMark(turn);
    }
    SignalGameOver();
  }

  public void PlayTicTacWithHuman(char player_mark, TTPlayer player)  {    machine_player = new Player(player_mark, player);
    if (player_mark == TTPlayer.X)
    {
      timer.StartTimer(player_mark);
      TTMove move = player.NextMove(tt_engine.GetBoardStatus());
      timer.StopTimer();
      PlayOneMove(player_mark, move);
    }
    tt_board.PlayWithHuman(this);
  }

  private boolean IsGameOver()  {    return tt_engine.playerWins(TTPlayer.X)
         || tt_engine.playerWins(TTPlayer.O)
         || tt_engine.GetNumEmptyCell() == 0;
  }

  private void PlayOneMove(char player_mark, TTMove move)  {    tt_engine.MakeMove(player_mark, move);
    PrintOneMove(player_mark, move);
    tt_board.DisableMove(move);
    tt_board.DisplayBoard();
  }

  public void mouseClicked(MouseEvent e)  {
    TTBoard.TTCell cell = (TTBoard.TTCell) e.getSource();
    TTMove move = new TTMove(cell.GetX(), cell.GetY());
    char machine_color = machine_player.player_mark;
    char human_color = TTEngine.GetOpponentMark(machine_color);
    if (tt_engine.IsMoveLegal(move))
    {
      PlayOneMove(human_color, move);
      if (tt_engine.DetectMoreMove(machine_color))
      {
	      timer.StartTimer(machine_color);
	      move = machine_player.player.NextMove(tt_engine.GetBoardStatus());
	      timer.StopTimer();
	      PlayOneMove(machine_color, move);
      	while (!tt_engine.DetectMoreMove(human_color)&& !IsGameOver())
         {
	         PrintPass(human_color);
	         timer.StartTimer(machine_color);
	         move = machine_player.player.NextMove(tt_engine.GetBoardStatus());
	         timer.StopTimer();
	         PlayOneMove(machine_color, move);
	      }
      }
      else if (!IsGameOver())
      {
	      PrintPass(machine_color);
      }
      if (IsGameOver())
      {
	      tt_board.DisableBoard();
	      SignalGameOver();
      }
    }
  }

  Vector GetLegalMovesAdaptor(char player_mark)  {    return tt_engine.GetLegalMoves(player_mark);
  }

  public static Vector GetLegalMoves(char player_mark)  {    return Singleton().GetLegalMovesAdaptor(player_mark);
  }

  char[][] GetBoardStatusAdaptor()  {    return tt_engine.GetBoardStatus();
  }

  public static char[][] GetBoardStatus()   {    return Singleton().GetBoardStatusAdaptor();
  }

  TTEngine GetEngineCopyAdaptor()  {    return tt_engine.GetEngineCopy();
  }

  public static TTEngine GetEngineCopy()  {    return Singleton().GetEngineCopyAdaptor();
  }


}