/*
    * Copyright (c) 2005 Regents of the University of California (Regents). Created
    * by TELS, Graduate School of Education, University of California at Berkeley.
    *
    * This software is distributed under the GNU Lesser General Public License, v2.
    *
    * Permission is hereby granted, without written agreement and without license
    * or royalty fees, to use, copy, modify, and distribute this software and its
    * documentation for any purpose, provided that the above copyright notice and
   * the following two paragraphs appear in all copies of this software.
   *
   * REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
   * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   * PURPOSE. THE SOFTWAREAND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
   * HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
   * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
   *
   * IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
   * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
   * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
   * REGENTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package net.sf.sail.core.beans;
  
  import java.beans.beancontext.BeanContextServicesSupport;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import net.sf.sail.core.beans.assembly.Assignment;
  import net.sf.sail.core.beans.assembly.PodRegistry;
  import net.sf.sail.core.beans.assembly.PodVarDelegate;
  import net.sf.sail.core.beans.assembly.PropertyRef;
  import net.sf.sail.core.curnit.PodArchiveResolver;
  import net.sf.sail.core.util.SailBeanUtils;
  import net.sf.sail.core.uuid.PodUuid;
  
  /**
   * Bean representing the reusable Pod container.
   * 
   * @author turadg
   */
  public class Pod extends BeanContextServicesSupport {
  	/**
  	 * 
  	 */
  	private static final long serialVersionUID = 7881255006647471835L;
  
  	/**
  	 * Make this a constant so other classes can use this property name
  	 */
  	public static final String PROPERTY_POD_ID = "podId";
  
  	/**
  	 * Logger for this class
  	 */
  	private static final Logger logger = Logger.getLogger(Pod.class.getName());
  
  	// property
  	PodUuid podId;
  
  	public PodUuid getPodId() {
  		return podId;
  	}
  
  	public void setPodId(PodUuid newPodId) {
  		if (newPodId == null)
  			throw new NullPointerException("podId argument was null");
  		PodUuid oldPodId = this.podId;
  		this.podId = newPodId;
  
  		// firePropertyChange(PROPERTY_POD_ID, old, podId);
  		// property change listener won't do because the pod may have never had
  		// a podId (and thus not fit yet in the registry)
  		PodRegistry.getDefaultRegistry().reregister(this);
  
  		if (oldPodId != null)
  			// update in assembly assignment statements
  			updateLeftAssignments(assemblyCalls, oldPodId, newPodId);
  	}
  
  	/**
  	 * This pod's id is often in the left of assignment statements in the list
  	 * of assembly calls. Replace all occurences of the old pod id in the left
  	 * assignments with the new pod id.
  	 * 
  	 * @param calls
  	 * @param oldPodId
  	 * @param newPodId
  	 */
  	private static void updateLeftAssignments(List<Assignment> calls,
 			PodUuid oldPodId, PodUuid newPodId) {
 		for (Assignment assignment : calls) {
 			PodVarDelegate left = assignment.getLeft();
 			if (left.getPodId().equals(oldPodId))
 				left.setPodId(newPodId);
 		}
 	}
 
 	// property
 	Map<String, PropertyRef> vars = new HashMap<String, PropertyRef>();
 
 	public Map<String, PropertyRef> getVars() {
 		return vars;
 	}
 
 	public void setVars(Map<String, PropertyRef> vars) {
 		this.vars = vars;
 	}
 
 	/**
 	 * Export propertyRef as exportSocketName.
 	 * 
 	 * Export a property of a bean within this pod, given by propertyRef. This
 	 * export will be referenced by exportSocketName so that other pods can ask
 	 * for the value, using resolve().
 	 * 
 	 * When this pod is marshalled, the value of the property will be preserved.
 	 * 
 	 * @param propertyRef
 	 * @param exportSocketName
 	 */
 	public void exportProperty(PropertyRef propertyRef, String exportSocketName) {
 		bind(exportSocketName, propertyRef, false);
 	}
 
 	/**
 	 * Import propertyRef as importSocketName.
 	 * 
 	 * Import a property of a bean within this pod, given by propertyRef. This
 	 * import will be referenced by importSocketName so that assembly calls can
 	 * fill it in with other values.
 	 * 
 	 * When this pod is marshalled, the property value won't be preserved since
 	 * it will be set by an assembly call at load time.
 	 * 
 	 * @param propertyRef
 	 * @param importSocketName
 	 */
 	public void importProperty(PropertyRef propertyRef, String importSocketName) {
 		bind(importSocketName, propertyRef, true);
 	}
 
 	/**
 	 * This should not be used outside this class. Instead use exportProperty()
 	 * or importProperty() as applicable.
 	 * 
 	 * @param varName
 	 * @param propertyRef
 	 * @param isTransient
 	 */
 	@Deprecated
 	public void bind(String varName, PropertyRef propertyRef,
 			boolean isTransient) {
 		Object target = propertyRef.getTarget();
 		if (!this.contains(target))
 			throw new RuntimeException("pod " + this
 					+ " does not contain target " + target + " of binding");
 		vars.put(varName, propertyRef);
 		if (isTransient)
 			transientRefs.add(propertyRef);
 	}
 
 	/**
 	 * 
 	 * @param varName
 	 * @return the current value of the property (import or export) specified by
 	 *         varName
 	 */
 	public Object resolve(String varName) {
 		Object value = null;
 		try {
 			value = (vars.get(varName)).getCurrentValue();
 		} catch (Exception e) {
 			logger.warning("exception: " + e);
 		}
 		return value;
 	}
 
 	// property
 	Set<PropertyRef> transientRefs = new HashSet<PropertyRef>();
 
 	public Set<PropertyRef> getTransientRefs() {
 		return transientRefs;
 	}
 
 	public void setTransientRefs(Set<PropertyRef> transientRefs) {
 		this.transientRefs = transientRefs;
 	}
 
 	// property
 	List<Assignment> assemblyCalls = new LinkedList<Assignment>();
 
 	private boolean assemblyStarted;
 
 	private boolean assembled;
 
 	public List<Assignment> getAssemblyCalls() {
 		return assemblyCalls;
 	}
 
 	public void setAssemblyCalls(List<Assignment> assemblyCalls) {
 		Object old = this.assemblyCalls;
 		this.assemblyCalls = assemblyCalls;
 		firePropertyChange("assemblyCalls", old, assemblyCalls);
 	}
 
 	protected Pod childWithId(PodUuid podId) {
 		Collection<Pod> podChildren = SailBeanUtils.childrenOfType(this,
 				Pod.class);
 		for (Pod pod : podChildren) {
 			if (pod.getPodId().equals(podId))
 				return pod;
 		}
 		return null;
 	}
 
 	public URL getPodArchive() {
 		return PodArchiveResolver.getPodArchive(podId);
 	}
 
 	// TODO make this throw a checked exception for failed assignments
 	public void assemble(PodRegistry registry) throws UnknownPodException {
 		assembleChildren(registry);
 		registry.register(this);
 		assemblyStarted = true;
 		for (Assignment assignment : assemblyCalls) {
 			try {
 				assignment.execute(registry);
 			} catch (Exception e) {
 				logger
 						.severe("Pod assemble failing due failed execution of assignment " + assignment + " by " + e); //$NON-NLS-1$
 				throw new RuntimeException("error assembling", e);
 			}
 		}
 		assembled= true;
 	}
 
 	// TODO write delegate that persists this without exposing it
 	Set<PodUuid> childPodIds = new HashSet<PodUuid>();
 
 	@Override
 	public boolean add(Object targetChild) {
 		boolean success = super.add(targetChild);
 		if (logger.isLoggable(Level.FINE)) {
 			logger.fine(this + " added " + targetChild + " success:" + success);
 		}
 		if (success && targetChild instanceof Pod) {
 			Pod pod = (Pod) targetChild;
 			childPodIds.add(pod.getPodId());
 		}
 
 		return success;
 	}
 
 	/**
 	 * Remove the member from this container.
 	 * 
 	 * If the member is a child pod, also remove all references from this pod to
 	 * that pod.
 	 */
 	@Override
 	public boolean remove(Object targetChild) {
 		// remove as member of this pod container
 		boolean success = super.remove(targetChild);
 		if (logger.isLoggable(Level.FINE)) {
 			logger.fine(this + " removed " + targetChild + " success:"
 					+ success);
 		}
 
 		// remove from transient refs set
 		// removeFromTransientRefs(targetChild);
 
 		// more to do if the removal is of a pod
 		if (success && targetChild instanceof Pod) {
 			Pod pod = (Pod) targetChild;
 
 			// pod itself is already removed
 
 			// clean out podvar assignments involving that pod
 			List<Assignment> calls = this.assemblyCalls;
 			List<Assignment> callsToRemove = new ArrayList<Assignment>();
 			for (Assignment assignment : calls) {
 				boolean remove = false;
 				if (assignment.getLeft().getPodId().equals(pod.getPodId()))
 					remove = true;
 				else if (assignment.getRight().getPodId()
 						.equals(pod.getPodId()))
 					remove = true;
 				if (remove) {
 					callsToRemove.add(assignment);
 					// also remove from import vars if it's there
 					String varName = assignment.getLeft().getVarName();
 					vars.remove(varName);
 				}
 			}
 			this.assemblyCalls.removeAll(callsToRemove);
 		}
 
 		return success;
 	}
 
 	/**
 	 * @param targetChild
 	 */
 	@Deprecated
 	private void removeFromTransientRefs(Object targetChild) {
 		for (PropertyRef ref : transientRefs) {
 			try {
 				if (targetChild == ref.getCurrentValue()) {
 					transientRefs.remove(ref);
 				}
 			} catch (Exception e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 		}
 	}
 
 	private void assembleChildren(PodRegistry registry)
 			throws UnknownPodException {
 		for (PodUuid podId : childPodIds) {
 			Pod pod = registry.getPod(podId);
 			if (pod == null)
 				throw new UnknownPodException(podId, registry);
 			add(pod);
 			pod.assemble(registry);
 		}
 	}
 
 	public Set<PodUuid> getChildPodIds() {
 		refreshChildPodsIdSet();
 		return childPodIds;
 	}
 
 	/**
 	 * 
 	 */
 	private void refreshChildPodsIdSet() {
 		Collection<Pod> podChildren = SailBeanUtils.childrenOfType(this,
 				Pod.class);
 		Set<PodUuid> idsOfPodChildren = new HashSet<PodUuid>();
 		for (Pod pod : podChildren) {
 			idsOfPodChildren.add(pod.getPodId());
 		}
 		childPodIds = idsOfPodChildren;
 	}
 
 	/**
 	 * Used only by the XMLEncoder unmarshaller as a way of restoring references
 	 * to the pod childen. The actually pod childen become members of this pod
 	 * collection during Pod.assemble()
 	 * 
 	 * @param childPodIds
 	 */
 	public void setChildPodIds(Set<PodUuid> childPodIds) {
 		this.childPodIds = childPodIds;
 	}
 
 	/**
 	 * Returns whether the value is the same as a podvar that is transient.
 	 * (i.e. should not be marshalled) Assumes instances of Pod cannot be
 	 * imported.
 	 * 
 	 * @param value
 	 * @return true iff the value matches the current value of one of the refs
 	 *         in this pod marked transient
 	 */
 	public boolean isTransient(Object value) {
 		if (value instanceof Pod)
 			return false;
 
 		// since there's no way to compare it, consider a null value to never be
 		// transient
 		if (value == null)
 			return false;
 
 		/*
 		 * If the value is an array, it is transient if any of its elements is
 		 * transient. So iterate over each and if you find one return true.
 		 */
 		Class<? extends Object> valueClass = value.getClass();
 		if (valueClass.isArray()) {
 			Object[] values = ((Object[]) value);
 			for (int i = 0; i < values.length; i++) {
 				Object elementValue = values[i];
 				if (valueMatchesReference(elementValue, transientRefs)) {
 					return true;
 				}
 			}
 		}
 
 		if (valueMatchesReference(value, transientRefs)) {
 			// System.out.println("returning true: some match of " + value);
 			return true;
 		}
 
 		return false;
 	}
 
 	/**
 	 * @param value
 	 * @param propertyReferences
 	 *            TODO
 	 * @param valueClass
 	 */
 	private static boolean valueMatchesReference(Object value,
 			Set<PropertyRef> propertyReferences) {
 		for (PropertyRef ref : propertyReferences) {
 			try {
 				if (value == ref.getCurrentValue()) {
 					return true;
 				}
 			} catch (Exception e) {
 				logger.warning("exception: " + e);
 			}
 		}
 		return false;
 	}
 
 	@Override
 	public String toString() {
 		return "Pod@" + podId;
 	}
 
 	// TODO implement this properly with check against BeanContext facilities. a
 	// unit test even!
 	@Override
 	public int hashCode() {
 		return super.hashCode();
 		// the code below breaks the BeanContext children facilities
 		// return new HashCodeBuilder(29, 3).append(podId).append(childPodIds)
 		// .append(children).append(vars).append(transientRefs).append(
 		// transientRefs).toHashCode();
 	}
 
 	/**
 	 * Record that the pod has been modified, which requires that the pod id
 	 * change
 	 */
 	public void touch() {
 		// FIXME make a more reliable revision system
 		// FIXME ignoring for now, since we're using curnit-level versioning
 //		setPodId(BinaryUtils.createNewPodUuidFromOld(getPodId()));
 	}
 
 	/**
 	 * @return Returns the assembled.
 	 */
 	public boolean isAssembled() {
 		return assembled;
 	}
 
 }