package MaxFlowApplet.graph;

import java.util.Vector;

public class Graph {
    // default constructor
    public Graph()
    {
        vertices = new Vector(DEFAULTSIZE, DEFAULTINCREMENT);
        edges = new Vector(DEFAULTSIZE, DEFAULTINCREMENT);
        mark();
    };
    // constructor for demo graphs
    public Graph(Vertex vertex[], int vNumber, Edge edge[], int eNumber)
    {
        // the array of vertices must contain at least two vertices
        this();
        setSource(vertex[0]);
        setSink(vertex[1]);
        for(int i = 2; i < vNumber; i++)
            vertices.addElement(vertex[i]);
        for(int i = 0; i < eNumber; i++)
            edges.addElement(edge[i]);
    };

    // mark the current state (number of vertices & edges) of the graph
    public void mark()
    {
        vertexNo = vertices.size();
        edgeNo = edges.size();
    };

    // restores the marked state of the graph (after the maxflow)
    public void release()
    {
        vertices.setSize(vertexNo);
        edges.setSize(edgeNo);
    };

    // adds a vertex to graph
    public void addVertex(Vertex v)
    {
        vertices.addElement(v);
    };

    // creates a vertex and adds it to the graph
    public void addNewVertex()
    {
        vertices.addElement(new Vertex());
    };

    // creates an edge and adds it to the graph
    public Edge addNewEdge(Vertex v1, Vertex v2)
    {
        Edge e = new Edge();
        e.setVertexFrom(v1);
        e.setVertexTo(v2);
        addEdge(e);
        return e;
    };

    // adds an edge to graph and updates the edge references in vertices
    public void addEdge(Edge e)
    {
        e.getVertexFrom().addEdgeOut(e);
        e.getVertexTo().addEdgeIn(e);
        edges.addElement(e);
    };

    // removes a vertex and all of its edges from graph
    public void removeVertex(Vertex v)
    {
        int fan;
        Edge e;
        Vertex u;
        fan = v.fanIn();
        for(int i = fan-1; i >= 0; i--)
        {
            e = v.getEdgeIn(i);
            u = e.getVertexFrom();
            u.removeEdgeOut(e);
            removeEdge(e);
        }
        fan = v.fanOut();
        for(int i = fan-1; i >= 0; i--)
            {
                e = v.getEdgeOut(i);
                u = e.getVertexTo();
                u.removeEdgeIn(e);
                removeEdge(e);
            }
        vertices.removeElement(v);
    };


    // removes an edge from the graph without checking if the edge
    // is references in a vertex
    public void removeEdge(Edge e)
    {
        Vertex from = e.getVertexFrom();
        Vertex to = e.getVertexTo();

        from.removeEdgeOut(e);
        to.removeEdgeIn(e);
        edges.removeElement(e);
    };


    // returns the number of vertices in the graph
    public int numberOfVertices()
    {
        return vertices.size();
    };

    // returns the wanted vertex
    public Vertex getVertex(int index)
    {
        return (Vertex) vertices.elementAt(index);
    };

    // returns the number of edges in the graph
    public int numberOfEdges()
    {
        return edges.size();
    };

    // returns the wanted edge
    public Edge getEdge(int index)
    {
        return (Edge) edges.elementAt(index);
    };

    // returns the source of the graph
    public Vertex getSource()
    {
        return source;
    };

    // sets the source to the new value
    public void setSource(Vertex v)
    {
        source = v;
        addVertex(v);
    };

    // returns the sink of the graph
    public Vertex getSink()
    {
        return sink;
    };

    // sets the sink to the new value
    public void setSink(Vertex v)
    {
        sink = v;
        addVertex(v);
    };

    // a vector of vertices and a vector of edges
    protected Vector vertices;
    protected Vector edges;

    protected Vertex source;
    protected Vertex sink;

    // the following fields are used for mark & release
    protected int edgeNo;
    protected int vertexNo;

    // constants
    static final int DEFAULTSIZE  = 10;
    static final int DEFAULTINCREMENT = 10;
};