/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  
  package com.gridsystems.config.tools.console;
  
  import java.io.IOException;
  import java.text.MessageFormat;
  import java.util.ResourceBundle;
  
  import com.gridsystems.config.ConsoleConfiguratorView;
  import com.gridsystems.config.app.UI;
  
  /**
   * Asks the user to chose between a list of valid values.
   *
   * @author SJM.
   */
  public class SelectionField extends Field implements ConsoleViewAction {
  
    /**
     * Pattern to use for field display.
     */
    protected String linePattern;
  
    /**
     * Pattern to use for value display and parsing.
     */
    protected String valuePattern;
  
    /**
     * The value.
     */
    protected Object value;
  
    /**
     * A cached instance of the value formatter.
     */
    protected MessageFormat valueFormatter = null;
  
    /**
     * The list of allowed values.
     */
    private String[] values = null;
  
    /**
     * Creates a new instance.
     *
     * @param bundle       The resource bundle
     * @param linePattern  The pattern for field display
     * @param valuePattern The pattern for value display and parsing
     * @param values a String[] with the list of allowed values.
     */
    public SelectionField(ResourceBundle bundle, String linePattern,
      String valuePattern, String[] values) {
      super(bundle);
      this.linePattern = linePattern;
      this.valuePattern = valuePattern;
  
      if (valuePattern != null) {
        valueFormatter = new MessageFormat(valuePattern);
      }
      if (values != null) {
        this.values = values;
      } else {
        this.values = new String[0];
      }
    }
  
    /**
     * Asks the user for the new value for this field. The empty string means to
     * maintain the current value.
     * <p>
     * To specify an empty value, in trimmed fields a blank space can be used
     * <p>
     * This method does not return until the default value or a valid one is
     * specified.
     *
     * @param view The view where this field is located
     * @return     It always returns true, as the edition does not imply an
     *             exit from the view execution loop.
     * @see com.gridsystems.config.tools.console.ConsoleViewAction
     */
    public boolean execute(ConsoleConfiguratorView view) {
      while (true) {
        try {
         String line = readLine();
         if (line.equals("")) {
           return true;
         }
 
         line = line.trim();
         if (line.length() == 1) {
           int index = line.charAt(0) - 'a';
           if ((index >= 0) && (index < this.values.length)) {
             setStringValue(this.values[index]);
             return true;
           }
         }
       } catch (Exception e) {
         e.printStackTrace();
       }
     }
   }
 
   /**
    * Reads a line of text from the console.
    *
    * @return The read text
    * @throws IOException If an error occurs while reading from the console
    */
   protected String readLine() throws IOException {
     if (value != null) {
       String currentValuePattern =
         UI.getString("console.readLine.currentValue");
       String currentValue = MessageFormat.format(
         currentValuePattern, new Object[]{getStringValue()});
 
       System.out.println(currentValue);
     }
 
     char index = 'a';
     for (int i = 0; i < this.values.length; i++) {
       System.out.println(index + ") " + this.values[i]);
       index++;
     }
 
     String line =
       ConsoleTools.readLine(UI.getString("console.readLine.newValue"));
     return line;
   }
 
   /**
    * {@inheritDoc}
    */
   public String getKeyMapping() {
     return getString(this.linePattern + ".keyMap");
   }
 
   /**
    * {@inheritDoc}
    */
   public String[] getContents() {
     String[] contents = new String[1];
 
     // Constructs the actual line pattern
     StringBuffer pattern = new StringBuffer();
     String key = getKeyMapping();
     if (key != null) {
       pattern.append(" ").append(key).append(". ");
     }
 
     pattern.append(getString(linePattern));
 
     String s = getStringValue();
     contents[0] = MessageFormat.format(pattern.toString(), new Object[] { s });
     return contents;
   }
 
   /**
    * Gets this field value.
    *
    * @return The value
    */
   public Object getValue() {
     return value;
   }
 
   /**
    * Sets the value of this field.
    *
    * @param value The new value
    */
   public void setValue(Object value) {
     this.value = value;
   }
 
   /**
    * Gets the field value as a string.
    *
    * @return A string containing this field value
    */
   protected String getStringValue() {
     if (value == null) {
       return "";
     } else if (valueFormatter == null) {
       return value.toString();
     } else {
       return valueFormatter.format(new Object[] { value });
     }
   }
 
   /**
    * Sets the field value from the specified string. If not null, the value pattern
    * will be used for parsing the text
    *
    * @param newValue The text containing the new value
    */
   protected void setStringValue(String newValue) {
     if (valueFormatter == null) {
       value = newValue;
     } else {
       try {
         value = valueFormatter.parse(newValue)[0];
       } catch (Exception e) {
         e.printStackTrace();
       }
     }
   }
 }