package graph;

/**
 * Created with xgiovio.macbookair.
 * User: xgiovio
 * Date: 19/05/14
 * Time: 16:30
 */

import java.util.Iterator;

/**
 * An realization of a graph according to adjacency list structure.
 *
 * @author Roberto Tamassia, Eric Zamore
 */

public class AdjacencyListGraph<V,E> implements Graph<V,E> {

    protected NodePositionList<Vertex<V>> VList;	// container for vertices
    protected NodePositionList<Edge<E>> EList;	// container for edges
    /** Default constructor that creates an empty graph */
    public AdjacencyListGraph() {
        VList = new NodePositionList<Vertex<V>>();
        EList = new NodePositionList<Edge<E>>();
    }
    /** Return an iterator over the vertices of the graph */
    public Iterable<Vertex<V>> vertices() {
        return VList;
    }
    /** Return an iterator over the edges of the graph */
    public Iterable<Edge<E>> edges() {
        return EList;
    }
    /** Replace the element a given position (vertex or edge) with a new
     element and return the old element */
    public Object replace(Position p, Object o)
            throws InvalidPositionException {
        MyPosition pp = checkPosition(p);
        Object temp = p.element();
        pp.setElement(o);
        return temp;
    }
    /** Return an iterator over the edges incident on a vertex */
    public Iterable<Edge<E>> incidentEdges(Vertex<V> v)
            throws InvalidPositionException {
        MyVertex<V> vv = checkVertex(v);
        return vv.incidentEdges();

    }
    /** Return the endvertices of a edge in an array of length 2 */
    public Vertex<V>[] endVertices(Edge<E> e)
            throws InvalidPositionException {
        MyEdge<E> ee = checkEdge(e);
        return ee.endVertices();
    }
    /** Return the other endvertex of an incident edge */
    public Vertex<V> opposite(Vertex<V> v, Edge<E> e)
            throws InvalidPositionException {
        checkVertex(v);
        MyEdge<E> ee = checkEdge(e);
        Vertex<V>[] endv = ee.endVertices();
        if (v == endv[0])
            return endv[1];
        else if (v == endv[1])
            return endv[0];
        else
            throw new InvalidPositionException("No such vertex exists");
    }
    /** Test whether two vertices are adjacent */
    public boolean areAdjacent(Vertex<V> u, Vertex<V> v)
            throws InvalidPositionException {
        // search the incidence list of the vertex with smaller degree
        Iterable<Edge<E>> iterToSearch;
        if (degree(u) < degree(v)) {
            iterToSearch = incidentEdges(u);
        }
        else {
            iterToSearch = incidentEdges(v);
        }
        for (Edge<E> e: iterToSearch ) {
            Vertex<V>[] endV = endVertices(e);
            // if there exists an edge whose endpoints are u and v
            if ((endV[0] == u && endV[1] == v) || (endV[0] == v && endV[1] == u))
                return true;
        }
        return false;
    }
    /** Insert and return a new vertex with a given element */
    public Vertex<V> insertVertex(V o) {
        MyVertex<V> vv =  new MyVertex<V>(o);
        VList.addLast(vv);
        Position<Vertex<V>> p = VList.last();
        vv.setLocation(p);
        return vv;
    }
    /** Insert and return a new edge with a given element between two
     vertices */
    public Edge<E> insertEdge(Vertex<V> v, Vertex<V> w, E o)
            throws InvalidPositionException {
        MyVertex<V> vv = checkVertex(v);
        MyVertex<V> ww = checkVertex(w);
        MyEdge<E> ee = new MyEdge<E>(v, w, o);
        Position<Edge<E>> pv = vv.insertIncidence(ee);
        Position<Edge<E>> pw = ww.insertIncidence(ee);
        ee.setIncidences(pv, pw);
        EList.addLast(ee);
        Position<Edge<E>> pe = EList.last();
        ee.setLocation(pe);
        return ee;
    }
    /** Remove a vertex and all its incident edges and return the
     element stored at the removed vertex */
    public V removeVertex(Vertex<V> v)
            throws InvalidPositionException {
        MyVertex<V> vv = checkVertex(v);
        Iterator<Edge<E>> inc = incidentEdges(v).iterator();
        while (inc.hasNext()) {
            MyEdge<E> e = (MyEdge<E>) inc.next();
            if (e.location() != null) // if the edge has not been marked invalid
                removeEdge(e);
        }
        VList.remove(vv.location());
        return v.element();
    }
    /** Remove an edge and return its element */
    public E removeEdge(Edge<E> e)
            throws InvalidPositionException {
        MyEdge<E> ee = checkEdge(e);
        MyVertex<V>[] endv = ee.endVertices();
        Position<Edge<E>>[] inc = ee.incidences();
        endv[0].removeIncidence(inc[0]);
        endv[1].removeIncidence(inc[1]);
        EList.remove(ee.location());
        ee.setLocation(null);	// invalidating this edge
        return e.element();
    }

    // Auxiliary methods

    /** Return the degree of a given vertex */
    public int degree(Vertex<V> v) {
        MyVertex<V> vv = checkVertex(v);
        return vv.degree();
    }

    /** Determines whether a given position is valid. */
    protected MyPosition checkPosition(Position p)
            throws InvalidPositionException {
        if (p == null || !(p instanceof MyPosition))
            throw new InvalidPositionException("Position is invalid");
        return (MyPosition) p;
    }

    /** Determines whether a given vertex is valid. */
    protected MyVertex<V> checkVertex(Vertex<V> v)
            throws InvalidPositionException {
        if (v == null || !(v instanceof MyVertex))
            throw new InvalidPositionException("Vertex is invalid");
        return (MyVertex<V>) v;
    }

    /** Determines whether a given edge is valid. */
    protected MyEdge<E> checkEdge(Edge<E> e)
            throws InvalidPositionException {
        if (e == null || !(e instanceof MyEdge))
            throw new InvalidPositionException("Edge is invalid");
        return (MyEdge<E>) e;
    }

    /** Implementation of a decorable position by means of a hash
     * table. */
    protected static class MyPosition<T>
            extends HashTableMap<Object,Object> implements DecorablePosition<T> {
        /** The element stored at this position. */
        protected T elem;
        /** Returns the element stored at this position. */
        public T element() {
            return elem;
        }
        /** Sets the element stored at this position. */
        public void setElement(T o) {
            elem = o;
        }
    }

    /** Returns a string representation of the vertex and edge lists,
     * separated by a newline. */
    public String toString() {
        return VList.toString() + "\n" +  EList.toString();
    }

    public int numVertices() {
        return VList.size();
    }

    public int numEdges() {
        return EList.size();
    }

    public V replace(Vertex<V> p, V o) throws InvalidPositionException {
        V temp = p.element();
        MyVertex<V> vv = checkVertex(p);
        vv.setElement(o);
        return temp;
    }

    public E replace(Edge<E> p, E o) throws InvalidPositionException {
        E temp = p.element();
        MyEdge<E> ee = checkEdge(p);
        ee.setElement(o);
        return temp;
    }

    /** Implementation of a vertex for an undirected adjacency list
     * graph.  Each vertex stores its incidence container and position
     * in the vertex container of the graph. */
    protected  class MyVertex<V>
            extends MyPosition<V> implements Vertex<V> {
        /** Incidence container of the vertex. */
        protected PositionList<Edge<E>> incEdges;
        /** Position of the vertex in the vertex container of the graph. */
        protected Position<Vertex<V>> loc;
        /** Constructs the vertex with the given element. */
        MyVertex(V o) {
            elem = o;
            incEdges = new NodePositionList<Edge<E>>();
        }
        /** Return the degree of a given vertex */
        public int degree() {
            return incEdges.size();
        }
        /** Returns the incident edges on this vertex. */
        public Iterable<Edge<E>> incidentEdges() {
            return incEdges;
        }
        /** Inserts an edge into the incidence container of this vertex. */
        public Position<Edge<E>> insertIncidence(Edge<E> e) {
            incEdges.addLast(e);
            return incEdges.last();
        }
        /** Removes an edge from the incidence container of this vertex. */
        public void removeIncidence(Position<Edge<E>> p) {
            incEdges.remove(p);
        }
        /** Returns the position of this vertex in the vertex container of
         * the graph. */
        public Position<Vertex<V>> location() {
            return loc;
        }
        /** Sets the position of this vertex in the vertex container of
         * the graph. */
        public void setLocation(Position<Vertex<V>> p) {
            loc = p;
        }
        /** Returns a string representation of the element stored at this
         * vertex. */
        public String toString() {
            return elem.toString();
        }
    }

    /** Implementation of an edge for an undirected adjacency list
     * graph.  Each edge stores its endpoints (end vertices), its
     * positions within the incidence containers of its endpoints, and
     * position in the edge container of the graph. */
    protected class MyEdge<E> extends MyPosition<E> implements Edge<E> {

        /** The end vertices of the edge. */
        protected MyVertex<V>[] endVertices;
        /** The positions of the entries for the edge in the incidence
         * containers of the end vertices. */
        protected Position<Edge<E>>[] Inc;
        /** The position of the edge in the edge container of the
         * graph. */
        protected Position<Edge<E>> loc;

        /** Constructs an edge with the given endpoints and elements. */
        MyEdge (Vertex<V> v, Vertex<V> w, E o) {
            elem = o;
            endVertices = (MyVertex<V>[]) new MyVertex[2];
            endVertices[0] = (MyVertex<V>)v;
            endVertices[1] = (MyVertex<V>)w;
            Inc = (Position<Edge<E>>[]) new Position[2];
        }
        /** Returns the end vertices of the edge. There are always two
         * elements in the returned array. */
        public MyVertex<V>[] endVertices() {
            return endVertices;
        }
        /** Returns the positions of the edge in the incidence containers
         * of its end vertices.  The returned array always contains two
         * elements. */
        public Position<Edge<E>>[] incidences() {
            return Inc;
        }
        /** Sets the positions of the edge in the incidence containers of
         * its end vertices. */
        public void setIncidences(Position<Edge<E>> pv, Position<Edge<E>> pw) {
            Inc[0] = pv;
            Inc[1] = pw;
        }
        /** Returns the position of the edge in the edge container of the
         * graph. */
        public Position<Edge<E>> location() {
            return loc;
        }
        /** Sets the position of the edge in the edge container of the
         * graph. */
        public void setLocation(Position<Edge<E>> p) {
            loc = p;
        }
        /** Returns a string representation of the edge via a tuple of
         * vertices. */
        public String toString() {
            return element() + "(" + endVertices[0].toString() +
                    "," + endVertices[1].toString() + ")";
        }
    }
}