package horstmann.ch08_graphed;
import java.awt.Graphics2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
   A graph consisting of selectable nodes and edges.
 */
public abstract class Graph implements Serializable
{
  private static final long serialVersionUID = 2008L;
  /**
      Constructs a graph with no nodes or edges.
   */
  public Graph()
  {
    nodes = new ArrayList<Node>();
    edges = new ArrayList<Edge>();
  }

  /**
      Adds an edge to the graph that joins the nodes containing
      the given points. If the points aren't both inside nodes,
      then no edge is added.
      @param e the edge to add
      @param p1 a point in the starting node
      @param p2 a point in the ending node
   */
  public boolean connect(Edge e, Point2D p1, Point2D p2)
  {
    Node n1 = findNode(p1);
    Node n2 = findNode(p2);
    if (n1 != null && n2 != null)
    {
      e.connect(n1, n2);
      edges.add(e);
      return true;
    }
    return false;
  }

  /**
      Adds a node to the graph so that the top left corner of
      the bounding rectangle is at the given point.
      @param n the node to add
      @param p the desired location
   */
  public boolean add(Node n, Point2D p)
  {
    Rectangle2D bounds = n.getBounds();
    n.translate(p.getX() - bounds.getX(),
        p.getY() - bounds.getY());
    nodes.add(n);
    return true;
  }

  /**
      Finds a node containing the given point.
      @param p a point
      @return a node containing p or null if no nodes contain p
   */
  public Node findNode(Point2D p)
  {
    for (int i = nodes.size() - 1; i >= 0; i--)
    {
      Node n = nodes.get(i);
      if (n.contains(p)) return n;
    }
    return null;
  }

  /**
      Finds an edge containing the given point.
      @param p a point
      @return an edge containing p or null if no edges contain p
   */
  public Edge findEdge(Point2D p)
  {
    for (int i = edges.size() - 1; i >= 0; i--)
    {
      Edge e = edges.get(i);
      if (e.contains(p)) return e;
    }
    return null;
  }

  /**
      Draws the graph
      @param g2 the graphics context
   */
  public void draw(Graphics2D g2)
  {
    for (Node n : nodes)
      n.draw(g2);

    for (Edge e : edges)
      e.draw(g2);

  }

  /**
      Removes a node and all edges that start or end with that node
      @param n the node to remove
   */
  public void removeNode(Node n)
  {
    for (int i = edges.size() - 1; i >= 0; i--)
    {
      Edge e = edges.get(i);
      if (e.getStart() == n || e.getEnd() == n)
        edges.remove(e);
    }
    nodes.remove(n);
  }

  /**
      Removes an edge from the graph.
      @param e the edge to remove
   */
  public void removeEdge(Edge e)
  {
    edges.remove(e);
  }

  /**
      Gets the smallest rectangle enclosing the graph
      @param g2 the graphics context
      @return the bounding rectangle
   */
  public Rectangle2D getBounds(Graphics2D g2)
  {
    Rectangle2D r = null;
    for (Node n : nodes)
    {
      Rectangle2D b = n.getBounds();
      if (r == null) r = b;
      else r.add(b);
    }
    for (Edge e : edges)
      r.add(e.getBounds(g2));
    return r == null ? new Rectangle2D.Double() : r;
  }

  /**
      Gets the node types of a particular graph type.
      @return an array of node prototypes
   */
  public abstract Node[] getNodePrototypes();

  /**
      Gets the edge types of a particular graph type.
      @return an array of edge prototypes
   */
  public abstract Edge[] getEdgePrototypes();

  /**
      Gets the nodes of this graph.
      @return an unmodifiable list of the nodes
   */
  public List<Node> getNodes()
  {
    return Collections.unmodifiableList(nodes); }

  /**
      Gets the edges of this graph.
      @return an unmodifiable list of the edges
   */
  public List<Edge> getEdges()
  {
    return Collections.unmodifiableList(edges);
  }

  private ArrayList<Node> nodes;
  private ArrayList<Edge> edges;
}