package de.fhdw.wtf.common.task;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   import java.util.concurrent.Callable;
   
   import de.fhdw.wtf.common.exception.walker.CyclicDependencyException;
   import de.fhdw.wtf.common.exception.walker.DependencyException;
  import de.fhdw.wtf.common.task.result.ExceptionalTaskResult;
  import de.fhdw.wtf.common.task.result.OKTaskResult;
  import de.fhdw.wtf.common.task.result.TaskResult;
  import de.fhdw.wtf.common.task.result.visitor.TaskResultVisitor;
  
  /**
   * A dependency task is a piece of work that may have dependencies on other tasks completion and on which other tasks
   * may depend on.
   * 
   * On successful completion this task checks possible starts of tasks depending on it and submit it.
   * 
   */
  public abstract class DependencyTask implements Task, Callable<TaskResult> {
  	
  	/**
  	 * Tasks that depend on the successful execution of this task.
  	 */
  	private final DependencyList dependencies;
  	
  	/**
  	 * All dependency-tasks must have exited successfully, before this task may start its work.
  	 */
  	private final Collection<DependencyTask> observers;
  	
  	/**
  	 * Instance of the task executor managing the delayed start of a task, depending on defined thread resources.
  	 */
  	private final TaskExecutor taskmanager;
  	
  	/**
  	 * Constructor. This constructor introduces the new task directly to the task executor!
  	 * 
  	 * @see TaskExecutor#introduce(DependencyTask)
  	 * 
  	 * @param taskmanager
  	 *            task executor, that organizes concurrent execution of tasks
  	 */
  	public DependencyTask(final TaskExecutor taskmanager) {
  		this.dependencies = DependencyList.create(this);
  		this.observers = new ArrayList<>();
  		this.taskmanager = taskmanager;
  		taskmanager.introduce(this);
  	}
  	
  	@Override
  	public String toString() {
  		return this.getClass().getSimpleName();
  	}
  	
  	@Override
  	public final void start() {
  		System.out.println("[submitted] " + this);
  		this.taskmanager.submit(this);
  	}
  	
  	/**
  	 * Adds a new task as dependency for the current task.
  	 * 
  	 * @param a
  	 *            must have completed successfully before this task starts its work
  	 * @throws CyclicDependencyException
  	 *             when cyclic dependencies are added
  	 */
  	public void addDependency(final DependencyTask a) throws CyclicDependencyException {
  		
  		if (this.contains(a)) {
  			throw CyclicDependencyException.create(a.toString());
  		} else {
  			this.getDependencies().addDependency(a);
  			a.register(this);
  		}
  		
  	}
  	
  	/**
  	 * Adds a new observer on the successful execution of this task.
  	 * 
  	 * @param a
  	 *            wants to be notified
  	 */
  	private void register(final DependencyTask a) {
  		this.observers.add(a);
  	}
  	
  	/**
  	 * This operation must be called by its owning task, when it has successfully ended its work.
  	 */
  	synchronized void notifyObservers() {
  		final Iterator<DependencyTask> i = this.observers.iterator();
  		while (i.hasNext()) {
 			final DependencyTask current = i.next();
 			current.updateFinished(this);
 		}
 	}
 	
 	/**
 	 * Updates the list of dependencies because of <code>task</code> exited successful. It is no longer a dependency to
 	 * be fulfilled.
 	 * 
 	 * @param task
 	 *            successful executed task
 	 */
 	private synchronized void updateFinished(final DependencyTask task) {
 		final boolean removed = this.getDependencies().remove(task);
 		if (!removed) {
 			throw new DependencyException(this.toString() + ": Task <" + task.toString()
 					+ "> is not registered as dependency or already removed!!");
 		}
 		if (this.getDependencies().isEmpty()) {
 			this.start();
 		}
 	}
 	
 	/**
 	 * This tests whether the given task is a part of this task.
 	 * 
 	 * @param a
 	 *            task to be compared with this task
 	 * @return true, if a is a part of this task
 	 */
 	public boolean contains(final DependencyTask a) {
 		return this.equals(a) || this.containsTransitive(a);
 	}
 	
 	/**
 	 * This tests whether the given task is a transitive part of this task.
 	 * 
 	 * @param a
 	 *            task to be compared with this task
 	 * @return true, if a is a transitive part of this task
 	 */
 	public abstract boolean containsTransitive(DependencyTask a);
 	
 	@Override
 	public final TaskResult call() {
 		System.out.println("[started] " + this);
 		final TaskResult result = this.doWork();
 		System.out.println("[ended] " + this);
 		result.accept(new TaskResultVisitor() {
 			@Override
 			public void handleOkTaskResult(final OKTaskResult okTaskResult) {
 				DependencyTask.this.notifyObservers();
 			}
 			
 			@Override
 			public void handleExceptionalTaskResult(final ExceptionalTaskResult exceptionalTaskResult) {
 				// Nothing
 			}
 		});
 		
 		return result;
 	}
 	
 	/**
 	 * The tasks processes its work and produces a result in the end.
 	 * 
 	 * @return result of this task
 	 */
 	public abstract TaskResult doWork();
 	
 	/**
 	 * Gets a list of dependencies - tasks that are required to be run before this task starts its work.
 	 * 
 	 * @return list of dependencies
 	 */
 	protected DependencyList getDependencies() {
 		return this.dependencies;
 	}
 }