/*
    * Copyright (c) 2003-2005, Henri Yandell
    * All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or 
    * without modification, are permitted provided that the 
    * following conditions are met:
    * 
    * + Redistributions of source code must retain the above copyright notice, 
   *   this list of conditions and the following disclaimer.
   * 
   * + Redistributions in binary form must reproduce the above copyright notice, 
   *   this list of conditions and the following disclaimer in the documentation 
   *   and/or other materials provided with the distribution.
   * 
   * + Neither the name of Simple-JNDI nor the names of its contributors 
   *   may be used to endorse or promote products derived from this software 
   *   without specific prior written permission.
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
   * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
   * POSSIBILITY OF SUCH DAMAGE.
   */
  package org.osjava.sj.loader;
  
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.util.HashMap;
  import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Properties;
  
  import javax.naming.Context;
  import javax.naming.NamingException;
  
  import org.osjava.sj.loader.convert.ConvertRegistry;
  import org.osjava.sj.loader.convert.Converter;
  
  import org.osjava.sj.loader.util.AbstractProperties;
  import org.osjava.sj.loader.util.CustomProperties;
  import org.osjava.sj.loader.util.IniProperties;
  import org.osjava.sj.loader.util.Utils;
  import org.osjava.sj.loader.util.XmlProperties;
  
  /***
   * Loads a .properties file into a JNDI server.
   */
  public class JndiLoader {
  
      // separator, or just put them in as contexts?
      public static final String SIMPLE_DELIMITER = "org.osjava.sj.delimiter";
  
      // share the same InitialContext
      public static final String SIMPLE_SHARED = "org.osjava.sj.shared";
  
      // char(s) to replace : with on the filesystem in filenames
      public static final String SIMPLE_COLON_REPLACE = "org.osjava.sj.colon.replace";
  
      private static ConvertRegistry convertRegistry = new ConvertRegistry();
  
      private Hashtable table = new Hashtable();
  
      public JndiLoader() {
          this.table.put(SIMPLE_DELIMITER, "/");
      }
      
      public JndiLoader(Hashtable env) {
          if(!env.containsKey(SIMPLE_DELIMITER)) {
              throw new IllegalArgumentException("The property "+SIMPLE_DELIMITER+" is mandatory. ");
          }
          
  
          this.table.put(SIMPLE_DELIMITER, env.get(SIMPLE_DELIMITER));
  
          if(env.containsKey(SIMPLE_COLON_REPLACE)) {
              this.table.put(SIMPLE_COLON_REPLACE, env.get(SIMPLE_COLON_REPLACE));
          }
  
      }
      
      public void putParameter(String key, String value) {
          table.put(key, value);
      }
  
      public String getParameter(String key) {
          return (String) table.get(key);
      }
  
     /***
      * Loads all .properties files in a directory into a context
      */
     public void loadDirectory(File directory, Context ctxt) throws NamingException, IOException {
         loadDirectory(directory, ctxt, null, "");
     }
     public void loadDirectory(File directory, Context ctxt, Context parentCtxt, String ctxtName) throws NamingException, IOException {
 // System.err.println("Loading directory. ");
 
         if( !directory.isDirectory() ) {
             throw new IllegalArgumentException("java.io.File parameter must be a directory. ["+directory+"]");
         }
 
         File[] files = directory.listFiles();
         if(files == null) {
 // System.err.println("Null files. ");
             return;
         }
 
         for(int i=0; i<files.length; i++) {
             File file = files[i];
             String name = file.getName();
 
             String colonReplace = (String) this.table.get(SIMPLE_COLON_REPLACE);
             if(colonReplace != null) {
                 if(name.indexOf(colonReplace) != -1) {
                     name = Utils.replace( name, colonReplace, ":" );
                 }
             }
 // System.err.println("Consider: "+name);
             // TODO: Replace hack with a FilenameFilter
 
             if( file.isDirectory() ) {
                 // HACK: Hack to stop it looking in .svn or CVS
                 if(name.equals(".svn") || name.equals("CVS")) {
                     continue;
                 }
 
 // System.err.println("Is directory. Creating subcontext: "+name);
                 Context tmpCtxt = ctxt.createSubcontext( name );
                 loadDirectory(file, tmpCtxt, ctxt, name);
             } else {
                 // TODO: Make this a plugin system
                 String[] extensions = new String[] { ".properties", ".ini", ".xml" };
                 for(int j=0; j<extensions.length; j++) {
                     String extension = extensions[j];
                     if( file.getName().endsWith(extension) ) {
 // System.err.println("Is "+extension+" file. "+name);
                         Context tmpCtxt = ctxt;
                         if(!file.getName().equals("default"+extension)) {
                             name = name.substring(0, name.length() - extension.length());
 // System.err.println("Not default, so creating subcontext: "+name);
                             tmpCtxt = ctxt.createSubcontext( name );
                             parentCtxt = ctxt;
                             ctxtName = name;
                         }
                         load( loadFile(file), tmpCtxt, parentCtxt, ctxtName );
                     }
                 }
             }
         }
 
     }
 
     private Properties loadFile(File file) throws IOException {
 //        System.err.println("LOADING: "+file);
         AbstractProperties p = null;
 
         if(file.getName().endsWith(".xml")) {
             p = new XmlProperties();
         } else
         if(file.getName().endsWith(".ini")) {
             p = new IniProperties();
         } else {
             p = new CustomProperties();
         }
 
         p.setDelimiter( (String) this.table.get(SIMPLE_DELIMITER) );
 
         FileInputStream fin = null;
         try {
             fin = new FileInputStream(file);
             p.load(fin);
             return p;
         } finally {
             if(fin != null) fin.close();
         }
     }
 
 
     /***
      * Loads a properties object into a context.
      */
     public void load(Properties properties, Context ctxt) throws NamingException {
         load(properties, ctxt, null, "");
     }
     public void load(Properties properties, Context ctxt, Context parentCtxt, String ctxtName) throws NamingException {
  //       System.err.println("Loading Properties: " + properties);
 
         String delimiter = (String) this.table.get(SIMPLE_DELIMITER);
         String typePostfix = delimiter + "type";
 
         // NOTE: "type" effectively turns on pseudo-nodes; if it 
         //       isn't there then other pseudo-nodes will result 
         //       in re-bind errors
 
         // scan for pseudo-nodes, aka "type":   foo.type
         // store in a temporary type table:    "foo", new Properties() with type="value"
         Map typeMap = new HashMap();
         Iterator iterator = properties.keySet().iterator();
         while(iterator.hasNext()) {
             String key = (String) iterator.next();
 
             if(key.equals("type") || key.endsWith( typePostfix )) {
                 Properties tmp = new Properties();
                 tmp.put( "type", properties.get(key) );
                 if( key.equals( "type" ) ) {
                     typeMap.put( "", tmp );
                 } else {
                     typeMap.put( key.substring(0, key.length() - typePostfix.length()), tmp );
                 }
             }
 
         }
 
 //        System.err.println("TypeMap: " + typeMap);
 
 // if it matches a type root, then it should be added to the properties
 // if not, then it should be placed in the context
 // for each type properties
 // call convert: pass a Properties in that contains everything starting with foo, but without the foo
 // put objects in context
 
         iterator = properties.keySet().iterator();
         while(iterator.hasNext()) {
             String key = (String) iterator.next();
             Object value = properties.get(key);
 
             if(key.equals("type") || key.endsWith( typePostfix )) {
                 continue;
             }
 
             if(typeMap.containsKey(key)) {
 // System.err.println("Typed: "+key);
                 ( (Properties) typeMap.get(key) ).put("", value);
                 continue;
             }
 
             if(key.indexOf(delimiter) != -1) {
                 String pathText = removeLastElement( key, delimiter );
                 String nodeText = getLastElement( key, delimiter );
 // System.err.println("PathText: "+pathText+" NodeText: "+nodeText);
 
                 if(typeMap.containsKey(pathText)) {
 // System.err.println("Sibling: "+key);
                     ( (Properties) typeMap.get(pathText) ).put(nodeText, value);
                     continue;
                 }
             } else
             if(typeMap.containsKey("")) {
 // System.err.println("Empty Sibling: "+key);
                     ( (Properties) typeMap.get("") ).put(key, value);
                     continue;
             }
 
 // System.err.println("Putting: "+key);
             jndiPut( ctxt, key, properties.get(key) );
         }
 
         Iterator typeIterator = typeMap.keySet().iterator();
         while(typeIterator.hasNext()) {
             String typeKey = (String) typeIterator.next();
             Properties typeProperties = (Properties) typeMap.get(typeKey);
 
             Object value = convert(typeProperties);
 // System.err.println("Putting typed: "+typeKey);
             if(typeKey.equals("")) {
                 jndiPut( parentCtxt, ctxtName, value );
             } else {
                 jndiPut( ctxt, typeKey, value );
             }
         }
 
     }
 
     private void jndiPut(Context ctxt, String key, Object value) throws NamingException {
         // here we need to break by the specified delimiter
 //        System.err.println("Putting "+key+"="+value);
 
         // can't use String.split as the regexp will clash with the types of chars 
         // used in the delimiters. Could use Commons Lang. Quick hack instead.
 //        String[] path = key.split( (String) this.table.get(SIMPLE_DELIMITER) );
         String[] path = Utils.split( key, (String) this.table.get(SIMPLE_DELIMITER) );
 
 // System.err.println("LN: "+path.length);
         int lastIndex = path.length - 1;
 
 
         Context tmpCtxt = ctxt;
 
         for(int i=0; i < lastIndex; i++) {
             Object obj = tmpCtxt.lookup(path[i]);
             if(obj == null) {
 // System.err.println("Creating subcontext: " + path[i] + " for " + key);
                 tmpCtxt = tmpCtxt.createSubcontext(path[i]);
             } else
             if(obj instanceof Context) {
 // System.err.println("Using subcontext: "+obj + " for " + key);
                 tmpCtxt = (Context) obj;
             } else {
                 throw new RuntimeException("Illegal node/branch clash. At branch value '"+path[i]+"' an Object was found: " +obj);
             }
         }
         
         Object obj = tmpCtxt.lookup(path[lastIndex]);
         if(obj instanceof Context) {
             tmpCtxt.destroySubcontext(path[lastIndex]);
             obj = null;
         }
         if(obj == null) {
 // System.err.println("Binding: "+path[lastIndex]+" on "+key);
             tmpCtxt.bind( path[lastIndex], value );
         } else {
 // System.err.println("Rebinding: "+path[lastIndex]+" on "+key);
             tmpCtxt.rebind( path[lastIndex], value );
         }
     }
 
     private static Object convert(Properties properties) {
         String type = properties.getProperty("type");
         // TODO: handle a plugin type system
         
         String converterClassName = properties.getProperty("converter");
         if(converterClassName != null) {
             try {
                 Class converterClass = Class.forName( converterClassName );
                 Converter converter = (Converter) converterClass.newInstance();
                 return converter.convert(properties, type);
             } catch(ClassNotFoundException cnfe) {
                 throw new RuntimeException("Unable to find class: "+converterClassName, cnfe);
             } catch(IllegalAccessException ie) {
                 throw new RuntimeException("Unable to access class: "+type, ie);
             } catch(InstantiationException ie) {
                 throw new RuntimeException("Unable to create Converter " + type + " via empty constructor. ", ie);
             }
         }
 
         // TODO: Support a way to set the default converters in the jndi.properties 
         //       and in the API itself
         Converter converter = convertRegistry.getConverter(type);
         if(converter != null) {
             return converter.convert(properties, type);
         }
 
         return properties.get("");
 
     }
 
     // String methods to make the using code more readable
     private static String getLastElement( String str, String delimiter ) {
         int idx = str.lastIndexOf(delimiter);
         return str.substring(idx + 1);
     }
     private static String removeLastElement( String str, String delimiter ) {
         int idx = str.lastIndexOf(delimiter);
         return str.substring(0, idx);
     }
 
 }