/*
   @See License.txt@
    */
   
   package spellcast.ui;
   
   import java.awt.BorderLayout;
   import java.awt.GridBagConstraints;
   import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.beans.PropertyChangeListener;
  import java.io.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.File;
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.net.InetAddress;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  
  import javax.swing.BorderFactory;
  import javax.swing.ComboBoxModel;
  import javax.swing.DefaultComboBoxModel;
  import javax.swing.JButton;
  import javax.swing.JComboBox;
  import javax.swing.JDialog;
  import javax.swing.JFrame;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.JTextField;
  import javax.swing.event.SwingPropertyChangeSupport;
  import org.apache.log4j.Logger;
  import spellcast.net.NetConstants;
  import spellcast.util.TextUtil;
  
  /***
   * The New Game Dialog allows the user to create a new spellcast server.
   * <p>
   * A JComboBox is displayed with the label "Game Name" into which a game name
   * can be entered.  By default the values will be the read from the file 
   * <b>user.home</b>/.spellcast/GameNames.txt.  The format of this file is described at the 
   * end of this document.
   * <p>
   * A JText field is displayed with the label "Server Address" into which a manual address
   * can be entered.  By default the value of <code>InetAddress.getLocalHost</code>, a colon, and 
   * <code>NetConstants.SPELLCAST_NET_DEFAULT_PORT</code> will be displayed.
   * When a new value is filled in the port is optional and will default to the
   * <code>NetConstants.SPELLCAST_NET_DEFAULT_PORT</code>
   * <p>
   * In the South area are two buttons for "Create" and "Cancel".
   * <p>
   * Format of <b>user.home</b>/.spellcast/GameNames.txt:<br>
   * The purpose of this file is to retain the 10 most popular 
   * choice of game names for this user.<br>
   * The file consists of at most 10 lines.<br>
   * Each line is of the form: <number of uses> <game name>
   * The number of uses indicates how many times this game name has been used.<br>
   * The game name can contain any character and is limited to be 32 characters.<br>
   * The file is written so that each line is sorted into most used to least used<br> 
   * <p>
   * This class will fire NEW_GAME_PROP property change events.
   * @author Barrie Treloar
   */
  public class NewGameDialog extends JDialog implements UIProperties {
      private static final int MAX_GAME_NAMES = 10;
      private static final int MAX_GAME_NAME_STRING_LENGTH = 32;
  
      private JButton c_create;
      private JButton c_cancel;
      private JComboBox c_gameName;
      private JTextField c_serverAddress;
      private ArrayList mostRecentUsedGameNames = new ArrayList(MAX_GAME_NAMES);
      private File mostRecentUsedGameNamesFile =
          new File(System.getProperty("user.home") + "/.spellcast/GameNames.txt");
  
      private SwingPropertyChangeSupport propertySupport;
  
      private static final Logger logger = Logger.getLogger("client.connect");
  
      public NewGameDialog() {
          super((JFrame) null, "Create Spellcast Game", false);
  
          propertySupport = new SwingPropertyChangeSupport(this);
  
          createSouthPanel();
          createCenterPanel();
          pack();
      }
  
      public void addPropertyChangeListener(PropertyChangeListener listener) {
          propertySupport.addPropertyChangeListener(listener);
      }
  
      public void removePropertyChangeListener(PropertyChangeListener listener) {
          propertySupport.removePropertyChangeListener(listener);
     }
 
     private ComboBoxModel loadMostRecentUsedGameNames() {
         DefaultComboBoxModel result = new DefaultComboBoxModel();
         BufferedReader r = null;
 
         try {
             if (mostRecentUsedGameNamesFile.exists()) {
                 r = new BufferedReader(new FileReader(mostRecentUsedGameNamesFile));
                 String line = null;
                 // Only read at most 10 lines.
                 for (int i = 0; i < 10 && (line = r.readLine()) != null; i++) {
                     // Ensure line in correct format ( <number><space><string> )
                     int numberOfUses = TextUtil.getNumberOfUses(line);
                     String gameName = TextUtil.getGameName(line);
                     if (gameName.length() > MAX_GAME_NAME_STRING_LENGTH) {
                         gameName = gameName.substring(0, MAX_GAME_NAME_STRING_LENGTH);
                         logger.warn(
                             "Truncating game name that exceeds max length of "
                                 + MAX_GAME_NAME_STRING_LENGTH);
                     }
                     if (numberOfUses == -1 || gameName == null) {
                         logger.warn(
                             "Malformed line (" + i + ") expecting format of " + "<number><space><string>");
                     }
                     else {
                         mostRecentUsedGameNames.add(numberOfUses + " " + gameName);
                     }
                 }
                 Collections.sort(mostRecentUsedGameNames, new GameNameComparator());
 
                 Iterator i = mostRecentUsedGameNames.iterator();
                 while (i.hasNext()) {
                     line = (String) i.next();
                     result.addElement(TextUtil.getGameName(line));
                 }
             }
         }
         catch (Exception e) {
             logger.error("Could not load Most Recent Used Game Names.", e);
         }
         finally {
             try {
                 if (r != null) {
                     r.close();
                 }
             }
             catch (Exception e) {
                 logger.error("Unexpected error in Reader.close().", e);
             }
         }
 
         return result;
     }
 
     private void saveMostRecentUsedGameNames(ComboBoxModel model) {
         BufferedWriter w = null;
 
         try {
             // Creates only if does not exist
             mostRecentUsedGameNamesFile.createNewFile();
 
             if (mostRecentUsedGameNamesFile.exists()) {
                 // Check to see if the game name has already been used before
                 // If it has then re-add it to the list after incrementing the numberOfUses
                 boolean gameNotInList = true;
                 String currentGameName = (String) model.getSelectedItem();
                 Iterator i = mostRecentUsedGameNames.iterator();
                 while (i.hasNext()) {
                     String line = (String) i.next();
                     String gameName = TextUtil.getGameName(line);
                     if (gameName.equals(currentGameName)) {
                         int numberOfUses = TextUtil.getNumberOfUses(line) + 1;
                         i.remove();
                         mostRecentUsedGameNames.add(numberOfUses + " " + gameName);
                         gameNotInList = false;
                         break;
                     }
                 }
                 if (gameNotInList) {
                     mostRecentUsedGameNames.add("1 " + currentGameName);
                 }
                 Collections.sort(mostRecentUsedGameNames, new GameNameComparator());
                 // trim the list to the max size
                 while (mostRecentUsedGameNames.size() > MAX_GAME_NAMES) {
                     mostRecentUsedGameNames.remove(mostRecentUsedGameNames.size() - 1);
                 }
 
                 w = new BufferedWriter(new FileWriter(mostRecentUsedGameNamesFile));
                 i = mostRecentUsedGameNames.iterator();
                 while (i.hasNext()) {
                     String line = (String) i.next();
                     w.write(line);
                     w.newLine();
                 }
             }
         }
         catch (Exception e) {
             logger.error("Could not save Most Recent Used Game Names.", e);
         }
         finally {
             try {
                 if (w != null) {
                     w.flush();
                     w.close();
                 }
             }
             catch (Exception e) {
                 logger.error("Unexpected error in Writer.close().", e);
             }
         }
 
     }
 
     private void createSouthPanel() {
         JPanel p = new JPanel();
         GridBagLayout gridbag = new GridBagLayout();
         p.setLayout(gridbag);
         GridBagConstraints c = new GridBagConstraints();
         // Common constraints
         c.insets = new Insets(4, 4, 4, 4);
         c.fill = GridBagConstraints.HORIZONTAL;
 
         c.weightx = 1.0;
         JLabel empty = new JLabel(" ");
         gridbag.setConstraints(empty, c);
         p.add(empty);
 
         c.weightx = 0.0;
         c_create = new JButton("Create");
         c_create.setDefaultCapable(true);
         getRootPane().setDefaultButton(c_create);
         c_create.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
                 String theGameName = (String) c_gameName.getSelectedItem();
                 if (theGameName == null || theGameName.equals("")) {
                     theGameName = "Spellcast";
                     c_gameName.addItem(theGameName);
                     c_gameName.setSelectedItem(theGameName);
                 }
                 String serverAddressString = c_serverAddress.getText().trim();
                 setVisible(false);
 
                 NewGameEvent evt = new NewGameEvent(theGameName, serverAddressString);
                 propertySupport.firePropertyChange(NEW_GAME_PROP, null, evt);
             }
         });
         gridbag.setConstraints(c_create, c);
         p.add(c_create);
 
         c_cancel = new JButton("Cancel");
         c_cancel.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
                 setVisible(false);
             }
         });
         gridbag.setConstraints(c_cancel, c);
         p.add(c_cancel);
 
         getContentPane().add(p, BorderLayout.SOUTH);
     }
 
     private void createCenterPanel() {
         JPanel p = new JPanel();
         p.setBorder(BorderFactory.createEmptyBorder(4, 4, 4, 4));
 
         GridBagLayout gridbag = new GridBagLayout();
         p.setLayout(gridbag);
         GridBagConstraints c = new GridBagConstraints();
         // Common constraints
         c.insets = new Insets(4, 4, 4, 4);
 
         JLabel gameNameLabel = new JLabel("Game Name");
         gridbag.setConstraints(gameNameLabel, c);
         p.add(gameNameLabel);
 
         c.gridwidth = GridBagConstraints.REMAINDER;
         c.anchor = GridBagConstraints.WEST;
         c_gameName = new JComboBox(loadMostRecentUsedGameNames());
         c_gameName.setEditable(true);
         gridbag.setConstraints(c_gameName, c);
         p.add(c_gameName);
         gameNameLabel.setLabelFor(c_gameName);
 
         c.gridwidth = GridBagConstraints.RELATIVE;
         c.anchor = GridBagConstraints.CENTER;
         JLabel serverAddressLabel = new JLabel("Server Address");
         gridbag.setConstraints(serverAddressLabel, c);
         p.add(serverAddressLabel);
 
         c.gridwidth = GridBagConstraints.REMAINDER;
         c.anchor = GridBagConstraints.WEST;
         c_serverAddress = new JTextField(12);
         try {
             c_serverAddress.setText(
                 InetAddress.getLocalHost().getHostAddress()
                     + ":"
                     + NetConstants.SPELLCAST_NET_DEFAULT_PORT);
         }
         catch (Exception e) {
             logger.error("Could not get Localhost for setting Server Address.", e);
         }
         gridbag.setConstraints(c_serverAddress, c);
         p.add(c_serverAddress);
         serverAddressLabel.setLabelFor(c_serverAddress);
 
         getContentPane().add(p, BorderLayout.CENTER);
     }
 
     /***
      * This comparator imposes the correct order of GameNames based upon
      * how many uses the Game Name has.  The order is most uses first to least uses last.
      * It Compares its two arguments for order. 
      * Returns a negative integer, zero, or a positive integer
      * as the first argument is less than, equal to, or greater than the second.
      * Note: this comparator imposes orderings that are inconsistent with equals.
      */
     class GameNameComparator implements Comparator {
         public int compare(Object o1, Object o2) {
             int result = 0;
 
             String s1 = (String) o1;
             String s2 = (String) o2;
 
             int uses1 = TextUtil.getNumberOfUses(s1);
             int uses2 = TextUtil.getNumberOfUses(s2);
 
             // o1 is greater than o2 so it should go first, hence -1
             if (uses1 > uses2) {
                 result = -1;
             }
             else
                 if (uses1 < uses2) {
                     result = 1;
                 }
                 else {
                     result = 0;
                 }
 
             return result;
         }
     }
 
 }