/**
 * Implementierung der Tiefensuche auf einem ungereichteten, gewichteten
 * Graphen.
 */
public class Breitensuche {

	private Graph g;

	public Breitensuche() {
		g = new Graph();

		// Aufbau des Graphen
		// Erstellen der Knoten (Vertices)
		Vertex koe = new Vertex("Köln");
		g.addVertex(koe);
		Vertex dues = new Vertex("Düsseldorf");
		g.addVertex(dues);
		Vertex dor = new Vertex("Dortmund");
		g.addVertex(dor);
		Vertex bi = new Vertex("Bielefeld");
		g.addVertex(bi);
		Vertex hnv = new Vertex("Hannover");
		g.addVertex(hnv);
		Vertex bo = new Vertex("Bochum");
		g.addVertex(bo);

		// Erstellen der Kanten (Edges)
		g.addEdge(new Edge(koe, dor, 96.0));
		g.addEdge(new Edge(dues, dor, 70.0));
		g.addEdge(new Edge(dor, bo, 22.0));
		g.addEdge(new Edge(bi, hnv, 113.0));
		g.addEdge(new Edge(bi, dor, 112.0));
		g.addEdge(new Edge(bi, dues, 178.0));
		g.addEdge(new Edge(bo, dues, 52.0));
	}

	/**
	 * Suche nach einem Vertex mit der angegebenen ID mittels der Breitensuche.
	 * 
	 * @param pVertexID
	 * @return
	 */
	public boolean findVertex(String pVertexID) {
		g.setAllVertexMarks(false); // Markierungen zurücksetzen
		Queue<Vertex> searchQueue = new Queue<>(); // Speicher für zu bearbeitende Knoten erstellen

		Vertex end = g.getVertex(pVertexID);

		Vertex start = g.getVertices().getContent();
		start.setMark(true);

		searchQueue.enqueue(start);

		while (!searchQueue.isEmpty()) {

			Vertex k = searchQueue.front();
			searchQueue.dequeue();
			
			System.out.println(k.getID());

			if (k.equals(end)) {
				System.out.println("Found!");
				return true;
			}

			List<Vertex> neighbours = g.getNeighbours(k);
			neighbours.toFirst();
			while (neighbours.hasAccess()) {
				Vertex n = neighbours.getContent();

				if (!n.isMarked()) {
					n.setMark(true);
					searchQueue.enqueue(n);
				}
				neighbours.next();
			}
		}

		// TODO: Implementiere die Breitensuche als iterativen Algorithmus:
		// Reihe dazu die noch nicht markierten Nachbarknoten in die
		// searchQueue ein und arbeite die Knoten in ihr der Reihe nach
		// ab, bis die Queue leer ist, oder der gesuchte Knoten
		// gefunden wurde.
		// TODO: Ergänze deine Methode um Ausgaben, anhand derer die Abarbeitung
		// deutlich wird.
		// TODO: Wenn dein Algorithmus funnktioniert, kopiere die Methode und
		// Erstelle Varianten, bei denen die Reihenfolge der Nachbarknoten
		// modifiziert ist. Dazu
		return false;
	}

	/**
	 *
	 * @param pVertexID
	 * @return
	 */
	public boolean findVertexByID(String pVertexID) {
		g.setAllVertexMarks(false); // Markierungen zurücksetzen
		Queue<Vertex> searchQueue = new Queue<>(); // Speicher für zu bearbeitende Knoten erstellen

		// TODO: Ändere die Breitensuche so ab, dass die Knoten so abgearbeitet
		// werden, dass die Nachbarknoten in alphabetischer Reihenfolge
		// besucht werden.
		// Nutze dazu die Hilfsmethode getVertexFromListByID, um aus
		// Liste der Nachbarknoten denjenigen, der alphabetisch als
		// erstes kommt herauszusuchen.
		return false;
	}

	public boolean findVertexByWeight(String pVertexID) {
		g.setAllVertexMarks(false); // Markierungen zurücksetzen
		Queue<Vertex> searchQueue = new Queue<>(); // Speicher für zu bearbeitende Knoten erstellen

		// TODO: Ändere die Breitensuche so ab, dass die Knoten so abgearbeitet
		// werden, dass der Nachbarknoten mit der Kante mit dem geringsten
		// Gewicht zuerst besucht wird.
		// Nutze dazu die Hilfsmethode getVertexFromListByWeight, um aus
		// Liste der Nachbarknoten denjenigen mit dem geringsten Gewicht
		// herauszusuchen.
		return false;
	}

	/**
	 * Sucht aus einer Liste von Knoten denjenigen, dessen ID alphabetisch ale
	 * erstes kommt. Der Knoten wird aus der Liste gelöscht und dann zurück
	 * gegeben.
	 * 
	 * @param pVertices
	 * @return
	 */
	private Vertex getVertexFromListByID(List<Vertex> pVertices) {
		pVertices.toFirst();
		Vertex v = pVertices.getContent();
		do {
			pVertices.next();

			if (pVertices.hasAccess() && pVertices.getContent().getID().compareToIgnoreCase(v.getID()) < 0) {
				v = pVertices.getContent();
			}
		} while (pVertices.hasAccess());

		pVertices.toFirst();
		while (pVertices.hasAccess()) {
			if (pVertices.getContent().getID().equals(v.getID())) {
				break;
			}
			pVertices.next();
		}
		pVertices.remove();
		return v;
	}

	/**
	 * Sucht aus einer Liste von Knoten denjenigen, dessen Kantengewicht zum Konten
	 * <code>pCurrentVertex</code> am geringsten ist. Der Knoten wird aus der Liste
	 * gelöscht und dann zurück gegeben.
	 * 
	 * @param pVertices
	 * @return
	 */
	private Vertex getVertexFromListByWeight(Vertex pCurrentVertex, List<Vertex> pVertices) {
		pVertices.toFirst();
		Vertex v = pVertices.getContent();
		double weight = g.getEdge(pCurrentVertex, v).getWeight();
		do {
			pVertices.next();

			if (pVertices.hasAccess() && g.getEdge(pCurrentVertex, pVertices.getContent()).getWeight() < weight) {
				v = pVertices.getContent();
			}
		} while (pVertices.hasAccess());

		pVertices.toFirst();
		while (pVertices.hasAccess()) {
			if (pVertices.getContent().getID().equals(v.getID())) {
				break;
			}
			pVertices.next();
		}
		pVertices.remove();
		return v;
	}
}