package net.sf.jldapbeans.lang;
   
   import java.beans.BeanInfo;
   import java.beans.Introspector;
   import java.beans.PropertyDescriptor;
   import java.lang.reflect.Method;
   import java.util.ArrayList;
   import java.util.Enumeration;
   import java.util.Hashtable;
  import java.util.List;
  import java.util.Vector;
  
  import javax.naming.Context;
  import javax.naming.Name;
  import javax.naming.NamingException;
  import javax.naming.directory.Attribute;
  import javax.naming.directory.Attributes;
  import javax.naming.ldap.*;
  import javax.naming.spi.DirObjectFactory;
  
  import net.sf.jldapbeans.lang.LdapClass;
  import net.sf.jldapbeans.lang.annotation.*;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /***
   * The <code>LdapBeanFactory</code> is the entry point of the mechanism that retrieves
   * an object from the LDAP directory, instantiates a java bean and fills its
   * properties with the attribute values from the LDAP object.
   * 
   * @author <a href="mailto:alonsoft@users.sf.net">A. Alonso Domínguez</a>
   * @version 1.0 $ Revision 01-nov-2005 :: alonso $
   * 
   * @see javax.naming.spi.DirObjectFactory
   */
  public class LdapBeanFactory implements DirObjectFactory {
  	private static final Log log = LogFactory.getLog(LdapBeanFactory.class);
  	
  	/***
  	 * Reads the <tt>objectClass</tt> attribute to get an array of strings
  	 * 
  	 * @param objectClass An instance of <tt>javax.naming.directory.Attribute</tt> which 
  	 *                    represents the values of the <tt>objectClass</tt> attribute.
  	 * @return An array of strings with the <tt>objectClass</tt> names.
  	 * @throws NamingException
  	 */
  	protected String[] getObjectClasses(Attribute objectClass) throws NamingException {
  		Vector<String> objClsVector = new Vector<String>();
  		Enumeration<?> e = objectClass.getAll();
  		while(e.hasMoreElements()) {
  			String value = (String) e.nextElement();
  			objClsVector.addElement(value);
  		}
  		return objClsVector.toArray(new String[objClsVector.size()]);
  	}
  	
  	public Object getObjectInstance(Object obj, Name name, Context ctx, Hashtable env) { return null; }
  	
  	/***
  	 * Entry point from <code>DirObjectFactory</code> that starts the process of retrieving
  	 * <code>LdapBean</code>s from the server.
  	 * 
  	 * @param obj Object received from the ldap server.
  	 * @param name Name of the context
  	 * @param ctx The <code>LdapContext</code> of the object
  	 * @param env Actual environment
  	 * @param attrs <code>Attributes</code> of the context
  	 * @return A <code>LdapBean</code> initialized and ready to use
  	 * @throws Exception
  	 */
  	public Object getObjectInstance(Object obj, Name name, Context ctx, Hashtable env,
  	Attributes attrs) throws Exception {
  		if(!(ctx instanceof LdapContext)) return null;
  		if(name.toString().equals("cn=Subschema")) return null;
  		
  		log.debug("Retrieving LdapBean for name [" + name + "]");
  		String[] objectClass = getObjectClasses(attrs.get("objectClass"));
  		
  		LdapClass ldapClass = LdapClass.forName(objectClass);
  		Object bean = ldapClass.newInstance();
  		initialize(bean, attrs, ldapClass);
  		((LdapObject) bean).contextualize(new LdapName(name.toString()), (LdapContext) ctx);
  		return bean;
  	}
  	
  	/***
  	 * Initializes the bean properties from an instance of <tt>javax.naming.directory.Attributes</tt>.
  	 * 
  	 * @param bean The bean to be initialized
  	 * @param attrs Attributes from LDAP directory to be set in the bean
  	 * @param ldapClass The <tt>LdapClass</tt> of the bean. 
  	 */
  	private void initialize(Object bean, Attributes attrs, LdapClass ldapClass)
  	throws Exception {
  		// Remember the properties already initialized
  		List<String> done = new ArrayList<String>();
  		
  		for(Class<?> clazz : ldapClass.getClasses()) {
 			try {
 				BeanInfo bi = Introspector.getBeanInfo(clazz);
 				for(PropertyDescriptor property : bi.getPropertyDescriptors()) {
 					// If we had already initialized this property then continue the loop
 					if(done.contains(property.getName())) continue;
 					
 					Method read = property.getReadMethod(), write = property.getWriteMethod();
 					
 					if(!read.isAnnotationPresent(LdapAttribute.class)) continue;
 					LdapAttribute ldapAttr = read.getAnnotation(LdapAttribute.class);
 					
 					// Now, we do a search through the different possible names of the attribute,
 					// the process stop when the retrieved value from the LDAP directory is not null
 					boolean propDone = false;
 					for(String attrID : ldapAttr.name()) {
 						if(propDone) break;
 						
 						if(attrID.equals("[undefined]")) attrID = property.getName();
 						Attribute attr = attrs.get(attrID);
 						// If attribute id is not found continue, (may show a warn message) 
 						if(attr == null) continue;
 						
 						// Moment to retrieve the LdapAttribute's value
 						Object value = null;
 						if(!LdapModifier.isSingleValue(ldapAttr.value())) {
 							List<Object> valueList = new ArrayList<Object>();
 							Enumeration<?> e = attr.getAll();
 							while(e.hasMoreElements())
 								valueList.add(e.nextElement());
 							value = valueList;
 						}
 						else value = attr.get();
 						
 						// If we got a not null value, then initialize the corresponding property
 						if(value != null) {
 							log.debug("Initializing property [" + property.getName() 
 									+ "] with value [" + value + "]");
 							write.invoke(bean, new Object[]{ value });
 							done.add(property.getName());
 							propDone = true;
 						}
 					}
 					
 					if(!propDone)
 						log.warn("Property not initialized [" + property.getName() + "]");
 				}
 			}
 			catch(Exception e) {
 				log.fatal("Unexpected exception intializing LDAP Bean class [" + clazz + "]", e);
 				throw e;
 			}
 		}
 	}
 		
 }