import java.awt.*;
import java.io.*;
import java.lang.*;
import java.net.*;
import java.util.*;

public class  TTT extends Frame implements DialogResult
{ 
	public TTT()
	{
		Font f = new Font ("Helvetica", Font.PLAIN, 75);
		if (playerType == SERVER)
			setTitle("Tic-Tac-Toe SERVER");
		else
			setTitle("Tic-Tac-Toe CLIENT");
		setLayout(new GridLayout(3,3));
	  	for (int i=0; i<NUM_BUTTONS; i++)
	  	{
      		add(Buttons[i] = new GameButton(i));
			Buttons[i].setFont(f);
		}
	}
   
	public boolean handleEvent(Event evt)
	{
		if (evt.id == Event.WINDOW_DESTROY && evt.target == this)
   			System.exit(0);
      	return super.handleEvent(evt);
   	}

	public boolean action(Event evt, Object arg)
	{  
   		if ( evt.target instanceof GameButton)
		{
			sendMessage("SELECT " + ((GameButton) evt.target).getNum());
			Board.disable();
			selectButton(((GameButton) evt.target).getNum());
		}
		else
			return false;
		return true;
	}

	
	public static void selectButton (int num)
	{
		num_turns++;
		Buttons[num].setLabel(turn);
		Buttons[num].disable();
		Results[num] = turn.hashCode();
		checkResults();
		if ( turn.equals(X) )
			turn = O;
		else
			turn = X;
	}
		
	public static void checkResults ()
	{
		if (!(playerType == SERVER))
			return;
		else
		{
			if ( checkWinner() == WINNER )
			{
				if (turn.equals(X))
				{
					sendMessage("LOSE");
					PlayAgainDialog dialog = new PlayAgainDialog(Board,
							"You are the winner!");
					dialog.show();
				}
				else
				{
					sendMessage("WIN");
					PlayAgainDialog dialog = new PlayAgainDialog(Board,
							"You are the loser!");
					dialog.show();
				}
			}
			else if ( num_turns == NUM_BUTTONS )
			{
				sendMessage("TIE");
				PlayAgainDialog dialog = new PlayAgainDialog(Board,
						"It is a tie!");
				dialog.show();
			}
			else if (turn.equals(X))
				sendMessage("TURN");
			else
				Board.enable();
		}
	}


	// There are eight possible scenarios
	static int checkWinner ()
	{
		if ( (Results[0] + Results[1] + Results[2]) == (3 * turn.hashCode()) )
			return (WINNER);
		if ( (Results[3] + Results[4] + Results[5]) == (3 * turn.hashCode()) )
			return (WINNER);
		if ( (Results[6] + Results[7] + Results[8]) == (3 * turn.hashCode()) )
			return (WINNER);
		if ( (Results[0] + Results[3] + Results[6]) == (3 * turn.hashCode()) )
			return (WINNER);
		if ( (Results[1] + Results[4] + Results[7]) == (3 * turn.hashCode()) )
			return (WINNER);
		if ( (Results[2] + Results[5] + Results[8]) == (3 * turn.hashCode()) )
			return (WINNER);
		if ( (Results[0] + Results[4] + Results[8]) == (3 * turn.hashCode()) )
			return (WINNER);
		if ( (Results[2] + Results[4] + Results[6]) == (3 * turn.hashCode()) )
			return (WINNER);

		return (TIE);
	}


	static void resetGameBoard ()
   	{
		for (int i=0; i<NUM_BUTTONS; i++)
		{
			Buttons[i].setLabel("");
			Buttons[i].enable();
			Results[i] = 0;
		}
		num_turns = 0;
		play_count = 0;
		Board.disable();
		if (start == SERVER)
		{
			turn = O;
			start = CLIENT;
		}
		else
		{
			turn = X;
			start = SERVER;
		}
	}
   	

	public static void playAgain ()
	{
		if (playerType == SERVER)
		{
			if (play_count == 2)
			{
				sendMessage("NEW");
				resetGameBoard();
				if (start == CLIENT)
					sendMessage("TURN");
				else
					Board.enable();
			}
		}
	}


	public void processDialogResult (Dialog source, int result)
	{
		if (result == YES)
		{
			sendMessage("PLAY");
			play_count++;
			playAgain();
		}
		else if (result == NO)
		{
			sendMessage("EXIT");
//			sock.close();
			System.exit(0);
		}
	}

	static public void createServer ()
	{
		try
		{
			// Have the system give me a available socket
			server = new ServerSocket (0);
			InetAddress address = InetAddress.getLocalHost();
			System.out.print("Type java TTT " + address.getHostName());
			System.out.println(" " + server.getLocalPort());
			sock = server.accept();
			in_stream = new DataInputStream(sock.getInputStream());
			out_stream = new PrintStream(sock.getOutputStream());
		}
		catch (Exception e)
		{
			System.out.println(e);
		}
	}

	static public void createClient (String host, String port)
	{
		try
		{
			Integer i = Integer.valueOf(port);
			sock = new Socket(host, i.intValue());
			in_stream = new DataInputStream(sock.getInputStream());
			out_stream = new PrintStream(sock.getOutputStream());
		}
		catch (Exception e)
		{
			System.out.println(e);
		}
	}

	public static void sendMessage (String msg)
	{
		try
		{
			out_stream.println(msg);
		}
		catch (Exception e)
		{
			System.out.println(e);
		}
	}

	public static void processMessage ()
	{
		PlayAgainDialog dialog;
		try
		{
		while (true)
		{
			String str = in_stream.readLine();
			StringTokenizer token = new StringTokenizer(str, " :");

			String tok = token.nextToken();
			if (tok.equals("TURN"))
			{
				Board.enable();
			}
			else if (tok.equals("SELECT"))
			{
				tok = token.nextToken();
				Integer i = Integer.valueOf(tok);
				selectButton (i.intValue());
			}
			else if (tok.equals("WIN"))
			{
				dialog = new PlayAgainDialog(Board,
						"You are the winner!");
				dialog.show();
			}
			else if (tok.equals("TIE"))
			{
				dialog = new PlayAgainDialog(Board,
						"It is a tie!");
				dialog.show();
			}
			else if (tok.equals("LOSE"))
			{
				dialog = new PlayAgainDialog(Board,
						"You are the loser!");
				dialog.show();
			}
			else if (tok.equals("EXIT"))
			{
				sock.close();
				System.exit(0);
			}
			else if (tok.equals("PLAY"))
			{
				play_count++;
				playAgain();
			}
			else if (tok.equals("NEW"))
			{
				resetGameBoard();
			}
		}
		}
		catch (Exception e)
		{ 
			System.out.println(e);
		}
	}



	public static void startGame ()
	{
		out_stream.println("TURN");
		processMessage ();
	}
   
	public static void main(String[] args)
	{ 
		if ( args.length == 0 )
		{
			playerType = SERVER;
			start = CLIENT;
			createServer();
		}
		else if ( args.length == 2 )
		{
			playerType = CLIENT;
			createClient(args[0], args[1]);
		}
		else
		{
			System.out.println("Usage: java TTT [Host Port]");
			System.exit(0);
		}
		Board = new TTT();
		Board.resize(300, 300);
		start = SERVER;
		resetGameBoard();
		Board.show();  
		if ( playerType == SERVER )
		{
			startGame();
		}
		else
			processMessage ();
	}

	private static final int NUM_BUTTONS = 9;
	private static final int WINNER = 0;
	private static final int TIE = 1;
	private static final int YES = 1;
	private static final int NO = 0;
	private static final int SERVER = 0;
	private static final int CLIENT = 1;
	private static GameButton[] Buttons = new GameButton[NUM_BUTTONS];
	private static int[] Results = new int[NUM_BUTTONS];
	private static int num_turns;
	public static Frame Board;
	static final String X = "X";
	static final String O = "O";
	static String turn;
	static ServerSocket server; 
	static Socket sock;
	static DataInputStream in_stream;
	static PrintStream out_stream;
	private static int	playerType;
	private static int	start;
	private static int  play_count;
}


interface DialogResult
{
	public void processDialogResult (Dialog source, int result);
}

class GameButton extends Button
{
	public GameButton ( int num )
	{
		super ("");
		button_num = num;
	}

	public int getNum ()
	{
		return (button_num);
	}

	public int	button_num;

}


class PlayAgainDialog extends Dialog
{
	public PlayAgainDialog (Frame parent, String msg)
	{
		super(parent, "Play Again Dialog", true);
		Panel p1 = new Panel();
		p1.add(new Label(msg));
		p1.add(new Label("Do you want to play again?"));
		add("Center", p1);

		Panel p2 = new Panel();
		p2.add(new Button("Yes"));
		p2.add(new Button("No"));
		add("South", p2);
		resize(220, 150);
	}

	public boolean action(Event evt, Object arg)
	{
		if ( arg.equals("Yes") )
		{
			dispose();
			((DialogResult)getParent()).processDialogResult(this, 1);
			return true;
		}
		else if ( arg.equals("No") )
		{
			dispose();
			((DialogResult)getParent()).processDialogResult(this, 0);
			return true;
		}
		return false;
	}

	public boolean handleEvent(Event evt)
	{
		return super.handleEvent(evt);
	}
}