package siouxsie.mvc.impl;
   
   import java.beans.PropertyChangeEvent;
   import java.beans.PropertyChangeListener;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.HashMap;
   import java.util.Map;
   
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import siouxsie.mvc.ActionTriggerDescription;
  import siouxsie.mvc.IActionLauncher;
  import siouxsie.mvc.IActionTrigger;
  import siouxsie.mvc.IController;
  
  import com.opensymphony.xwork2.ActionProxy;
  import com.opensymphony.xwork2.ActionProxyFactory;
  import com.opensymphony.xwork2.ObjectFactory;
  import com.opensymphony.xwork2.config.Configuration;
  import com.opensymphony.xwork2.config.ConfigurationManager;
  import com.opensymphony.xwork2.config.ConfigurationProvider;
  import com.opensymphony.xwork2.config.providers.XmlConfigurationProvider;
  
  /**
   * MVC controller.
   * Handle XWork engine configuration and execution.
   * @author Arnaud Cogoluegnes
   * @version $Id$
   */
  public class Controller implements IController, PropertyChangeListener {
  	
  	/**
  	 * XWork configuration.
  	 * Can be usefull to get object from the container.
  	 */ 
  	private Configuration configuration;
  	
  	/** how to launch action */
  	private IActionLauncher actionLauncher;
  	
  	private ActionProxyFactory actionProxyFactory;
  	
  	@SuppressWarnings("unchecked")
  	private Map extraContext = new HashMap();  
  	
  	private static final Log LOG = LogFactory.getLog(Controller.class);
  
  	private String [] configFiles;
  	
  	private Class<? extends ObjectFactory> objectFactoryClazz;
  	
  	/**
  	 * collection of configuration providers.
  	 * (container providers to be more exact).
  	 */
  	private Collection<ConfigurationProvider> providers = new ArrayList<ConfigurationProvider>(); 
  	
  	/** should we add the XWork default container provider */
  	private boolean defaultConfigurationProvider = true;
  
  	public String[] getConfigFiles() {
  		return configFiles;
  	}
  
  	public void setConfigFiles(String[] configFiles) {
  		this.configFiles = configFiles;
  	}
  
  	public IActionLauncher getActionLauncher() {
  		return actionLauncher;
  	}
  
  	public void setActionLauncher(IActionLauncher actionLauncher) {
  		this.actionLauncher = actionLauncher;
  	}
  	
  	@SuppressWarnings("unchecked")
  	public void executeAction(String name,String nameSpace,Map parameters) {
  		try {
  			// TODO: add the possibility not to execute result and let it done by the controller
  			ActionProxy actionProxy = actionProxyFactory.createActionProxy(nameSpace,name,null,extraContext,true,false);
  			actionProxy.getInvocation().getInvocationContext().setParameters(parameters);
  			// launches the action
  			String result = getActionLauncher().launch(actionProxy);
  			
  			// TODO: handle waiting in multithreaded environment
  			
  			
  		} catch(Exception e) {
  			// TODO handle exception message?
  			// handler(s) could be define in the XWork config file and retrieve from the container
  			LOG.error(e.getMessage(),e);
  		}		
  	}
  	
  	public void init() {
  		ConfigurationManager confManager = new ConfigurationManager();
 		if(defaultConfigurationProvider) {
 			// default XWork configuration (necessary since XWork 2.1)
 			SiouxsieMVCConfigurationProvider provider = new SiouxsieMVCConfigurationProvider();
 			provider.setObjectFactoryClazz(objectFactoryClazz);
 			confManager.addContainerProvider(provider);			
 		}
 		
 		// container providers (usually Java classes, with extra container configurations)
 		for(ConfigurationProvider provider : providers) {
 			confManager.addContainerProvider(provider);
 		}
 		
 		// configuration files (usually XML file for interceptor, action and so on...)
 		for(String configFile : getConfigFiles()) {
 			confManager.addContainerProvider(
 				new XmlConfigurationProvider(configFile, true)
 			);
 		}				
 		this.configuration = confManager.getConfiguration();		
 		this.actionProxyFactory = configuration.getContainer().getInstance(ActionProxyFactory.class);
 		
 		// handle the action trigger mechanism
 		IActionTrigger trigger = configuration.getContainer().getInstance(IActionTrigger.class);
 		if(trigger != null) {
 			// register the controller to the trigger
 			trigger.addPropertyChangeListener(this);
 		} else {
 			LOG.warn("no action trigger found in the XW container, how screens are supposed to launch the controller?");
 		}
 		
 	}
 
 	@SuppressWarnings("unchecked")
 	public Map getExtraContext() {
 		return extraContext;
 	}
 
 	@SuppressWarnings("unchecked")
 	public void setExtraContext(Map extraContext) {
 		this.extraContext = extraContext;
 	}
 
 	public Configuration getConfiguration() {
 		return configuration;
 	}
 
 	public void setConfiguration(Configuration configuration) {
 		this.configuration = configuration;
 	}
 	
 	/**
 	 * Add a configuration provider.
 	 * @param provider
 	 * @return
 	 */
 	public Controller addConfigurationProvider(ConfigurationProvider provider) {
 		if(!this.providers.contains(provider)) {
 			providers.add(provider);
 		}
 		return this;
 	}
 
 	public void setObjectFactoryClazz(
 			Class<? extends ObjectFactory> objectFactoryClazz) {
 		this.objectFactoryClazz = objectFactoryClazz;
 	}
 
 	/**
 	 * Handle the action trigger.
 	 */
 	public void propertyChange(PropertyChangeEvent evt) {
 		if(evt.getNewValue() instanceof ActionTriggerDescription) {
 			ActionTriggerDescription desc = (ActionTriggerDescription) evt.getNewValue();
 			executeAction(desc.getActionName(),
 					desc.getActionNamespace(),
 					desc.getParameters()
 			);			
 		} else {
 			LOG.warn("this kind of value cannot be handled: "+evt.getNewValue());
 		}
 		
 	}
 	
 }