import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Collections;
public class Graph
{
    private ArrayList<Node> nodes;
    private ArrayList<Edge> edges;

    public Graph(){
        this.nodes = new ArrayList<Node> ();
        this.edges = new ArrayList<Edge>();
    }

    public void addNode(Node n) {
        this.nodes.add(n);
    }

    public void addNode(int nr){
        this.nodes.add(new Node(nr));
    }

    public void addEdge(Edge e){
        this.edges.add(e);
        e.getAnfang().addEdge(e);
        e.getEnde().addEdge(e);
    }

    public void addEdge(int a, int e, int w, boolean g){
        Node an = null;
        Node en = null;
        for (int i = 0; i < this.nodes.size(); i++){
            if (this.nodes.get(i).getNumber() == a){
                an = this.nodes.get(i);
            }
            if (this.nodes.get(i).getNumber()== e){
                en = this.nodes.get(i);
            }
        }
        if (an == null || en == null){
            return;
        }
        this.addEdge(new Edge(an, en, w, g));
    }

    public Node getNode(int nr){
        for (Node n : this.nodes){
            if (n.getNumber() == nr){
                return n;
            }
        }
        return null;
    }

    public ArrayList<Node> breitensuche(int start){
        ArrayList<Node> ergebnis = new ArrayList<Node>();
        LinkedList<Node> q = new LinkedList<Node>();
        q.add(this.getNode(start));

        while(!q.isEmpty()){
            Node aktuell = q.removeFirst();
            if (ergebnis.contains(aktuell)){
                continue;
            }

            ArrayList<Node> erreichbar = aktuell.getTargets();
            Collections.sort(erreichbar);
            q.addAll(erreichbar);

            ergebnis.add(aktuell);
        }

        return ergebnis;
    }

    public ArrayList<Node> tiefensuche(int start){
        ArrayList<Node> ergebnis = new ArrayList<Node>();
        LinkedList<Node> q = new LinkedList<Node>();
        q.add(this.getNode(start));

        while(!q.isEmpty()){
            Node aktuell = q.removeLast();
            if (ergebnis.contains(aktuell)){
                continue;
            }

            ArrayList<Node> erreichbar = aktuell.getTargets();
            Collections.sort(erreichbar, Collections.reverseOrder());
            q.addAll(erreichbar);

            ergebnis.add(aktuell);
        }

        return ergebnis;
    }

    public ArrayList<Node> dijkstra (int start, int ziel){
        Node s = this.getNode(start);
        s.entfernung=0;
        ArrayList<Edge> edges = s.getEdges();
        for (Edge e : edges){
            Node n;

            if (e.getAnfang() == s ) n= e.getEnde();
            else n = e.getAnfang();
            int neu = s.entfernung +e.getWert();
            if (n.entfernung==-1 || neu < n.entfernung){
                n.entfernung = neu;
                n.vorgaenger = s;  
            }
        }
        
        s.bearbeitet = true;
        
        while(true){
        Node next = null; 
        for (Node n : this.nodes){
            if (!n.bearbeitet) continue;
            if (n.entfernung == -1) continue; 
            
            if (next == null || next.entfernung > n.entfernung){
                next = n;
            }
        }
        if (next == null) break;
        edges = next.getEdges();
        for (Edge e : edges){
            Node n;

            if (e.getAnfang() == s ) n= e.getEnde();
            else n = e.getAnfang();
            int neu = s.entfernung +e.getWert();
            if (n.entfernung==-1 || neu < n.entfernung){
                n.entfernung = neu;
                n.vorgaenger = next;  
            }
        }
        next.bearbeitet = true;
    }
    Node z = this.getNode(ziel);
    ArrayList<Node> ergebnis = new ArrayList<Node> ();
    while (z != null){
        ergebnis.add(z);
        z=z.vorgaenger;
    }
    return ergebnis;
}
}