/*
   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
  */
  
  /*
   * Project: KernelConfigurator
   * Created on 03-mar-2004
   *
   * Copyright (c)2003 Grid Systems
   */
  package com.gridsystems.config.tools.console;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.ResourceBundle;
  import java.util.MissingResourceException;
  import java.text.MessageFormat;
  
  import com.gridsystems.config.Configurator;
  import com.gridsystems.config.ConsoleConfiguratorView;
  import com.gridsystems.config.ErrorListener;
  import com.gridsystems.config.app.UI;
  
  /**
   * Base implementation for console views.
   *
   * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
   * @version 1.0
   */
  public abstract class AbstractConsoleView implements ConsoleConfiguratorView,
                                                       ErrorListener {
    /**
     * Default console width.
     */
    private static final int DEFAULT_CONSOLE_WIDTH = 70;
  
    /**
     * Resource bundle to use for message I18N.
     */
    protected ResourceBundle bundle = null;
  
    /**
     * Width of the console view.
     */
    protected int width;
  
    /**
     * Form fields.
     */
    private Object[] form = null;
  
    /**
     * Registered key mappings.
     */
    private Map<String, ConsoleViewAction> keyMappings
      = new HashMap<String, ConsoleViewAction>();
  
    /**
     * Message to show at the bottom line of the view.
     */
    private MessageField messages = new MessageField();
  
    /**
     * The configurator this view is associated to.
     */
    private Configurator config;
  
    /**
     * Creates a new instance with default with and the specified Configuration instance.
     *
     * @param config The configuration instance
     */
    public AbstractConsoleView(Configurator config) {
      this(config, DEFAULT_CONSOLE_WIDTH);
    }
  
    /**
     * Creates a new instance.
     *
     * @param config The configuration to use
     * @param width  The view width
     */
    public AbstractConsoleView(Configurator config, int width) {
      this.bundle = config.getBundle();
     this.width = width;
     this.config = config;
     this.config.setErrorListener(this);
 
     setApplyDiscardMappings(config);
   }
 
   /**
    * Registers the default apply and discard actions linked to the specified
    * configuration instance.
    *
    * @param config The configuration instance which actions will affect to
    */
   public void setApplyDiscardMappings(Configurator config) {
     addKeyMapping(new ApplyAction(config));
     addKeyMapping(new DiscardAction(config));
   }
 
   /**
    * Gets the configurator this view is associated to.
    *
    * @return  The configurator
    */
   public Configurator getConfigurator() {
     return config;
   }
 
   /**
    * @see com.gridsystems.config.ConsoleConfiguratorView#execute()
    */
   public void execute() {
     Object[] localForm = buildForm();
     String sPrompt = UI.getString("console.menu.prompt");
 
     boolean alive = true;
     while (alive) {
       try {
         paintForm(localForm);
         System.out.println();
         String line = ConsoleTools.readLine(sPrompt).toUpperCase();
         ConsoleViewAction action = (ConsoleViewAction)keyMappings.get(line);
         if (action != null) {
           alive = action.execute(this);
         }
       } catch (Exception e) {
         e.printStackTrace();
       }
     }
   }
 
   /**
    * Displays the "view box".
    *
    * @param form The contents of the box
    */
   protected void paintForm(Object[] form) {
     ConsoleTools.clear();
     ConsoleTools.paintBox(getTitle(), form, width);
 
     // Resets the error line
     messages.reset();
   }
 
   /**
    * Creates the contents of the "view box". It adds an Apply/Discard button bar
    * to the bottom of the box after calling to {@link #getContents(java.util.List)}
    *
    * @return An array of objects conforming the "view box" contents, that can be
    *         directly used as an argument by the painBox method in ConsoleTools.
    */
   protected Object[] buildForm() {
     if (form == null) {
       String sApplyText = UI.getString("console.apply.text");
       String sDiscardText = UI.getString("console.discard.text");
 
       ArrayList<Object> items = new ArrayList<Object>();
       getContents(items);
       items.add("-");
       items.add(" [" + sApplyText + "]   [" + sDiscardText + "]");
 
       // Place holders for error messages
       items.add(null);
       items.add(messages);
 
       form = new Object[items.size()];
       items.toArray(form);
     }
     return form;
   }
 
   /**
    * Registers a string with a ConsoleViewAction instance. The action will
    * be executed when the user types the key string.
    *
    * @param key    The associated command string
    * @param action The action to execute when key is typed
    */
   public void addKeyMapping(String key, ConsoleViewAction action) {
     keyMappings.put(key.toUpperCase(), action);
   }
 
   /**
    * Registers action with its own key mapping.
    *
    * @param action The action to execute
    */
   public void addKeyMapping(ConsoleViewAction action) {
     addKeyMapping(action.getKeyMapping(), action);
   }
 
   /**
    * Registers the keymappings of all actions in the specified group field.
    *
    * @param group The group field.
    */
   public void addKeyMapping(GroupField group) {
     ConsoleViewAction[] actions = group.getActions();
     for (int i = 0; i < actions.length; i++) {
       addKeyMapping(actions[i]);
     }
   }
 
   /**
    * Removes the key mapping for the specified action.
    *
    * @param action  the action to remove
    */
   public void removeKeyMapping(ConsoleViewAction action) {
     keyMappings.remove(action.getKeyMapping().toUpperCase());
   }
 
   /**
    * Removes all key mappings in the specified group field.
    *
    * @param group The group field
    */
   public void removeKeyMapping(GroupField group) {
     ConsoleViewAction[] actions = group.getActions();
     for (int i = 0; i < actions.length; i++) {
       removeKeyMapping(actions[i]);
     }
   }
 
   /**
    * Gets an array with the items conforming the contents of the "view box".
    *
    * @param list A list where to put the contents of the box
    */
   protected abstract void getContents(List<Object> list);
 
   /**
    * Creates a ValueField that will share the same bundle as this instance.
    *
    * @param linePattern  The line pattern of the new field
    * @param valuePattern The value pattern of the new field
    * @return The field
    */
   protected ValueField createValueField(String linePattern, String valuePattern) {
     return new ValueField(bundle, linePattern, valuePattern);
   }
 
   /**
    * Creates a SelectionField that will share the same bundle as this instance.
    *
    * @param linePattern a String with the line pattern of the new field.
    * @param valuePattern a String with the value pattern of the new field.
    * @param values a String[] with the list of valid values of the new field.
    *
    * @return the SelectionField created.
    */
   protected SelectionField createSelectionField(
     String linePattern, String valuePattern, String[] values) {
     return new SelectionField(bundle, linePattern, valuePattern, values);
   }
 
   /**
    * Creates a BoolField that will share the same bundle as this instance.
    *
    * @param linePattern The field line pattern
    * @return The field
    */
   protected BoolField createBoolField(String linePattern) {
     return new BoolField(bundle, linePattern);
   }
 
   /**
    * Creates a password field that will share the same bundle as this instance.
    *
    * @param linePattern The field line pattern
    * @return The field
    */
   protected PasswordField createPasswordField(String linePattern) {
     return new PasswordField(bundle, linePattern);
   }
 
   /**
    * Creates a password field that will share the same bundle as this instance.
    *
    * @param linePattern The field line pattern
    * @param value the value
    * @return The field
    */
   protected ConstantField createConstantField(String linePattern, String value) {
     return new ConstantField(bundle, linePattern, value);
   }
   /**
    * Gets a localized string, using the found string as a pattern to be used
    * by a MessageFormat instance.
    *
    * @param key    The key for the localized pattern
    * @param params The parameters for pattern substitution
    * @return       The localized / formatter string
    * @throws NullPointerException if the bundle is not set
    */
   public String getString(String key, Object[] params) {
     if (bundle == null) {
       throw new NullPointerException("Bundle not set");
     }
 
     try {
       String pattern = bundle.getString(key);
       return MessageFormat.format(pattern, params);
     } catch (MissingResourceException e) {
       return key + "#not found";
     }
   }
 
   /**
    * Gets a localized string, using the found string as a pattern to be used
    * by a MessageFormat instance.
    *
    * @param key    The key for the localized pattern
    * @return       The localized / formatter string
    * @throws NullPointerException if the bundle is not set
    */
   public String getString(String key) {
     return getString(key, null);
   }
 
   /**
    * Shows an error message in the bottom line of the view.
    * <p>
    * The message is removed on the next view refresh
    *
    * @param message The error message lines
    */
   public void showError(String[] message) {
     int count = (message == null) ? 0 : message.length;
     if (count == 0) {
       // No message to show
       messages.reset();
     } else {
       String title = UI.getString("messages.error");
       StringBuffer sb = new StringBuffer();
 
       messages.addLine("-");
       for (int i = 0; i < count; i++) {
         sb.setLength(0);
         if (i == 0) {
           sb.append(title).append(": ");
         } else {
           ConsoleTools.fill(sb, ' ', title.length() + 2);
         }
         sb.append(message[i]);
         messages.addLine(sb.toString());
       }
     }
   }
 
   /**
    * Map of current errors in the view.
    */
   Map<String, String> errors = new HashMap<String, String>();
 
   /**
    * {@inheritDoc}
    */
   public void updateError(String id, String msg, boolean add) {
     if (add) {
       System.err.println("ERROR: " + msg);
       errors.put(id, msg);
     } else {
       errors.remove(id);
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void clearErrors() {
     errors.clear();
   }
 
   /**
    * {@inheritDoc}
    */
   public boolean hasErrors() {
     return this.errors.size() == 0;
   }
 }