/*
   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 25-feb-2004
   *
   * Copyright (c)2003 Grid Systems
   */
  package com.gridsystems.config.modules.jvm;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.text.MessageFormat;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.MissingResourceException;
  import java.util.Properties;
  import java.util.ResourceBundle;
  
  import com.gridsystems.config.ConfiguratorModel;
  
  /**
   * Data Model for the JVM Configurator.
   *
   * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
   * @version 1.0
   */
  public class JVMConfigModel implements ConfiguratorModel {
  
    /**
     * Default max heap size.
     */
    public static final String DEFAULT_HEAP_MAX = "256";
  
    /**
     * Default min heap size.
     */
    public static final String DEFAULT_HEAP_MIN = "128";
  
    /**
     * Default thread stack size.
     */
    public static final String DEFAULT_STACK_SIZE = "";
  
    /**
     * Default proxy usage mode.
     */
    public static final String DEFAULT_USE_PROXY = "false";
  
    /**
     * Default proxy host name or IP address.
     */
    public static final String DEFAULT_PROXY_HOST = "";
  
    /**
     * Default proxy port.
     */
    public static final String DEFAULT_PROXY_PORT = "";
  
    /**
     * Default remote debug mode.
     */
    public static final String DEFAULT_DEBUG_MODE = "false";
  
    /**
     * Default remote debug port.
     */
    public static final String DEFAULT_DEBUG_PORT = "8000";
  
    /**
     * Default initial suspension flag in debug mode.
     */
    public static final String DEFAULT_DEBUG_SUSPEND = "true";
  
    /**
     * Path to the configuration file.
     */
    public static final String DEFAULT_CONFIG_PATH = "../conf/jvm.properties";
  
   /**
    * Model fields directly editable through the configurator UI.
    */
   private Properties values;
 
   /**
    * System properties to add to the command-line.
    */
   private Properties props;
 
   /**
    * Extra JVM flags to set in the command-line, different from system properties or
    * those covered by values.
    */
   private HashSet<String> extraFlags;
 
   /**
    * JVM command-line flags to set from values.
    */
   private HashSet<String> flags;
 
   /**
    * Path to config File.
    */
   private final String configFilePath;
 
   /**
    * Creates a new instance.
    * @param configFilePath Path to file where read properties.
    */
   public JVMConfigModel(String configFilePath) {
     this.configFilePath = configFilePath;
     values = new Properties();
     props = new Properties();
     extraFlags = new HashSet<String>();
   }
 
   /**
    * Creates a new instance.
    *
    * @param values     The field values.
    * @param props      The system properties
    * @param extraFlags The extra flags set
    */
   /*
   public JVMConfigModel(Properties values, Properties props, HashSet<String> extraFlags) {
     this.values = values;
     this.props = props;
     this.extraFlags = extraFlags;
   }
   */
 
   /**
    * Sets a system property.
    *
    * @param key   The system property name
    * @param value The system property value
    */
   public void setProperty(String key, String value) {
     this.props.setProperty(key, value);
   }
 
   /**
    * Sets a field value.
    *
    * @param key   The field name
    * @param value The field value
    */
   public void setValue(String key, Object value) {
     this.values.setProperty(key, value.toString());
   }
 
   /**
    * Gets a field value.
    *
    * @param key The field name
    * @param def The default field value
    * @return The field value
    */
   public String getValue(String key, String def) {
     return this.values.getProperty(key, def);
   }
 
   /**
    * Gets a system property.
    *
    * @param key The system property name
    * @param def The system property default value
    * @return The system property value
    */
   public String getProperty(String key, String def) {
     return this.props.getProperty(key, def);
   }
 
   /**
    * Adds a collection of command-line flags to the current set.
    *
    * @param flags The flags collection
    */
   public void addFlags(Collection<String> flags) {
     this.extraFlags.addAll(flags);
   }
 
   /**
    * Gets the JVM heap minimum size.
    *
    * @return The JVM heap minimum size
    */
   public String getMinHeap() {
     return this.getValue("heap.min", DEFAULT_HEAP_MIN);
   }
 
   /**
    * Gets the JVM heap maximum size.
    *
    * @return The JVM heap maximum size
    */
   public String getMaxHeap() {
     return this.getValue("heap.max", DEFAULT_HEAP_MAX);
   }
 
   /**
    * Gets the JVM thread-stack size.
    *
    * @return The JVM thread-stack size
    */
   public String getStackSize() {
     return this.getValue("stack.size", DEFAULT_STACK_SIZE);
   }
 
   /**
    * Gets whether proxy use is enabled or not.
    *
    * @return "true" if enabled; "false" if not
    */
   public String getUseProxy() {
     return this.getValue("proxy.use", DEFAULT_USE_PROXY);
   }
 
   /**
    * Gets the proxy host name / IP.
    *
    * @return The proxy host name or IP address
    */
   public String getProxyHost() {
     return this.getValue("proxy.host", DEFAULT_PROXY_HOST);
   }
 
   /**
    * Gets the proxy port.
    *
    * @return The proxy port
    */
   public String getProxyPort() {
     return this.getValue("proxy.port", DEFAULT_PROXY_PORT);
   }
 
   /**
    * Gets whether debug mode is enabled or not.
    *
    * @return "true" if remote debugging is enabled; "false" if not
    */
   public String getDebugEnabled() {
     return this.getValue("debug.enable", DEFAULT_DEBUG_MODE);
   }
 
   /**
    * Gets the remote debug port.
    *
    * @return The debug port the debugger will connect to
    */
   public String getDebugPort() {
     return this.getValue("debug.port", DEFAULT_DEBUG_PORT);
   }
 
   /**
    * Gets whether the server JVM will start suspended.
    *
    * @return "true" if the JVM will start suspended; "false" if not
    */
   public String getDebugSuspend() {
     return this.getValue("debug.suspend", DEFAULT_DEBUG_SUSPEND);
   }
 
   /**
    * Copies the specified model data into this instance. Only "editable" fields are
    * copied. The extraFlags set is not included, as it is not directly editable from
    * this configurator views.
    *
    * @param src The source model
    */
   public void copyModel(JVMConfigModel src) {
     this.values = (Properties)src.values.clone();
     this.props  = (Properties)src.props.clone();
   }
 
   /**
    * @see com.gridsystems.config.ConfiguratorModel#load()
    */
   public void load() {
     File f = new File(this.configFilePath);
     if (f.exists()) {
       FileInputStream fis = null;
       try {
         fis = new FileInputStream(f);
         Properties p = new Properties();
         p.load(fis);
 
         this.props = extractProperties(p, "system.");
         this.extraFlags = extractSet(p, "flags.");
         this.values = p;
       } catch (Exception e) {
         e.printStackTrace();
       } finally {
         try { fis.close(); } catch (Exception ignore) { }
       }
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void store() throws IOException {
     File f = new File(this.configFilePath);
     f.getParentFile().mkdir();
     Properties p = new Properties();
     embed(p, "", values);
     embed(p, "system.", props);
     embed(p, "flags.", extraFlags);
 
     FileOutputStream fos = null;
     try {
       fos = new FileOutputStream(f);
       p.store(fos, "JVM Properties");
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       try { fos.close(); } catch (Exception ignore) { }
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void apply() throws IOException {
     buildFlags();
     writeBat();
     writeSh();
   }
 
   /**
    * Writes the DOS shell script for setting the correct JVM options.
    *
    * @throws IOException If an error occurs
    */
   private void writeBat() throws IOException {
     File f = new File("setenv.bat");
     PrintWriter out = null;
     try {
       out = new PrintWriter(new FileWriter(f));
       out.println("@echo off");
       out.println("set JAVA_OPTS=" + getJavaOpts());
     } finally {
       if (out != null) {
         out.close();
       }
     }
   }
 
   /**
    * Writes the Unix shell script for setting the correct JVM options.
    *
    * @throws IOException If an error occurs
    */
   private void writeSh() throws IOException {
     File f = new File("setenv.sh");
     PrintWriter out = null;
     try {
       out = new PrintWriter(new FileWriter(f));
       out.println("#!/bin/sh");
       out.println("JAVA_OPTS=\"" + getJavaOpts() + "\"");
       out.println("export JAVA_OPTS");
     } finally {
       if (out != null) {
         out.close();
       }
     }
   }
 
   /**
    * Builds the JVM command-line flags.
    *
    * @return The command-line flags
    */
   private String getJavaOpts() {
     StringBuffer sb = new StringBuffer();
     boolean first = true;
     for (Iterator it = flags.iterator(); it.hasNext();) {
       String flag = (String)it.next();
       if (first) {
         first = false;
       } else {
         sb.append(' ');
       }
       sb.append(flag);
     }
     return sb.toString();
   }
 
   /**
    * Builds the contents of the flags set, from data in the values set.
    */
   private void buildFlags() {
     flags = new HashSet<String>();
     flags.addAll(extraFlags);
 
     for (Iterator it = props.keySet().iterator(); it.hasNext();) {
       String key = (String)it.next();
       String value = props.getProperty(key);
       // values containing blank spaces must be surrounded with "
       if (value.indexOf(" ") >= 0) {
         flags.add("-D" + key + "=\"" + value + "\"");
       } else {
         flags.add("-D" + key + "=" + value);
       }
     }
 
     String value = formatValue("heap.min", "-Xms{0}M");
     if (value != null) {
       flags.add(value);
     }
 
     value = formatValue("heap.max", "-Xmx{0}M");
     if (value != null) {
       flags.add(value);
     }
 
     value = formatValue("stack.size", "-Xss{0}M");
     if (value != null) {
       flags.add(value);
     }
 
     value = values.getProperty("debug.enable");
     if ("true".equals(value)) {
       flags.add("-Xdebug");
       String port = values.getProperty("debug.port");
       boolean suspend = "true".equals(values.getProperty("debug.suspend"));
       flags.add("-Xrunjdwp:transport=dt_socket,address=" + port
                 + ",server=y,suspend=" + (suspend ? "y" : "n"));
       flags.add("-Djpda.port=" + port);
     }
 
     value = values.getProperty("proxy.use");
     if ("true".equals(value)) {
       flags.add("-DproxySet=true");
       flags.add("-DproxyHost=" + values.getProperty("proxy.host"));
       flags.add("-DproxyPort=" + values.getProperty("proxy.port"));
     }
   }
 
   /**
    * Formats the field value with the specified name using the specified pattern.
    *
    * @param key    The field name
    * @param format The formatting pattern
    * @return The formatted string
    */
   private String formatValue(String key, String format) {
     String value = values.getProperty(key);
     if (value == null) {
       return null;
     }
     value = value.trim();
     if (value.equals("")) {
       return null;
     }
 
     return MessageFormat.format(format, new Object[] { value });
   }
 
   /**
    * Adds all items in src to dest, adding the specified prefix to the keys.
    *
    * @param dest   The destination Properties instance
    * @param prefix The prefix to set
    * @param src    The source Properties instance
    */
   private void embed(Properties dest, String prefix, Properties src) {
     for (Iterator it = src.keySet().iterator(); it.hasNext();) {
       String key = (String)it.next();
       String value = src.getProperty(key);
       dest.setProperty(prefix + key, value);
     }
   }
 
   /**
    * Adds all items in src to dest, adding the specified prefix to the keys.
    *
    * @param dest   The destination Properties instance
    * @param prefix The prefix to set
    * @param src    The source set
    */
   private void embed(Properties dest, String prefix, HashSet src) {
     int index = 0;
     for (Iterator it = src.iterator(); it.hasNext();) {
       String item = (String)it.next();
       dest.setProperty(prefix + "item" + index, item);
       index += 1;
     }
   }
 
   /**
    * Gets a Properties instance containing the values previously embedded in src with the
    * specified prefix.
    *
    * @param src    The source Properties instance
    * @param prefix The embedding prefix
    * @return A Properties instance containing the previously embedded items
    */
   private Properties extractProperties(Properties src, String prefix) {
     Properties dest = new Properties();
 
     for (Iterator it = src.keySet().iterator(); it.hasNext();) {
       String key = (String)it.next();
       if (key.startsWith(prefix)) {
         String value = src.getProperty(key);
         String destKey = key.substring(prefix.length());
         dest.setProperty(destKey, value);
         it.remove();
       }
     }
 
     return dest;
   }
 
   /**
    * Gets a HashSet instance containing the values previously embedded in src with the
    * specified prefix.
    *
    * @param src    The source Properties instance
    * @param prefix The embedding prefix
    * @return A HashSet instance containing the previously embedded items
    */
   private HashSet<String> extractSet(Properties src, String prefix) {
     HashSet<String> dest = new HashSet<String>();
 
     for (Iterator it = src.keySet().iterator(); it.hasNext();) {
       String key = (String)it.next();
       if (key.startsWith(prefix)) {
         String value = src.getProperty(key);
         dest.add(value);
         it.remove();
       }
     }
 
     return dest;
   }
 
   /**
    * Validate data of this Model.
    *
    * @throws IOException In case of invalid data
    */
   public void validate() throws IOException {
     IOException ioe = null;
 
     int minValue;
     try {
       minValue = getMemoryValue(getMinHeap());
     } catch (Exception e) {
       Object[] params = new Object[] {getMinHeap()};
       ioe = new IOException(getString("errors.restoreHeadMin", params));
       minValue = Integer.parseInt(DEFAULT_HEAP_MIN);
       setValue("heap.min", DEFAULT_HEAP_MIN);
     }
     int maxValue;
     try {
       maxValue = getMemoryValue(getMaxHeap());
     } catch (Exception e) {
       Object[] params = new Object[] {getMinHeap()};
       ioe = new IOException(getString("errors.restoreHeadMax", params));
       maxValue = Integer.parseInt(DEFAULT_HEAP_MAX);
       setValue("heap.max", DEFAULT_HEAP_MAX);
     }
     //Check memory values
     if (minValue > maxValue) {
       if (ioe == null) {
         ioe = new IOException(getString("errors.minGreaterMax"));
       }
     }
     if (ioe != null) {
       throw ioe;
     }
   }
 
   /**
    * Gets a localized string.
    *
    * @param key The i18n key
    * @return    The localized string, or null if none found for key
    * @throws NullPointerException if the bundle is not set
    */
   public String getString(String key) {
     ResourceBundle bundle = JVMConfigurator.getInstance().getBundle();
     if (bundle == null) {
       throw new NullPointerException("Bundle not set");
     }
 
     try {
       return bundle.getString(key);
     } catch (MissingResourceException e) {
       return null;
     }
   }
 
   /**
    * 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) {
     ResourceBundle bundle = JVMConfigurator.getInstance().getBundle();
     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";
     }
   }
 
   /**
    * It converts the string memory to its integer bytes memory
    * value.
    *
    * @param memory Text memory value.
    * @return Number of bytes of the memory value.
    */
   private int getMemoryValue(String memory) {
     if (memory == null || memory.equals("")) {
       //Empty memory
       return 0;
     }
     //  MegaBytes value
     return Integer.parseInt(memory);
   }
 }