package cpath;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Stack;

/**
 * Stellt ein Projekt dar, das aus Arbeitspaketen besteht. Im Prinzip nichts
 * anderes als ein Graph mit Arbeitspaketen als Knoten. Das Projekt kennt nur
 * die Startknoten, diese kennen jeweils ihren Nachfolger.
 */
public class Project {

	private List<Workpackage> startNodes = new ArrayList<Workpackage>();
	private List<Workpackage> endNodes = new ArrayList<Workpackage>();
	private Set<Workpackage> criticalPathNodes = new HashSet<Workpackage>();
	private Set<Workpackage> allNodes = new HashSet<Workpackage>();
	private Stack<Workpackage> currentNodes = new Stack<Workpackage>();

	public List<Workpackage> getStartNodes() {
		return startNodes;
	}

	public void setStartNodes(List<Workpackage> startNodes) {
		this.startNodes = startNodes;
	}

	public Set<Workpackage> getCriticalPathNodes() {
		return criticalPathNodes;
	}

	public Set<Workpackage> getAllNodes() {
		return allNodes;
	}

	public void computeCriticalPath() {
		resetLists();
		// TODO: Implementieren Sie diese Methode, so dass nach deren Aufruf
		// alle Werte im Graph gesetzt sind und die beiden verfuegbaren Sets
		// korrekt befuellt wurden. Veraendern Sie nicht die Workpackage-Klasse!
		// Zum Testen koennen Sie die beigefuegte Test-Klasse verwenden und
		// erweitern. Beachten Sie, dass ihre Implementierung generell
		// funktionieren und nicht nur dieses eine Problem loesen soll.

		// ------------------------------------------------------------------------------|
		// VORWÄRTS ALLES DURCHGEHEN
		// ------------------------------------------------------------------------------|

		// Fülle die Stack initial mit den Start-Nodes
		for (Workpackage wp : startNodes) {
			currentNodes.add(wp);
		}

		while (!currentNodes.isEmpty()) {

			List<Workpackage> childNodes = new ArrayList<Workpackage>();

			while (!currentNodes.isEmpty()) {

				Workpackage currentPackage = currentNodes.pop();

				// If its not a start node we have to get the largest earliest finish of its
				// predecessors
				if (!startNodes.contains(currentPackage)) {
					Workpackage candidatePackage = null;
					for (Workpackage parPackage : currentPackage.getPredecessors()) {
						if (candidatePackage == null
								|| parPackage.getEarliestFinish() > candidatePackage.getEarliestFinish()) {
							candidatePackage = parPackage;
						}
					}
					currentPackage.setEarliestStart(candidatePackage.getEarliestFinish());
				}

				currentPackage.setEarliestFinish(currentPackage.getEarliestStart() + currentPackage.getDuration());

				// If there are no successors we have a end-node
				if (currentPackage.getSuccessors().isEmpty()) {
					endNodes.add(currentPackage);
				} else {
					// Else add all children to the temp children list
					for (Workpackage childPackage : currentPackage.getSuccessors()) {
						childNodes.add(childPackage);
					}
				}
			}

			for (Workpackage wp : childNodes) {
				currentNodes.push(wp);
			}

		}

		// ------------------------------------------------------------------------------|
		// RÜCKWÄRTS ALLES DURCHGEHEN
		// ------------------------------------------------------------------------------|

		// Finde das package mit größten earliest finish

		Workpackage candidatePackage = null;
		for (Workpackage wp : endNodes) {
			if (candidatePackage == null || wp.getEarliestFinish() > candidatePackage.getEarliestFinish()) {
				candidatePackage = wp;
			}
		}

		for (Workpackage wp : endNodes) {
			wp.setLatestFinish(candidatePackage.getEarliestFinish());
		}

		// Fülle die Stack initial mit den End-Nodes
		for (Workpackage wp : endNodes) {
			currentNodes.add(wp);
		}

		while (!currentNodes.isEmpty()) {

			List<Workpackage> parentNodes = new ArrayList<Workpackage>();

			while (!currentNodes.isEmpty()) {

				Workpackage currentPackage = currentNodes.pop();

				// If its not a start node we have to get the smallest earliest finish of its
				// predecessors
				if (!endNodes.contains(currentPackage)) {
					candidatePackage = null;
					for (Workpackage succPackage : currentPackage.getSuccessors()) {
						if (candidatePackage == null
								|| succPackage.getLatestStart() < candidatePackage.getLatestStart()) {
							candidatePackage = succPackage;
						}
					}
					currentPackage.setLatestFinish(candidatePackage.getLatestStart());
				}

				currentPackage.setLatestStart(currentPackage.getLatestFinish() - currentPackage.getDuration());
				currentPackage.setSlack(currentPackage.getLatestStart() - currentPackage.getEarliestStart());

				// Add all parents to the parent list
				if (!currentPackage.getPredecessors().isEmpty()) {
					for (Workpackage parentPackage : currentPackage.getPredecessors()) {
						parentNodes.add(parentPackage);
					}
				}

				// Before going to the next package add this one to the allNodes list
				allNodes.add(currentPackage);

			}

			for (Workpackage wp : parentNodes) {
				currentNodes.push(wp);
			}

		}

		// ------------------------------------------------------------------------------|
		// KRITISCHE PFADE ERKENNEN
		// ------------------------------------------------------------------------------|

		boolean isNoStartNode = true;
		Workpackage critPathNode = endNodes.stream().filter(x -> x.getSlack() == 0).findFirst().get();

		while (isNoStartNode) {
			criticalPathNodes.add(critPathNode);

			if (critPathNode.getPredecessors().isEmpty()) {
				isNoStartNode = false;
			} else {
				critPathNode = critPathNode.getPredecessors().stream().filter(x -> x.getSlack() == 0).findFirst().get();
			}
		}

	}

	private void resetLists() {
		currentNodes.clear();
		endNodes.clear();
		criticalPathNodes.clear();
		allNodes.clear();
	}
}