package org.xvsm.internal.tasks;
   
   import java.io.Serializable;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.util.List;
   
   import org.xvsm.core.ContainerRef;
   import org.xvsm.core.aspect.AspectContext;
  import org.xvsm.core.aspect.IAspect;
  import org.xvsm.core.aspect.IPoint;
  import org.xvsm.core.aspect.LocalIPoint;
  import org.xvsm.interfaces.container.IContainer;
  import org.xvsm.internal.ContainerManager;
  import org.xvsm.internal.EventProcessingPool;
  import org.xvsm.internal.GlobalAspectManager;
  import org.xvsm.internal.exceptions.AspectNotOkException;
  import org.xvsm.internal.exceptions.AspectRescheduleException;
  import org.xvsm.internal.exceptions.AspectSkipException;
  import org.xvsm.internal.exceptions.FatalException;
  import org.xvsm.internal.exceptions.InvalidContainerException;
  
  /***
   * 
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public class AspectTask extends Task implements Serializable {
  
  	/***
  	 * 
  	 */
  	private static final long serialVersionUID = 6173238989593091613L;
  
  	/***
  	 * The type of the aspect operations. Maybe null if not needed by the
  	 * operation.
  	 */
  	private AspectTaskType type;
  
  	/***
  	 * The aspect itselft. Maybe null if not needed by the operation.
  	 */
  	private IAspect aspect;
  
  	/***
  	 * The integration points, where the aspect should work.
  	 */
  	private List<IPoint> points;
  
  	/***
  	 * The {@link ContainerRef} where the aspect should be added.
  	 */
  	private ContainerRef cref;
  
  	/***
  	 * the uri of the aspect.
  	 */
  	private URI aspectURI;
  
  	/***
  	 * The constructor for local aspects.
  	 * 
  	 * @param type
  	 *            The {@link AspectTaskType}
  	 * @param cref
  	 *            The {@link ContainerRef} where the aspect should be added.
  	 * @param aspect
  	 *            The Aspect itself.
  	 * @param points
  	 *            The integration points of the aspect.
  	 */
  	public AspectTask(AspectTaskType type, ContainerRef cref, IAspect aspect,
  			List<IPoint> points) {
  		super();
  		this.type = type;
  		this.cref = cref;
  		this.aspect = aspect;
  		this.points = points;
  	}
  
  	public AspectTask(AspectTaskType type, ContainerRef cref, URI uri,
  			List<IPoint> points) {
  		super();
  		this.type = type;
  		this.cref = cref;
  		this.aspectURI = uri;
  		this.points = points;
  	}
  
  	public AspectTask(AspectTaskType type, URI uri, List<IPoint> points) {
  		super();
  		this.type = type;
  		this.aspectURI = uri;
  		this.points = points;
  	}
  
  	/***
  	 * The constructor for global aspects.
 	 * 
 	 * @param type
 	 *            The {@link AspectTaskType}
 	 * @param aspect
 	 *            The Aspect itself.
 	 * @param points
 	 *            The integration points of the aspect.
 	 */
 	public AspectTask(AspectTaskType type, IAspect aspect, List<IPoint> points) {
 		super();
 		this.type = type;
 		this.aspect = aspect;
 		this.points = points;
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public void run() {
 		Thread.currentThread().setName(this.getClass().getName());
 		String id = null;
 		switch (this.type) {
 		case ADD:
 			AspectContext acontext = new AspectContext(
 					LocalIPoint.PreAddAspect, this.points, this.aspect, this
 							.getAspectContext());
 			boolean skip = false;
 			try {
 				GlobalAspectManager.execute(acontext);
 			} catch (AspectNotOkException e) {
 				this.setResult(e);
 				return;
 			} catch (AspectRescheduleException e) {
 				EventProcessingPool.getInstance().execute(this);
 			} catch (AspectSkipException e) {
 				skip = true;
 			}
 			if (!skip) {
 				if (this.cref != null) {
 					// we have a local aspect.
 					IContainer container = null;
 					try {
 						container = ContainerManager.getInstance()
 								.getContainer(null, cref);
 					} catch (InvalidContainerException e) {
 						throw new FatalException(e);
 					}
 
 					id = container.addAspects(acontext.getIpoints(), acontext
 							.getAspect(), this.getAspectContext());
 				} else {
 					// we have a global aspect.
 					for (IPoint p : this.points) {
 						id = GlobalAspectManager.addAspect(p, this.aspect);
 					}
 				}
 			}
 
 			try {
 				acontext.setLocalIPoint(LocalIPoint.PostAddAspect);
 				GlobalAspectManager.execute(acontext);
 			} catch (Exception e) {
 				this.setResult(new FatalException(
 						"Aspect result not allowed here. " + e));
 			}
 			break;
 		case DELETE:
 			acontext = new AspectContext(LocalIPoint.PreRemoveAspect,
 					this.points, this.aspect, this.getAspectContext());
 			skip = false;
 			try {
 				GlobalAspectManager.execute(acontext);
 			} catch (AspectNotOkException e) {
 				this.setResult(e);
 				return;
 			} catch (AspectRescheduleException e) {
 				EventProcessingPool.getInstance().execute(this);
 			} catch (AspectSkipException e) {
 				skip = true;
 			}
 			if (!skip) {
 				if (this.cref != null) {
 					// we have a local aspect.
 					for (IPoint p : this.points) {
 						try {
 							IContainer container = ContainerManager
 									.getInstance().getContainer(null, cref);
 							container.removeAspect(p, this.aspectURI, this
 									.getAspectContext());
 						} catch (InvalidContainerException e) {
 							throw new FatalException(e);
 						}
 					}
 				} else {
 					// we have a global aspect.
 					for (IPoint p : this.points) {
 						GlobalAspectManager.removeAspect(p, this.aspectURI);
 					}
 				}
 			}
 			try {
 				acontext.setLocalIPoint(LocalIPoint.PostRemoveAspect);
 				GlobalAspectManager.execute(acontext);
 			} catch (Exception e) {
 				this.setResult(new FatalException(
 						"Aspect result not allowed here. " + e));
 			}
 			break;
 		default:
 		}
 
 		try {
 			if (this.cref == null) {
 				this.setResult(new URI("/aspects/" + id));
 			} else if (this.cref.getSite() == null) {
 				this.setResult(new URI("/aspects/" + id));
 			} else {
 				this.setResult(new URI(this.getCref().getSite() + "/aspects/"
 						+ id));
 			}
 		} catch (URISyntaxException e) {
 			this.setResult(e);
 		}
 	}
 
 	/***
 	 * @return the type
 	 */
 	public AspectTaskType getType() {
 		return type;
 	}
 
 	/***
 	 * @return the aspect
 	 */
 	public IAspect getAspect() {
 		return aspect;
 	}
 
 	/***
 	 * @return the points
 	 */
 	public List<IPoint> getPoints() {
 		return points;
 	}
 
 	/***
 	 * @return the cref
 	 */
 	public ContainerRef getCref() {
 		return cref;
 	}
 
 	/***
 	 * @return the aspectURI
 	 */
 	public URI getAspectURI() {
 		return aspectURI;
 	}
 
 }