package netgame.chat;

import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import javax.swing.*;
import netgame.common.*;

/* This class is a demo of the "netgame" package.  It's not exactly a game, but
 * it uses the netgame infrastructure of Hub + Clients to send and receive
 * messages in the chat room.  The chat room server is just a netgame Hub.
 * A ChatRoomWindow has a subclass that represents a Client for that Hub.
 */

/**
 * This class represents a client for a "chat room" application.  The chat
 * room is hosted by a server running on some computer.  The user of this
 * program must know the host name (or IP address) of the computer that
 * hosts the chat room.  When this program is run, it asks for that
 * information.  Then, it opens a window that has an input box where the
 * user can enter messages to be sent to the chat room.  The message is 
 * sent when the user presses return in the input box or when the
 * user clicks a Send button.  There is also a text area that shows 
 * a transcript of all messages from participants in the chat room.
 * <p>Participants in the chat room are represented only by ID numbers
 * that are assigned to them by the server when they connect.
 */
public class ChatRoomWindow extends JFrame {
    
    private final static int PORT = 37829; // The ChatRoom port number; can't be 
                                           // changed here unless the ChatRoomServer
                                           // program is also changed.

    /**
     * Gets the host name (or IP address) of the chat room server from the
     * user and opens a ChatRoomWindow.  The program ends when the user
     * closes the window.
     */
    public static void main(String[] args) {
        String host = JOptionPane.showInputDialog(
                       "Enter the host name of the\ncomputer that hosts the chat room:");
        if (host == null || host.trim().length() == 0)
            return;
        ChatRoomWindow window = new ChatRoomWindow(host);
        window.setLocation(200,100);
        window.setVisible(true);
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    
    
    /**
     * A ChatClient connects to the Hub and is used to send messages to
     * and receive messages from a Hub.  Messages received from the
     * Hub will be of type ForwardedMessage and will contain the
     * ID number of the sender and the string that was sent by
     * that user.
     */
    private class ChatClient extends Client {

        /**
         * Opens a connection the chat room server on a specified computer.
         */
        ChatClient(String host) throws IOException {
            super(host, PORT);
        }

        /**
         * Responds when a message is received from the server.  It should be
         * a ForwardedMessage representing something that one of the participants
         * in the chat room is saying.  The message is simply added to the
         * transcript, along with the ID number of the sender.
         */
        protected void messageReceived(Object message) {
            if (message instanceof ForwardedMessage) {  // (no other message types are expected)
                ForwardedMessage bm = (ForwardedMessage)message;
                addToTranscript("#" + bm.senderID + " SAYS:  " + bm.message);
            }
        }

        /**
         * Called when the connection to the client is shut down because of some
         * error message.  (This will happen if the server program is terminated.)
         */
        protected void connectionClosedByError(String message) {
            addToTranscript("Sorry, communication has shut down due to an error:\n     " + message);
            sendButton.setEnabled(false);
            messageInput.setEnabled(false);
            messageInput.setEditable(false);
            messageInput.setText("");
            connected = false;
            connection = null;
        }

        /**
         * Posts a message to the transcript when someone joins the chat room.
         */
        protected void playerConnected(int newPlayerID) {
            addToTranscript("Someone new has joined the chat room, with ID number " + newPlayerID);
        }

        /**
         * Posts a message to the transcript when someone leaves the chat room.
         */
        protected void playerDisconnected(int departingPlayerID) {
            addToTranscript("The person with ID number " + departingPlayerID + " has left the chat room");
        }

    } // end nested class ChatClient

    
    
    private JTextField messageInput;   // For entering messages to be sent to the chat room
    private JButton sendButton;        // Sends the contents of the messageInput.
    private JButton quitButton;        // Leaves the chat room cleanly, by sending a DisconnectMessage

    private JTextArea transcript;      // Contains all messages sent by chat room participant, as well
                                       // as a few additional status messages, such as when a new user arrives.
    
    private ChatClient connection;      // Represents the connection to the Hub; used to send messages;
                                        // also receives and processes messages from the Hub.
    
    private volatile boolean connected; // This is true while the client is connected to the hub.
    
    
    /**
     * Constructor creates the window and starts the process of connecting
     * to the hub; the actual connection is done in a separate thread.
     * @param host  The IP address or host name of the computer where the server is running.
     */
    private ChatRoomWindow(final String host) {
        super("Chat Room");
        setBackground(Color.BLACK);
        setLayout(new BorderLayout(2,2));
        transcript = new JTextArea(30,60);
        transcript.setLineWrap(true);
        transcript.setWrapStyleWord(true);
        transcript.setMargin(new Insets(5,5,5,5));
        transcript.setEditable(false);
        add(new JScrollPane(transcript), BorderLayout.CENTER);
        sendButton = new JButton("send");
        quitButton = new JButton("quit");
        messageInput = new JTextField(40);
        messageInput.setMargin(new Insets(3,3,3,3));
        ActionHandler ah = new ActionHandler();
        sendButton.addActionListener(ah);
        quitButton.addActionListener(ah);
        messageInput.addActionListener(ah);
        sendButton.setEnabled(false);
        messageInput.setEditable(false);
        messageInput.setEnabled(false);
        JPanel bottom = new JPanel();
        bottom.setBackground(Color.LIGHT_GRAY);
        bottom.add(new JLabel("You say:"));
        bottom.add(messageInput);
        bottom.add(sendButton);
        bottom.add(Box.createHorizontalStrut(30));
        bottom.add(quitButton);
        add(bottom,BorderLayout.SOUTH);
        pack();
        addWindowListener( new WindowAdapter() { // calls doQuit if user closes window
            public void windowClosing(WindowEvent e) {
                doQuit();
            }
        });
        new Thread() {
                // This is a thread that opens the connection to the server.  Since
                // that operation can block, it's not done directly in the constructor.
                // Once the connection is established, the user interface elements are
                // enabled so the user can send messages.  The Thread dies after
                // the connection is established or after an error occurs.
            public void run() {
                try {
                    addToTranscript("Connecting to " + host + " ...");
                    connection = new ChatClient(host);
                    connected = true;
                    messageInput.setEditable(true);
                    messageInput.setEnabled(true);
                    sendButton.setEnabled(true);
                    messageInput.requestFocus();
                }
                catch (IOException e) {
                    addToTranscript("Connection attempt failed.");
                    addToTranscript("Error: " + e);
                }
            }
        }.start();
    }
    
    
    /**
     * Adds a string to the transcript area, followed by a blank line.
     */
    private void addToTranscript(String message) {
        transcript.append(message);
        transcript.append("\n\n");
            // The following line is a nasty kludge that was the only way I could find to force
            // the transcript to scroll so that the text that was just added is visible in
            // the window.  Without this, text can be added below the bottom of the visible area
            // of the transcript.
        transcript.setCaretPosition(transcript.getDocument().getLength());
    }
    
    
    /**
     * Called when the user clicks the Quit button or closes
     * the window by clicking its close box.
     */
    private void doQuit() {
        if (connected)
            connection.disconnect();  // Sends a DisconnectMessage to the server.
        dispose();
        try {
            Thread.sleep(1000); // Time for DisconnectMessage to actually be sent.
        }
        catch (InterruptedException e) {
        }
        System.exit(0);
    }

    
    /**
     * Defines the object that handles all ActionEvents for the program.
     */
    private class ActionHandler implements ActionListener {
        public void actionPerformed(ActionEvent evt) {
            Object src = evt.getSource();
            if (src == quitButton) {  // Disconnect from the server and end the program.
                doQuit();
            }
            else if (src == sendButton || src == messageInput) {
                   // Send the string entered by the user as a message
                   // to the Hub, using the ChatClient that handles communication
                   // for this ChatRoomWindow.  Note that the string is not added
                   // to the transcript here.  It will get added after the Hub
                   // receives the message and broadcasts it to all clients,
                   // including this one.
                String message = messageInput.getText();
                if (message.trim().length() == 0)
                    return;
                connection.send(message);
                messageInput.selectAll();
                messageInput.requestFocus();
            }
        }
    }
    

}