/*
    * Replica is published under the terms
    * of the Apache Software License.
    */
   package replica.command;
   
   import java.util.Enumeration;
   import java.util.Hashtable;
   
  import replica.utils.BeanUtils;
  
  
  /***
   *  This Mappings implementation stores the mapped configuration in a hashtable.
   * 
   * @author Pedro Costa
   * @author Helder Silva
   * @since 17/Jan/2004
   */
  public class HashtableMappings implements Mappings {
  	
  	// contain the class names mapped to action ids.
  	Hashtable classMapping = new Hashtable();
  	
  	// contain the initial parameters for a given class name
  	// the key is the class name
  	ParametersMappings initParameters = new ParametersMappings();
  
  	/***
  	 * Default constructor. 
  	 */
  	public HashtableMappings() {
  		super();
  	}
  	
  	public void addMapping(String actionId, String className){
  		classMapping.put(actionId, className);
  	}
  	
  	public void addMapping(String actionId, String className, Hashtable parameters ){
  		if( parameters == null ){
  			addMapping(actionId, className);
  			return;
  		}
  		
  		int size = parameters.size();
  		addMapping( actionId, className, (String[])parameters.keySet().toArray(new String[size]),
  								parameters.values().toArray(new Object[size]) );
  	}
  	
  	public void addMapping(String actionId, String className, String[] paramNames, Object[] paramValues){
  		addMapping(actionId, className);
  		initParameters.addParameters(className, paramNames, paramValues);
  	}
  	
  	/*** 
  	 * 
  	 * @see replica.command.Mappings#getMappedClass(java.lang.String)
  	 */
  	public Class getMappedClass(String actionId) throws CommandException{
  		
  		try{
  			Class clazz = Class.forName((String)classMapping.get( actionId ));
  			
  			if( clazz == null )
  				throw new NoSuchCommandException("No command found for action id " + actionId, actionId);
  				
  			return clazz;
  		}
  		catch(ClassNotFoundException e){
  			throw new CommandException(e);
  		}
  	}
  
  	/* (non-Javadoc)
  	 * @see replica.server.cmd.Mappings#getNewCommand(java.lang.String)
  	 */
  	public Command getNewCommand(String actionId) throws CommandException {
  		
  		Class clazz = getMappedClass( actionId );
  		
  		try{
  			Command command = (Command)clazz.newInstance();
  			
  			initCommand( command );
  			
  			return command;
  		}
  		catch(IllegalAccessException e){
  			throw new CommandException("Error creating command from class [" + clazz + 
  					"] for action id [" + actionId + "]. Look for the root cause on this exception." + e.toString(), e );
  		}
  		catch(InstantiationException e ){
  			throw new CommandException("Error creating command from class [" + clazz + 
  					"] for action id [" + actionId + "]. Look for the root cause on this exception." + e.toString(), e );
  		}
  		 
  	}
  	
 	/***
 	 * Initialize the given command with the defined parameters (if any).
 	 * 
 	 * @param command
 	 */
 	protected void initCommand(Command command){
 		
 		Hashtable table = initParameters.getParameters(command.getClass().getName());
 		
 		if( table == null || table.size() == 0 )
 			return;
 		
 		Enumeration enum = table.keys();
 		while( enum.hasMoreElements() ){
 			String key = (String)enum.nextElement();
 			BeanUtils.writeProperty( command, key, table.get(key).toString() );
 		}
 	}
 	
 	class ParametersMappings{
 		
 		private Hashtable mappings = new Hashtable();
 		
 		ParametersMappings(){
 			super();
 		}
 		
 		/***
 		 * Adds initial parameter values for the given class.
 		 * 
 		 * @param clazz the class
 		 * @param paramName parameter name
 		 * @param paramValue parameter value
 		 */
 		public void addParameters( String className, String[] paramNames, Object[] paramValues ){
 			
 			if( paramNames.length != paramValues.length )
 				throw new IllegalArgumentException("Parameter Names and values must have the same lenght.");
 			
 			Hashtable params = (Hashtable)mappings.get(className);
 			
 			if( params == null ){
 				params = new Hashtable();
 				mappings.put(className, params);
 			}
 			
 			for (int i = 0; i < paramNames.length; i++)
 				params.put(paramNames[i], paramValues[i]);
 		}
 		
 		/***
 		 * Adds initial Parameter values for the given class.
 		 * 
 		 * @param clazz the class
 		 * @param parameters Hashtable containing the parameters.
 		 * 				 Where the key must the parameter name and the value the parameter value.
 		 */
 		public void addParameters( String className, Hashtable parameters){
 			
 			int size = parameters.size();
 			
 			addParameters( className, (String[])parameters.entrySet().toArray( new String[ size ] ),
 														parameters.values().toArray( new Object[ size ] ) );
 		}
 
 		/***
 		 * Shortcut method.
 		 * 
 		 * @see #addParameters( Class, String[], Object[])
 		 * @param clazz
 		 * @param paramName
 		 * @param paramValue
 		 */		
 		public void addParameter( String className, String paramName, Object paramValue ){
 			
 			addParameters(className, new String[]{paramName}, new Object[]{paramValue});
 		}
 		
 		/***
 		 * Return the initial parameters for the given class.
 		 * 
 		 * @param clazz
 		 * @return table conting as key the parameters names and as values the <i>values</i>.
 		 */
 		public Hashtable getParameters( String className  ){
 			
 			Hashtable table = (Hashtable)mappings.get( className );
 			
 			if( table == null )
 				return new Hashtable();
 				
 			return table;
 		}
 	}
 
 	/***
 		 * Adds mappings for the received commands.
 		 * 
 		 * @param className the name of the command class to map the commands in the received list.
 		 * @param paramsTable a table with the initial parameters value for the command class.
 		 * @param commands a list of commands to map to the received action class.
 		 */
 	protected void addMappingsForClass(String className, Hashtable paramsTable, String[] commands) {
 			
 		for (int i = 0; i < commands.length; i++) {
 			addMapping(commands[i], className, paramsTable );
 		}
 	}
 
 }