/*
    * $Source$
    * $Revision$
    *
    * Copyright (C) 2000 Tim Joyce
    *
    * Part of Melati (http://melati.org), a framework for the rapid
    * development of clean, maintainable web applications.
    *
   * Melati is free software; Permission is granted to copy, distribute
   * and/or modify this software under the terms either:
   *
   * a) the GNU General Public License as published by the Free Software
   *    Foundation; either version 2 of the License, or (at your option)
   *    any later version,
   *
   *    or
   *
   * b) any version of the Melati Software License, as published
   *    at http://melati.org
   *
   * You should have received a copy of the GNU General Public License and
   * the Melati Software License along with this program;
   * if not, write to the Free Software Foundation, Inc.,
   * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
   * GNU General Public License and visit http://melati.org to obtain the
   * Melati Software License.
   *
   * Feel free to contact the Developers of Melati (http://melati.org),
   * if you would like to work out a different arrangement than the options
   * outlined here.  It is our intention to allow Melati to be used by as
   * wide an audience as possible.
   *
   * 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.
   *
   * Contact details for copyright holder:
   *
   *     Tim Joyce <timj At paneris.org>
   *     http://paneris.org/
   *     68 Sandbanks Rd, Poole, Dorset. BH14 8BY. UK
   */
  
  package org.melati;
  
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.util.List;
  import java.util.Properties;
  import java.util.Vector;
  
  import org.melati.login.AccessHandler;
  import org.melati.poem.PoemLocale;
  import org.melati.poem.util.EnumUtils;
  import org.melati.servlet.FormDataAdaptorFactory;
  import org.melati.template.ClassNameTempletLoader;
  import org.melati.template.ServletTemplateEngine;
  import org.melati.template.SimpleDateAdaptor;
  import org.melati.template.TemplateEngine;
  import org.melati.template.TempletLoader;
  import org.melati.template.YMDDateAdaptor;
  import org.melati.template.YMDHMSTimestampAdaptor;
  import org.melati.util.ConfigException;
  import org.melati.util.HttpHeader;
  import org.melati.util.PropertiesUtils;
  
  /**
   * A MelatiConfig loads and provides access to the configuration parameters for
   * Melati. These are held in <TT>org.melati.MelatiConfig.properties</TT>.
   */
  public class MelatiConfig {
  
    private Properties configuration = null;
    private String propertiesPrefix = "org.melati.MelatiConfig";
  
    private AccessHandler accessHandler = null;
    private FormDataAdaptorFactory fdaFactory = null;
    private TempletLoader templetLoader = null;
    private TemplateEngine templateEngine = null;
    private static PoemLocale poemLocale = null;
    private Vector<String> preferredCharsets = null; 
    private String javascriptLibraryURL = null;
    private String staticURL = null;
    private String templatePath = null;
    private static String loginPageServletClassName = "org.melati.login.Login";
    private static String logoutPageServletClassName = "org.melati.login.Logout";
  
    private static String realPath = null;
    
    /**
     * Allows creation of a <code>MelatiConfig</code> with default config
     * params.
     */
    public MelatiConfig() {
      propertiesPrefix = getClass().getCanonicalName();
      try {
        configuration = PropertiesUtils.fromResource(getClass(), propertiesPrefix + ".properties");
     }
     catch (FileNotFoundException e) {
       configuration = new Properties();
       // TimJ: i think that if we don't have a properties file, it is pretty fatal
       // TimP: Naah
     }
     catch (IOException e) {
       throw new ConfigException("The file " + propertiesPrefix + ".properties" +
                                 " could not be read.", e);
     }
     init(propertiesPrefix);
   }
 
   /**
    * Allows creation of a <code>MelatiConfig</code> with a specified
    * properties file.
    * 
    * @param propertiesFilename
    *        the name of a properties file
    */
   public MelatiConfig(String propertiesFilename) {
     configuration = getProperties(propertiesFilename);
     init(propertiesFilename);
   }
 
   /**
    * Constructor from a given Properties object.
    * @param properties the properties object to look in 
    */
   public MelatiConfig(Properties properties) {
     configuration = properties;
     init(propertiesPrefix);
   }
 
   
   public static Properties getProperties() {
     return getProperties(MelatiConfig.class.getCanonicalName());
   }
   public static Properties getProperties(String propertiesName) {
     try {
       return PropertiesUtils.fromResource(MelatiConfig.class, propertiesName + ".properties");
     }
     catch (FileNotFoundException e) {
       throw new ConfigException("The file " + propertiesName + "properties" +
                                 " could not be found." +
                                 " Is it in your CLASSPATH?", e);
     }
     catch (IOException e) {
       throw new ConfigException("The file " + propertiesName + ".properties" +
                                 " could not be read.", e);
     }
     
   }
   @SuppressWarnings("unchecked")
   void init(String propertiesNameIn) {
     this.propertiesPrefix = propertiesNameIn;
     String pref = propertiesPrefix + ".";
     
     String accessHandlerProp              = pref + "accessHandler";
     String fdaFactoryProp                 = pref + "formDataAdaptorFactory";
     String templetLoaderProp              = pref + "templetLoader";
     String templateEngineProp             = pref + "templateEngine";
     String templatePathProp               = pref + "templatePath";
     String javascriptLibraryURLProp       = pref + "javascriptLibraryURL";
     String staticURLProp                  = pref + "staticURL";
     String melatiLocaleProp               = pref + "locale";
     String preferredCharsetsProp          = pref + "preferredCharsets";
     String loginPageServletClassNameProp  = pref + "loginPageServletClassName";
     String logoutPageServletClassNameProp = pref + "logoutPageServletClassName";
 
     try {
       setAccessHandler((AccessHandler)PropertiesUtils.
           instanceOfNamedClass(
               configuration,
               accessHandlerProp,
               "org.melati.login.AccessHandler",
               "org.melati.login.OpenAccessHandler"));
 
       setFdaFactory((FormDataAdaptorFactory)PropertiesUtils.
           instanceOfNamedClass(
                        configuration,
                        fdaFactoryProp,
                        "org.melati.servlet.FormDataAdaptorFactory",
                        "org.melati.servlet.MemoryFormDataAdaptorFactory"));
 
       String templetLoaderClassName =  (String)configuration.get(templetLoaderProp);
       if(templetLoaderClassName == null || 
          templetLoaderClassName.equals("org.melati.template.ClassNameTempletLoader")) {
         setTempletLoader(ClassNameTempletLoader.getInstance());
       } else
         setTempletLoader((TempletLoader)PropertiesUtils.
           instanceOfNamedClass(
                           configuration,
                           templetLoaderProp,
                           "org.melati.template.TempletLoader",
                           "org.melati.template.ClassNameTempletLoader"));
 
       setTemplateEngine((TemplateEngine)PropertiesUtils.
           instanceOfNamedClass(
                            configuration,
                            templateEngineProp,
                            "org.melati.template.TemplateEngine",
                            "org.melati.template.NoTemplateEngine"));
 
       String languageTag = PropertiesUtils.getOrDefault(configuration,
                                                         melatiLocaleProp,
                                                         "en-gb");
 
       setPoemiLocale(PoemLocale.fromLanguageTag(languageTag));
       if (poemLocale == null)
           throw new ConfigException(languageTag +
                               " is not a valid language tag for " +
                               melatiLocaleProp);
 
       // This is a fancy way of splitting, trimming and checking for
       // errors such as spaces within fields. 
       // It reflects the fact that the config file format 
       // is like a quoteless Http header field.
       setPreferredCharsets(
         EnumUtils.vectorOf(
             new HttpHeader(PropertiesUtils.getOrDefault(
                                configuration,
                                preferredCharsetsProp,
                                "ISO-8859-1, UTF-8, UTF-16")).wordIterator()));
 
       setJavascriptLibraryURL(PropertiesUtils.getOrDefault(
               configuration,
               javascriptLibraryURLProp,
               "/melati-static/admin/"));
 
       setStaticURL(PropertiesUtils.getOrDefault(
               configuration, 
               staticURLProp,
               "/melati-static/"
               ));
 
       setTemplatePath(PropertiesUtils.getOrDefault(configuration,
           templatePathProp, "."));
 
       setLoginPageServletClassName(PropertiesUtils.getOrDefault(configuration,
           loginPageServletClassNameProp, loginPageServletClassName));
 
       setLogoutPageServletClassName(PropertiesUtils.getOrDefault(configuration,
           logoutPageServletClassNameProp, logoutPageServletClassName));
     }
     catch (Exception e) {
       throw new ConfigException("Melati could not be configured", e);
     }
 
   }
 
   /**
    * @return {@link ServletTemplateEngine} in use.
    */
   public ServletTemplateEngine getServletTemplateEngine() {
     return (ServletTemplateEngine)templateEngine;
   }
 
   /**
    * @return {@link TemplateEngine} in use.
    */
   public TemplateEngine getTemplateEngine() {
     return templateEngine;
   }
 
   /**
    * Set the {@link TemplateEngine} to use.
    * 
    * @param templateEngine
    *        a {@link TemplateEngine}
    */
   public void setTemplateEngine(TemplateEngine templateEngine) {
     this.templateEngine = templateEngine;
   }
 
   /**
    * @return the configured {@link AccessHandler}
    */
   public AccessHandler getAccessHandler() {
     return accessHandler;
   }
 
   /**
    * Set the <code>AccessHandler</code> for use by this Melati.
    * 
    * @param accessHandler
    *        a {@link AccessHandler}
    */
   public void setAccessHandler(AccessHandler accessHandler) {
     this.accessHandler = accessHandler;
   }
 
   /**
    * @return the configured {@link TempletLoader}
    */
   public TempletLoader getTempletLoader() {
     return templetLoader;
   }
 
   /**
    * Set the {@link TempletLoader} for use by this Melati.
    * 
    * @param templetLoader
    *        a {@link TempletLoader}
    */
   public void setTempletLoader(TempletLoader templetLoader) {
     this.templetLoader = templetLoader;
   }
 
   /**
    * @return the configured {@link FormDataAdaptorFactory}
    */
   public FormDataAdaptorFactory getFormDataAdaptorFactory() {
     return fdaFactory;
   }
 
   /**
    * Set the {@link FormDataAdaptorFactory} for use by this Melati.
    * 
    * @param fdaf
    *        a {@link FormDataAdaptorFactory}
    */
   public void setFormDataAdaptorFactory(FormDataAdaptorFactory fdaf) {
     fdaFactory = fdaf;
   }
 
   /**
    * @return the location of javascript for this site.
    */
   public String getJavascriptLibraryURL() {
     return javascriptLibraryURL;
   }
 
   /**
    * Set the <code>JavascriptLibraryURL</code> for use by this Melati.
    * 
    * @param url
    *        a URL to the directory containing the JavaScript for this site
    */
   public void setJavascriptLibraryURL(String url) {
     this.javascriptLibraryURL = url;
   }
 
   /**
    * Normally set to <code>melati-static</code>.
    * 
    * @return the location of static content for this site.
    */
   public String getStaticURL() {
     return staticURL;
   }
 
   /**
    * Set the <code>StaticURL</code> for use by this Melati.
    * 
    * @param url
    *        a URL to the directory containing the static content
    */
   public void setStaticURL(String url) {
     this.staticURL = url;
   }
 
   /**
    * @return the location of templates.
    */
   public String getTemplatePath() {
     return templatePath;
   }
 
   /**
    * @param templatePath
    *        The templatePath to set.
    */
   public void setTemplatePath(String templatePath) {
     this.templatePath = templatePath;
   }
 
   /**
    * @return the class name of the logout servlet
    */
   public static String getLogoutPageServletClassName() {
     return logoutPageServletClassName;
   }
 
   /**
    * @param logoutPageServletClassName
    *        The logoutPageServletClassName to set.
    */
   public static void setLogoutPageServletClassName(
       String logoutPageServletClassName) {
     MelatiConfig.logoutPageServletClassName = logoutPageServletClassName;
   }
 
   /**
    * @return the class name of the login servlet
    */
   public static String getLoginPageServletClassName() {
     return loginPageServletClassName;
   }
 
   /**
    * @param loginPageServletClassName
    *        The loginPageServletClassName to set.
    */
   public static void setLoginPageServletClassName(
       String loginPageServletClassName) {
     MelatiConfig.loginPageServletClassName = loginPageServletClassName;
   }
 
   /**
    * @return The configured locale, defaults to British English melati locale.
    */
   public static PoemLocale getPoemLocale() {
     if (poemLocale == null)
       poemLocale = PoemLocale.HERE;
     return poemLocale;
   }
 
   /**
    * @param poemLocale
    *        The PoemLocale to set.
    */
   public void setPoemiLocale(PoemLocale poemLocale) {
     MelatiConfig.poemLocale = poemLocale;
   }
 
 
   /**
    * Return the set encodings that the server prefers and supports.
    * 
    * @return List of encoding names or aliases.
    */
   public List<String> getPreferredCharsets() {
     return preferredCharsets;
   }
 
   /**
    * @param preferredCharsets
    *        The preferredCharsets to set.
    */
   public void setPreferredCharsets(Vector<String> preferredCharsets) {
     this.preferredCharsets = preferredCharsets;
   }
 
   /**
    * @return Returns the fdaFactory.
    */
   public FormDataAdaptorFactory getFdaFactory() {
     return fdaFactory;
   }
 
   /**
    * @param fdaFactory
    *        The fdaFactory to set.
    */
   public void setFdaFactory(FormDataAdaptorFactory fdaFactory) {
     this.fdaFactory = fdaFactory;
   }
   
   //
   // Non configurable but here to make them available in a template context.
   //
   
   /**
    * Called from within templets using 
    * <code>
    * #set $yearField = $melati.Config.YMDDateAdaptor.yearField($field)
    * </code>
    * idiom.
    * Perhaps this should be elsewhere.
    * @return the adaptor for rendering dates as drop-downs.
    */
   public static YMDDateAdaptor getYMDDateAdaptor() {
     return YMDDateAdaptor.it;
   }
 
   /**
    * Called from within templets using 
    * <code>
    * #set $secondField = $melati.Config.YMDHMSTimestampAdaptor.secondField($field)
    * </code>
    * idiom.
    * Perhaps this should be elsewhere.
    * @return the adaptor for rendering timestamps as drop-downs.
    */
   public static YMDHMSTimestampAdaptor getYMDHMSTimestampAdaptor() {
     return YMDHMSTimestampAdaptor.getIt();
   }
 
   /**
    * Called from within templets.
    * Perhaps this should be elsewhere.
    * @return the adaptor for rendering dates as normal.
    */
   public static SimpleDateAdaptor getSimpleDateAdaptor() {
     return SimpleDateAdaptor.it;
   }
 
   /**
    * @param realPathP the path to set 
    */
   public void setRealPath(String realPathP) {
     realPath = realPathP;
   }
   /**
    * @return the real path, if set null otherwise
    */
   public String getRealPath() {
     return realPath;
   }
 
 }