package de.fhdw.wtf.common.task;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   
   import de.fhdw.wtf.common.exception.walker.CyclicDependencyException;
   import de.fhdw.wtf.common.exception.walker.CyclicPartDefinitionException;
   import de.fhdw.wtf.common.task.result.OKTaskResult;
  import de.fhdw.wtf.common.task.result.TaskResult;
  
  /**
   * A GroupDependencyTask groups multiple member tasks to a seperate unit. It may as well have dependencies and be a
   * dependency for others.
   * 
   */
  public class GroupDependencyTask extends DependencyTask {
  	
  	/**
  	 * Members participating in this group.
  	 */
  	private final Collection<DependencyTask> members;
  	
  	/**
  	 * Constructor of {@link GroupDependencyTask}.
  	 * 
  	 * @param taskmanager
  	 *            taskmanager
  	 */
  	public GroupDependencyTask(final TaskExecutor taskmanager) {
  		super(taskmanager);
  		this.members = new ArrayList<>();
  	}
  	
  	/**
  	 * Creates a {@link GroupDependencyTask}-Object.
  	 * 
  	 * @param taskmanager
  	 *            taskmanager
  	 * @return The {@link GroupDependencyTask}-Object.
  	 */
  	public static GroupDependencyTask create(final TaskExecutor taskmanager) {
  		return new GroupDependencyTask(taskmanager);
  	}
  	
  	/**
  	 * Adds this task as member of this group.
  	 * 
  	 * @param t
  	 *            new group member
  	 * @throws CyclicPartDefinitionException
  	 *             when cycles would arise
  	 */
  	public void addMember(final DependencyTask t) throws CyclicPartDefinitionException {
  		if (this.contains(t)) {
  			throw CyclicPartDefinitionException.create();
  		} else {
  			try {
  				super.addDependency(t);
  				this.members.add(t);
  				final Iterator<DependencyTask> i = this.getDependencies().getDependencies().iterator();
  				while (i.hasNext()) {
  					final DependencyTask current = i.next();
  					if (!this.members.contains(current)) {
  						t.addDependency(current);
  					}
  				}
  			} catch (final CyclicDependencyException e) {
  				throw CyclicPartDefinitionException.create();
  			}
  		}
  	}
  	
  	/**
  	 * Adds all tasks as member of this group task individually.
  	 * 
  	 * @param newMembers
  	 *            list of independent multiple new members
  	 * @throws CyclicPartDefinitionException
  	 *             when cycles would arise
  	 * @see {@link #addMember(DependencyTask)}
  	 */
  	public void addMembers(final DependencyTask... newMembers) throws CyclicPartDefinitionException {
  		for (final DependencyTask newMember : newMembers) {
  			this.addMember(newMember);
  		}
  	}
  	
  	@Override
  	public void addDependency(final DependencyTask a) throws CyclicDependencyException {
  		final Iterator<DependencyTask> i = this.members.iterator();
  		while (i.hasNext()) {
  			final DependencyTask current = i.next();
  			current.addDependency(a);
  		}
  		super.addDependency(a);
  	}
  	
  	@Override
 	public boolean containsTransitive(final DependencyTask a) {
 		final Iterator<DependencyTask> i = this.members.iterator();
 		while (i.hasNext()) {
 			final DependencyTask current = i.next();
 			if (current.contains(a)) {
 				return true;
 			}
 		}
 		return false;
 	}
 	
 	@Override
 	public TaskResult doWork() {
 		return new OKTaskResult();
 	}
 	
 }