package de.ugoe.cs.eventbench.jfc.data;

import java.util.HashMap;
import java.util.Map;

import de.ugoe.cs.eventbench.data.IReplayable;
import de.ugoe.cs.eventbench.data.ReplayableEvent;
import de.ugoe.cs.eventbench.jfc.JFCLogParser;

/**
 * <p>
 * This class defines JFC events.
 * </p>
 * 
 * @author Steffen Herbold
 * @version 1.0
 */
public class JFCEvent extends ReplayableEvent<IReplayable> {

	/**
	 * <p>
	 * Id for object serialization.
	 * </p>
	 */
	private static final long serialVersionUID = 1L;

	/**
	 * <p>
	 * Internal map of parameters associated with the event.
	 * </p>
	 */
	private Map<String, String> parameters;

	/**
	 * <p>
	 * Information about the event source.
	 * </p>
	 */
	private Map<String, String> sourceParameters;

	/**
	 * <p>
	 * Information about the parent of the event source.
	 * </p>
	 */
	private Map<String, String> parentParameters;

	/**
	 * <p>
	 * Constructor. Creates a new JFCEvent.
	 * </p>
	 * 
	 * @param type
	 *            type of the event
	 */
	public JFCEvent(String type) {
		super(type);
		parameters = new HashMap<String, String>();
		sourceParameters = new HashMap<String, String>();
		parentParameters = new HashMap<String, String>();
	}

	/**
	 * <p>
	 * Adds a new parameter to the event.
	 * </p>
	 * 
	 * @param name
	 *            name of the parameter
	 * @param value
	 *            value of the parameter
	 */
	public void addParameter(String name, String value) {
		parameters.put(name, value);
	}

	/**
	 * <p>
	 * Retrieves the value of a parameter.
	 * </p>
	 * 
	 * @param name
	 *            name of the parameter
	 * @return value of the parameter
	 */
	public String getParameter(String name) {
		return parameters.get(name);
	}

	/**
	 * <p>
	 * Adds new information about the source of the event.
	 * </p>
	 * 
	 * @param name
	 *            name of the information
	 * @param value
	 *            value of the information
	 */
	public void addSourceInformation(String name, String value) {
		sourceParameters.put(name, value);
	}

	/**
	 * <p>
	 * Retrieves information about the source of the event.
	 * </p>
	 * 
	 * @param name
	 *            name of the information
	 * @return value of the information
	 */
	public String getSourceInformation(String name) {
		return sourceParameters.get(name);
	}

	/**
	 * <p>
	 * Adds new information about the parent of the source of the event.
	 * </p>
	 * 
	 * @param name
	 *            name of the information
	 * @param value
	 *            value of the information
	 */
	public void addParentInformation(String name, String value) {
		parentParameters.put(name, value);
	}

	/**
	 * <p>
	 * Used by the {@link JFCLogParser} to extend the target string of the
	 * current event with a further ancestor. The resulting target string will
	 * have the structure {@code etc.grandparent.parent.eventtarget}.
	 * </p>
	 * 
	 * @param extension
	 *            extension for the target.
	 */
	public void extendTarget(String extension) {
		if (target == null || "".equals(target)) {
			target = extension;
		} else {
			target += "." + extension;
		}
	}

	/**
	 * <p>
	 * Retrieves information about the parent of the source of the event.
	 * </p>
	 * 
	 * @param name
	 *            name of the information
	 * @return value of the information
	 */
	public String getParentInformation(String name) {
		return parentParameters.get(name);
	}

	/**
	 * <p>
	 * This method implements the comparison between two targets of JFCEvents.
	 * The targets are equal, if they have the same placement in the widget
	 * hierarchy, i.e., the target strings describe the same widgets, according
	 * to the implementation of widget equality provided by
	 * {@link #compareWidgets(String, String)}.
	 * </p>
	 * 
	 * @see de.ugoe.cs.eventbench.data.Event#targetEquals(java.lang.String)
	 */
	@Override
	protected boolean targetEquals(String otherTarget) {
		if( target==null || otherTarget==null ) {
			return target==otherTarget; 
		}
		String[] targetParts = target.split("\\]\\.\\[");
		String[] otherParts = otherTarget.split("\\]\\.\\[");
		if (targetParts.length != otherParts.length) {
			return false;
		}
		
		boolean retVal;
		if (targetParts.length == 0) {
			retVal = compareWidgets(target, otherTarget);
		} else {
			retVal = true;
			for (int i = 0; retVal && i < targetParts.length; i++) {
				retVal &= compareWidgets(targetParts[i], otherParts[i]);
			}
		}
		return retVal;
	}

	/**
	 * <p>
	 * Compares two widget strings of the form
	 * {@code ['title','class','index','text','hashCode']}.
	 * </p>
	 * 
	 * @param widget1
	 * @param widget2
	 * @return
	 */
	private boolean compareWidgets(String widget1, String widget2) {
		String[] widgetInfo1 = widget1.split("','");
		String[] widgetInfo2 = widget2.split("','");
		// ensure size is equal
		if (widgetInfo1.length != 5 || widgetInfo2.length != 5) {
			return false;
		}
		// ensure that class [1], index [2], and text [3] are equal
		// and title [0] or hashCode [4] are equal
		return (widgetInfo1[1].equals(widgetInfo2[1])
				&& widgetInfo1[2].equals(widgetInfo2[2]) && widgetInfo1[3]
					.equals(widgetInfo2[3]))
				&& (widgetInfo1[0].equals(widgetInfo2[0]) || widgetInfo1[4]
						.equals(widgetInfo2[4]));

	}
	
	@Override
	protected int targetHashCode() {
		int hashCode = 0;
		int multiplier = 29;
		if( target!=null ) {
			String[] targetParts = target.split("\\[\\.\\[");
			if( targetParts.length==0 ) {
				hashCode = widgetHashCode(target);
			} else {
				for( String widgetString : targetParts ) {
					hashCode = hashCode * multiplier + widgetHashCode(widgetString);
				}
			}
		}
		
		return hashCode;
	}
	
	private int widgetHashCode(String widget) {
		int hashCode = 0;
		int multiplier = 37;
		String[] widgetInfo = widget.split("','");
		if( widgetInfo.length==5 ) {
			hashCode = hashCode * multiplier + widgetInfo[1].hashCode();
			hashCode = hashCode * multiplier + widgetInfo[2].hashCode();
			hashCode = hashCode * multiplier + widgetInfo[3].hashCode();
		}
		return hashCode;
	}

}