/*
   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 23-feb-2004
   *
   * Copyright (c)2003 Grid Systems
   */
  package com.gridsystems.config.app;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.lang.reflect.Method;
  import java.net.URL;
  import java.text.MessageFormat;
  import java.util.Collection;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Locale;
  import java.util.Map;
  import java.util.ResourceBundle;
  import java.util.StringTokenizer;
  
  import javax.swing.UIManager;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import com.gridsystems.config.Configurator;
  import com.gridsystems.config.modules.jvm.JVMConfigurator;
  import com.gridsystems.config.tools.console.ConsoleTools;
  import com.gridsystems.utils.AWTUtils;
  
  /**
   * Root class and provider for user interface delegation. Each subclass is
   * specialized in a specific type of user interface environment.
   *
   * @author Rodrigo Ruiz Aguayo
   * @version 1.0
   */
  public abstract class UI {
  
    /**
     * Help text to show in the console.
     */
    private static final String[] HELP_TEXT = {
      "Valid options:",
      "-swing      Executes in GUI mode",
      "-console    Executes in text mode",
      "-silent     Executes with no user interface",
      "-locale:xx  Sets the locale to xx (en, es_ES, ...). ",
      "            Defaults to the user environment settings",
      "-username:xx The name of the user that will execute the configured server",
      "",
      "Text mode flags:",
      "-ansi       If the terminal supports ANSI escape sequences",
      "-noacs      If line characters are not correctly displayed",
      "",
      "Swing mode flags:",
      "-laf:x      Sets the look and feel to use",
      "            Valid values are: system, cross, metal, gtk, motif and windows",
      "",
      "Other flags:",
      "-expert     Turns on the advanced configuration mode. Ignored in silent mode"
    };
  
    /**
     * For this class logs.
     */
    private static Log log = LogFactory.getLog(UI.class);
  
    /**
     * The application resource bundle.
     */
    private static ResourceBundle bundle = ResourceBundle.getBundle("config");
  
    /**
     * Specifies the Null UI.
     */
    public static final int NONE = 0;
  
    /**
     * Specifies the Swing UI.
    */
   public static final int SWING = 1;
 
   /**
    * Specified the Console UI.
    */
   public static final int CONSOLE = 2;
 
   /**
    * Class names for each declared constant.
    */
   private static final String[] CLASS_NAMES = {
     "com.gridsystems.config.app.NullUI",
     "com.gridsystems.config.app.SwingUI",
     "com.gridsystems.config.app.ConsoleUI"
   };
 
   /**
    * Flag that controls the "Expert" mode.
    */
   private static boolean expertMode = false;
 
   /**
    * The list of discovered configurators.
    */
   protected static Configurator[] configurators = null;
 
   /**
    * Default constructor.
    */
   public UI() { }
 
   /**
    * UI specific execution.
    * @return boolean
    */
   public abstract boolean execute();
 
   /**
    * Gets the message corresponding to the specified key in the "base" bundle.
    * <p>
    * This method is here to give easy access to the base bundle without knowledge
    * of the bundle name or location.
    *
    * @param key The key of the message to retrieve
    * @return    The message
    */
   public static String getString(String key) {
     return bundle.getString(key);
   }
 
   /**
    * Gets if the configurator is running in "expert mode".
    *
    * @return  <code>true</code> if the configurator is in expert mode
    */
   public static boolean isExpertMode() {
     return expertMode;
   }
 
   /**
    * Builds the list of Configutator implementations in the classpath
    * through inspection of "configurator.txt" resources found via ClassLoader.
    * <p>
    * Each "configurator.txt" resource is expected to contain a list of
    * Configurator classes.
    *
    * @return An array of Configurator instances
    */
   public static Configurator[] getConfigurators() {
     if (configurators == null) {
       JVMConfigurator jvmc = JVMConfigurator.getInstance();
 
       HashMap<String, Configurator> map = new HashMap<String, Configurator>();
       ClassLoader cl = Thread.currentThread().getContextClassLoader();
       try {
         // Special configurator. No need to register in configurators.txt
         register(map, jvmc);
 
         // Preloads for third party configurators access
         jvmc.getModel().load();
 
         Enumeration enumeration = cl.getResources("configurators.txt");
         while (enumeration.hasMoreElements()) {
           URL url = (URL)enumeration.nextElement();
 
           BufferedReader reader = null;
           try {
             reader = new BufferedReader(new InputStreamReader(url.openStream()));
             String line = reader.readLine();
             while (line != null) {
               line = line.trim();
               if (line.charAt(0) != '#') {
                 Configurator config = newConfigurator(line);
                 if (config != null) {
                   config.getModel().load();
                   register(map, config);
                 }
               }
               line = reader.readLine();
             }
           } finally {
             ReflectionTools.close(reader);
           }
         }
       } catch (IOException e) { }
 
       Collection<Configurator> col = map.values();
       Configurator[] configs = new Configurator[col.size()];
       col.toArray(configs);
 
       configurators = configs;
     }
     return configurators;
   }
 
   /**
    * Shows the help message in the console.
    */
   private static void showHelp() {
     for (int i = 0; i < HELP_TEXT.length; i++) {
       System.out.println(HELP_TEXT[i]);
     }
   }
   /**
    * Checks the specified mode is "usable", and initializes it.
    *
    * @param mode The desired UI mode
    * @param ansi Flag for ANSI mode
    * @param acs  Flaf for Alternative Character Set mode
    * @return The "adjusted" UI mode
    */
   private static int prepareMode(int mode, boolean ansi, boolean acs) {
     // Switch to CONSOLE if display does not exist
     if (mode == Configurator.MODE_SWING && !AWTUtils.existDisplay()) {
       mode = Configurator.MODE_CONSOLE;
     }
 
     if (mode == Configurator.MODE_CONSOLE) {
       ConsoleTools.setup(ansi, acs);
     }
 
     return mode;
   }
 
   /**
    * Sets the locale to the one specified in the parameter string.
    *
    * @param s The string containing the command-line argument with the locale
    */
   private static void parseLocale(String s) {
     String locale = s.substring("-locale:".length());
     setDefaultLocale(locale);
   }
 
   /**
    * Performs the execution of the appropriate UI implementation, according to
    * the passed command-line arguments.
    *
    * @param args The command-line arguments
    * @throws Exception In case of an unhandled error
    */
   public static void main(String[] args) throws Exception {
     int mode = Configurator.MODE_SILENT;
     boolean ansi = false;
     boolean acs = true;
 
     for (int i = 0; i < args.length; i++) {
       if ("-help".equals(args[i])) {
         showHelp();
         System.exit(0);
       } else if ("-expert".equals(args[i])) {
         expertMode = true;
       } else if ("-swing".equals(args[i])) {
         mode = Configurator.MODE_SWING;
       } else if ("-console".equals(args[i])) {
         mode = Configurator.MODE_CONSOLE;
       } else if ("-silent".equals(args[i])) {
         mode = Configurator.MODE_SILENT;
       } else if ("-ansi".equals(args[i])) {
         ansi = true;
       } else if ("-noacs".equals(args[i])) {
         acs = false;
       } else if (args[i].startsWith("-locale:")) {
         // Explicit language selection
         parseLocale(args[i]);
       } else if (args[i].startsWith("-laf:")) {
         parseLaf(args[i].substring("-laf:".length()));
       } else if (args[i].startsWith("-username:")) {
         Configurator.setUsername(args[i].substring("-username:".length()));
       } else {
         log.warn("Invalid " + args[i] + " option. Ignored");
       }
     }
 
     mode = prepareMode(mode, ansi, acs);
 
     boolean quitConfigurator = false;
     do {
       boolean correctExecution = execute(mode);
       quitConfigurator = quitConfigurator(correctExecution);
     } while (!quitConfigurator);
   }
 
   /**
    * @param correctExecution execution has finished correctly
    * @return <code>true</code> if configurator has to be reopened
    */
   private static boolean quitConfigurator(boolean correctExecution) {
     if (correctExecution) {
       return true;
     }
     //ask the user to reopen the configurator
     String line;
 
     do {
       try {
         line =
           ConsoleTools.readLine(UI.getString("console.readLine.applyErrors"));
       } catch (IOException e) {
         log.error("Error while reading information");
         e.printStackTrace();
         return false;
       }
     } while (wrongValue(line));
 
     if (line.equals("y") || line.equals("Y")) {
       return true;
     }
 
     return false;
 
   }
 
   /**
    * @param line characters to validate
    * @return validation
    */
   private static boolean wrongValue(String line) {
     return line.length() != 1
             || (!line.equals("y") && !line.equals("n")
                 && !line.equals("Y") && !line.equals("N"));
   }
 
   /**
    * Executes the appropriate UI implementation.
    *
    * @param mode The selected execution mode
    * @return returns boolean
    * @throws Exception If an error occurs
    */
   private static boolean execute(int mode) throws Exception {
     if (mode >= 0 && mode <= 2) {
       try {
         Configurator.setViewMode(mode);
         Class c = Class.forName(CLASS_NAMES[mode]);
         if (c != null) {
           UI ui = (UI)c.newInstance();
           UI.getConfigurators();
           return ui.execute();
         }
       } catch (Exception e) {
         e.printStackTrace();
         System.exit(1);
         return false;
       }
     } else {
       throw new Exception("No UI implemented for this options");
     }
     return false;
   }
 
   /**
    * Parses the specified LookAndFeel name and returns the appropriate class name.
    *
    * @param laf The LAF name
    * @return The LAF class name
    */
   private static String parseLaf(String laf) {
     if (laf.equalsIgnoreCase("system")) {
       laf = UIManager.getSystemLookAndFeelClassName();
     } else if (laf.equalsIgnoreCase("cross")) {
       laf = UIManager.getCrossPlatformLookAndFeelClassName();
     } else if (laf.equalsIgnoreCase("windows")) {
       laf = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
     } else if (laf.equalsIgnoreCase("gtk")) {
       laf = "com.sun.java.swing.plaf.gtk.GTKLookAndFeel";
     } else if (laf.equalsIgnoreCase("metal")) {
       laf = "javax.swing.plaf.metal.MetalLookAndFeel";
     } else if (laf.equalsIgnoreCase("motif")) {
       laf = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
     }
 
     try {
       // Checks the specified class exists
       Class.forName(laf);
       System.setProperty("swing.defaultlaf", laf);
     } catch (Exception e) {
       System.err.println("WARNING: Invalid LAF specified");
     }
 
     return laf;
   }
 
   /**
    * Adds the configurator to the specified map, using its path as the map key.
    *
    * @param map The map where c is to be put
    * @param c   The configurator instance
    */
   private static void register(Map<String, Configurator> map, Configurator c) {
     if (map.containsKey(c.getPath())) {
       (new InternalError("Configurator overriden!!!")).printStackTrace();
       System.exit(1);
     }
     map.put(c.getPath(), c);
   }
 
   /**
    * Creates a new configurator instance through reflection.
    * <p>
    * This method first attempts to obtain an instance by calling to a
    * static method called getInstance(). If no such a method is found, it
    * will try to create a new instance through the default constructor.
    *
    * @param className The name of the class to invoke
    * @return The class instance, or null if instantiation was not successful
    */
   private static Configurator newConfigurator(String className) {
     try {
       Class c = Class.forName(className);
       if (Configurator.class.isAssignableFrom(c)) {
         try {
           Method m = c.getMethod("getInstance");
           return (Configurator)m.invoke(null);
         } catch (Exception e) {
           return (Configurator)c.newInstance();
         }
       }
     } catch (Exception e) {
       String pattern = UI.getString("messages.classload");
       String msg = MessageFormat.format(pattern, new Object[] { className });
       log.warn(msg, e);
     }
     return null;
   }
 
   /**
    * Parses the specified string and sets the JVM default Locale from it.
    * <p>
    * The specified locale should be in the form:
    * <p>
    * <code>language[_country[_variant]]</code>
    *
    * @param slocale A locale string representation
    */
   private static void setDefaultLocale(String slocale) {
     StringTokenizer st = new StringTokenizer(slocale, "_");
     Locale locale = null;
     if (st.hasMoreTokens()) {
       String lang = st.nextToken().trim().toLowerCase();
       if (st.hasMoreTokens()) {
         String country = st.nextToken().trim().toUpperCase();
         if (st.hasMoreTokens()) {
           String variant = st.nextToken().trim();
           locale = new Locale(lang, country, variant);
         } else {
           locale = new Locale(lang, country);
         }
       } else {
         locale = new Locale(lang);
       }
     }
 
     if (locale != null) {
       Locale.setDefault(locale);
       bundle = ResourceBundle.getBundle("config", locale);
     }
   }
 }