/*
 *    GeoTools - The Open Source Java GIS Toolkit
 *    http://geotools.org
 *
 *    (C) 2002-2008, Open Source Geospatial Foundation (OSGeo)
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation;
 *    version 2.1 of the License.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 */
package org.geotools.graph.build.basic;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

import org.geotools.graph.build.GraphBuilder;
import org.geotools.graph.structure.Edge;
import org.geotools.graph.structure.Graph;
import org.geotools.graph.structure.Node;
import org.geotools.graph.structure.basic.BasicEdge;
import org.geotools.graph.structure.basic.BasicGraph;
import org.geotools.graph.structure.basic.BasicNode;

/**
 * Basic implementation of GraphBuilder. This implementation of builder 
 * creates the graph when the builder is created. The underlying graph 
 * implementation makes copies of the references to the node and edge 
 * collections, not copies of the underlying collections themselves. In this
 * way as nodes and edges are added to the builder, it is reflected in the 
 * built graph.
 * 
 * @author Justin Deoliveira, Refractions Research Inc, jdeolive@refractions.net
 *
 *
 * @source $URL$
 */
public class BasicGraphBuilder implements GraphBuilder {

  /** graph being built **/
  private Graph m_graph;
  
  /** nodes of graph being built **/
  private HashSet m_nodes;
  
  /** edges of graph being built **/
  private HashSet m_edges;
  
  /**
   * Constructs a new empty graph builder.
   */
  public BasicGraphBuilder () {
    m_nodes = new HashSet();
    m_edges = new HashSet();
    m_graph = buildGraph();
  }
  
  /**
   * @see GraphBuilder#buildNode()
   */
  public Node buildNode() {
    return(new BasicNode());  
  }

  /**
   * @see GraphBuilder#buildEdge(Node, Node)
   */
  public Edge buildEdge(Node nodeA, Node nodeB) {
    return(new BasicEdge(nodeA,nodeB));
  }

  /**
   * @see GraphBuilder#addNode(Node)
   */
  public void addNode(Node node) {
    m_nodes.add(node);  
  }

  /**
   * Checks for loops in which case it only added the edge to the adjacency 
   * list of one of the nodes (both of its nodes are the same node).
   * 
   * @see GraphBuilder#addEdge(Edge)
   */
  public void addEdge(Edge edge) {
    edge.getNodeA().add(edge);
    
    //if the edge is a loop edge, which is legal, only add to node once
    if (!edge.getNodeA().equals(edge.getNodeB())) edge.getNodeB().add(edge);
    m_edges.add(edge);
  }

  /**
   * @see GraphBuilder#removeNode(Node)
   */
  public void removeNode(Node node) {
    //prevents concurrent modification
    ArrayList toRemove = new ArrayList(node.getEdges());
    removeEdges(toRemove);
    m_nodes.remove(node);
  }

  /**
   * @see GraphBuilder#removeNodes(Collection)
   */
  public void removeNodes(Collection nodes) {
    for (Iterator itr = nodes.iterator(); itr.hasNext();) {
      Node n = (Node)itr.next();
      removeNode(n);
    }
  }
  
  /**
   * @see GraphBuilder#removeEdge(Edge)
   */
  public void removeEdge(Edge edge) {
    edge.getNodeA().remove(edge);
    edge.getNodeB().remove(edge);
    m_edges.remove(edge);
  }
  
  /**
   * @see GraphBuilder#removeEdges(Collection)
   */
  public void removeEdges(Collection edges) {
    for (Iterator itr = edges.iterator(); itr.hasNext();) {
      Edge e = (Edge)itr.next();
      removeEdge(e);
    }  
  }
  
  /**
   * @see GraphBuilder#getGraph() 
   */  
  public Graph getGraph() {
    return(m_graph);  
  }
  
  /**
   * @see GraphBuilder#clone(boolean)
   */
  public Object clone(boolean deep) throws Exception {
    GraphBuilder builder = (GraphBuilder)getClass().newInstance();
    if (deep) builder.importGraph(getGraph());
    
    return(builder);
  }

  /**
   * @see GraphBuilder#importGraph(Graph)
   */
  public void importGraph(Graph g) {
    m_nodes = new HashSet(g.getNodes());
    m_edges = new HashSet(g.getEdges());
    m_graph = buildGraph();
  }

  /**
   * Returns the nodes belonging to the graph being built.
   * 
   * @return A collection of nodes.
   */
  public Collection getNodes() {
    return(m_nodes);  
  }
  
  /**
   * Returns the edges belonging to the graph being built.
   * 
   * @return A collection of edges.
   */
  public Collection getEdges() {
    return(m_edges);  
  }
  
  /**
   * Creates the underlying graph object.
   * 
   * @return A Graph object.
   */
  protected Graph buildGraph() {
    return(new BasicGraph(m_nodes, m_edges));
  }
}