package nl.tudelft.goal.ut2004.agent.module;
   
   import java.lang.reflect.InvocationTargetException;
   import java.lang.reflect.Method;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;
  
  import nl.tudelft.goal.EIS2Java.annotation.AsPercept;
  import nl.tudelft.goal.EIS2Java.util.EIS2JavaUtil;
  import cz.cuni.amis.pogamut.base.agent.module.SensorModule;
  import cz.cuni.amis.pogamut.ut2004.bot.IUT2004BotController;
  import cz.cuni.amis.pogamut.ut2004.bot.impl.UT2004Bot;
  import cz.cuni.amis.utils.exception.PogamutException;
  import eis.exceptions.EntityException;
  
  /**
   * Module that prepares a batch of percepts after each update of the world view.
   * Percepts are gathered based on {@link AsPercept} annotations in the
   * controller.
   * 
   * A batch can be collected using {@link PerceptModule#getAllPercepts()}.
   * 
   * @author mpkorstanje
   * 
   */
  @SuppressWarnings("rawtypes")
  public class PerceptModule extends SensorModule<UT2004Bot> {
  
  	// /**
  	// * {@link BeginMessage} listener.
  	// */
  	// private class EndMessageListener implements
  	// IWorldEventListener<EndMessage> {
  	// @Override
  	// public void notify(EndMessage event) {
  	// updatePercepts();
  	// }
  	//
  	// /**
  	// * Constructor. Registers itself on the given WorldView object.
  	// *
  	// * @param worldView
  	// * WorldView object to listen to.
  	// */
  	// public EndMessageListener(IWorldView worldView) {
  	// worldView.addEventListener(EndMessage.class, this);
  	// }
  	// }
  
  	// /** {@link BeginMessage} listener */
  	// @SuppressWarnings("unused")
  	// private EndMessageListener endMessageListener;
  
  	/**
  	 * Methods that provide the percepts.
  	 */
  	private Set<Method> perceptProviders = new HashSet<Method>();
  
  	/**
  	 * Percepts pulled from bot.
  	 */
  	private Map<Method, Object> perceptBatch = new HashMap<Method, Object>();
  
  	/**
  	 * Event percepts pulled from bot.
  	 */
  	private Map<Method, List<Object>> eventPerceptBatch = new HashMap<Method, List<Object>>();
  
  	public PerceptModule(UT2004Bot agent) {
  		super(agent);
  
  		// Setup end message listener
  		// endMessageListener = new EndMessageListener(worldView);
  
  		// Setup percept providers.
  		try {
  			Class<? extends IUT2004BotController> controllerClass = agent.getController().getClass();
  			perceptProviders = EIS2JavaUtil.processPerceptAnnotations(controllerClass);
  		} catch (EntityException e) {
  			throw new PogamutException("Could not proccess all annotations", e);
  		}
  	}
  
  	/**
  	 * Calls all percept providers and puts the result in a new batch.
  	 */
  	public synchronized void updatePercepts() {
  
  		perceptBatch = new HashMap<Method, Object>();
  
  		for (Method method : perceptProviders) {
  			AsPercept annotation = method.getAnnotation(AsPercept.class);
  			String perceptName = annotation.name();
 
 			Object percept;
 			try {
 				percept = method.invoke(agent.getController());
 			} catch (IllegalArgumentException e) {
 				throw new PogamutException("Unable to update " + perceptName, e);
 			} catch (IllegalAccessException e) {
 				throw new PogamutException("Unable to update " + perceptName, e);
 			} catch (InvocationTargetException e) {
 				throw new PogamutException("Unable to update " + perceptName, e);
 			}
 			
 			if(percept == null){
 				System.out.println("?");
 			}
 
 			// Percept is event based, needs special handling.
 			if (annotation.event()) {
 				if (!eventPerceptBatch.containsKey(method)) {
 					eventPerceptBatch.put(method, new ArrayList<Object>());
 				}
 
 				List<Object> events = eventPerceptBatch.get(method);
 
 				// Percept provides multiple items, add them independently.
 				if (!annotation.multiplePercepts()) {
 					throw new PogamutException("Unable to update " + perceptName
 							+ " event percept must have multiplePercepts.", this);
 				}
 
 				if (!(percept instanceof Collection<?>)) {
 					throw new PogamutException("Unable to update " + perceptName
 							+ " return value must be a collection.", this);
 				}
 
 				events.addAll((Collection<?>) percept);
 
 			}
 			// Regular percept
 			else {
 				perceptBatch.put(method, percept);
 			}
 		}
 
 		perceptBatch.putAll(eventPerceptBatch);
 	}
 
 	public synchronized Map<Method, Object> getAllPercepts() {
 		// We can clear outstanding events. They'll be exported now.
 		eventPerceptBatch.clear();
 		return perceptBatch;
 	}
 }