/**
 * 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

        // Finished: 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.
        // Finished: 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
        
        if(g.getVertex("Köln").getID().equals(pVertexID)){
            System.out.println("Köln gefunden");
            return true;
        } else {
            g.getVertex("Köln").setMark(true);
            searchQueue.enqueue(g.getVertex("Köln"));
            while(!searchQueue.isEmpty()){
                Vertex v = searchQueue.front();
                List<Vertex> ngbrs = g.getNeighbours(v);
                ngbrs.toFirst();
                while(ngbrs.hasAccess()){
                    if(!ngbrs.getContent().isMarked()){
                        System.out.println(ngbrs.getContent().getID());
                        if(ngbrs.getContent().getID().equals(pVertexID)){
                            System.out.println(ngbrs.getContent().getID() +" gefunden");
                            return true;
                        }
                        ngbrs.getContent().setMark(true);
                        searchQueue.enqueue(ngbrs.getContent());
                    }
                    ngbrs.next();
                }
                searchQueue.dequeue();
            }
        }
        System.out.println(pVertexID +" Nicht gefunden");
        return false;
    }

    public List<Vertex> copyList(List<Vertex>list){
        list.toFirst();
        List<Vertex> copy = new List<Vertex>();
        while(list.hasAccess()){
            copy.append(list.getContent());
            list.next();
        }
        return copy;
    }
    
    /**
     *
     * @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.
        if(g.getVertex("Köln").getID().equals(pVertexID)){
            System.out.println("Köln gefunden");
            return true;
        } else {
            g.getVertex("Köln").setMark(true);
            searchQueue.enqueue(g.getVertex("Köln"));
            while(!searchQueue.isEmpty()){
                Vertex v = searchQueue.front();
                List<Vertex> cngbrs=copyList(g.getNeighbours(v));
                cngbrs.toFirst();
                while(cngbrs.hasAccess()){
                    Vertex vs = getVertexFromListByID(cngbrs);
                    if(!vs.isMarked()){
                        System.out.println(vs.getID());
                        if(vs.getID().equals(pVertexID)){
                            System.out.println(vs.getID() +" gefunden");
                            return true;
                        }
                        vs.setMark(true);
                        searchQueue.enqueue(vs);
                    }
                    
                }
                searchQueue.dequeue();
            }
        }
        System.out.println(pVertexID +" Nicht gefunden");
        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

        // Finished: Ä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.
        if(g.getVertex("Köln").getID().equals(pVertexID)){
            System.out.println("Köln gefunden");
            return true;
        } else {
            g.getVertex("Köln").setMark(true);
            searchQueue.enqueue(g.getVertex("Köln"));
            while(!searchQueue.isEmpty()){
                Vertex v = searchQueue.front();
                List<Vertex> cngbrs=copyList(g.getNeighbours(v));
                cngbrs.toFirst();
                while(cngbrs.hasAccess()){
                    Vertex vs = getVertexFromListByWeight(v,cngbrs);
                    if(!vs.isMarked()){
                        System.out.println(vs.getID());
                        if(vs.getID().equals(pVertexID)){
                            System.out.println(vs.getID() +" gefunden");
                            return true;
                        }
                        vs.setMark(true);
                        searchQueue.enqueue(vs);
                    }
                    
                }
                searchQueue.dequeue();
            }
        }
        System.out.println(pVertexID +" Nicht gefunden");
        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;
    }
}