/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.oodt.cas.workflow.gui.perspective.view.impl;

//JDK imports
import java.awt.Color;
import java.awt.Font;
import java.awt.geom.Rectangle2D;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.swing.BorderFactory;

//OODT imports
import org.apache.oodt.cas.workflow.gui.model.ModelNode;

//JGraph imports
import org.jgraph.event.GraphModelEvent;
import org.jgraph.event.GraphModelListener;
import org.jgraph.graph.AttributeMap;
import org.jgraph.graph.ConnectionSet;
import org.jgraph.graph.DefaultEdge;
import org.jgraph.graph.DefaultGraphCell;
import org.jgraph.graph.DefaultGraphModel;
import org.jgraph.graph.DefaultPort;
import org.jgraph.graph.GraphConstants;

//Jung imports
import edu.uci.ics.jung.graph.ObservableGraph;
import edu.uci.ics.jung.graph.event.GraphEvent;
import edu.uci.ics.jung.graph.event.GraphEventListener;

/**
 * 
 * This class integrates OODT, Jung and JGraph.
 * 
 * Not necessarily in that order. It acts as a facade, wrapping a Jung graph
 * (and its modifications) and then using that to update the current state of
 * the associated JGraph model.
 * 
 * @author mattmann
 * 
 */
public class JungJGraphModelAdapter extends DefaultGraphModel {

  private static final long serialVersionUID = 205647349848965651L;

  private ObservableGraph<ModelNode, IdentifiableEdge> jungGraph;

  private Map<String, DefaultGraphCell> cellMap;

  private static final Logger LOG = Logger
      .getLogger(JungJGraphModelAdapter.class.getName());

  public JungJGraphModelAdapter(
      final ObservableGraph<ModelNode, IdentifiableEdge> jungGraph) {
    this.jungGraph = jungGraph;
    this.jungGraph.addGraphEventListener(new WorkflowChangeListener(this));
    this.cellMap = new HashMap<String, DefaultGraphCell>();
    this.addGraphModelListener(new GraphModelListener() {

      @Override
      public void graphChanged(GraphModelEvent e) {
        Object[] added = e.getChange().getInserted();
        Object[] removed = e.getChange().getRemoved();
        Object[] changed = e.getChange().getChanged();

        if (added != null && added.length > 0) {
          for (Object a : added) {
            LOG.log(Level.FINE, "Jgraph notification of object added: ["
                + a.getClass().getName() + "]");

            if (a instanceof org.jgraph.graph.DefaultEdge) {
              LOG.log(Level.FINE, "Edge added to jgraph");
              org.jgraph.graph.DefaultEdge edge = (org.jgraph.graph.DefaultEdge) a;
              if (!jungGraph.getEdges().contains(edge.getUserObject())) {
                jungGraph.addEdge(
                    new IdentifiableEdge((ModelNode) edge.getSource(),
                        (ModelNode) edge.getTarget()), (ModelNode) edge
                        .getSource(), (ModelNode) edge.getTarget());
              }
            } else if (a instanceof org.jgraph.graph.DefaultGraphCell) {
              LOG.log(Level.FINE, "Vertex added to jgraph");
              org.jgraph.graph.DefaultGraphCell cell = (org.jgraph.graph.DefaultGraphCell) a;

              if (!jungGraph.getVertices().contains(cell.getUserObject())) {
                jungGraph.addVertex((ModelNode) cell.getUserObject());
              }
            }
          }
        }

        if (removed != null && removed.length > 0) {
          for (Object r : removed) {
            LOG.log(Level.FINE, "Jgraph notification of object removed: ["
                + r.getClass().getName() + "]");

            if (r instanceof org.jgraph.graph.DefaultEdge) {
              LOG.log(Level.FINE, "Edge removed from jgraph");
              org.jgraph.graph.DefaultEdge edge = (org.jgraph.graph.DefaultEdge) r;
              if (jungGraph.getEdges().contains(edge.getUserObject())) {
                jungGraph.removeEdge((IdentifiableEdge) edge.getUserObject());
              }
            } else if (r instanceof org.jgraph.graph.DefaultGraphCell) {
              LOG.log(Level.FINE, "Vertex removed from jgraph");
              org.jgraph.graph.DefaultGraphCell cell = (org.jgraph.graph.DefaultGraphCell) r;

              if (jungGraph.getVertices().contains(cell.getUserObject())) {
                jungGraph.removeVertex((ModelNode) cell.getUserObject());
              }
            }
          }
        }

      }
    });

  }

  public DefaultGraphCell getVertexCell(ModelNode node) {
    if (cellMap.get(node.getId()) != null) {
      return cellMap.get(node.getId());
    }

    DefaultGraphCell cell = new DefaultGraphCell(node);
    cell.add(new DefaultPort());
    return cell;
  }

  private AttributeMap getEdgeAttributes(DefaultEdge edge) {
    AttributeMap eMap = new AttributeMap();
    GraphConstants.setLineEnd(eMap, GraphConstants.ARROW_TECHNICAL);
    GraphConstants.setEndFill(eMap, true);
    GraphConstants.setEndSize(eMap, 10);
    GraphConstants.setForeground(eMap, Color.decode("#25507C"));
    GraphConstants.setFont(eMap,
        GraphConstants.DEFAULTFONT.deriveFont(Font.BOLD, 12));
    GraphConstants.setLineColor(eMap, Color.decode("#7AA1E6"));
    AttributeMap map = new AttributeMap();
    map.put(edge, eMap);
    return map;
  }

  private AttributeMap getVertexAttributes(DefaultGraphCell cell) {
    AttributeMap vMap = new AttributeMap();

    Color c = Color.decode("#FF9900");
    GraphConstants.setBounds(vMap, new Rectangle2D.Double(50, 50, 90, 30));
    GraphConstants.setBorder(vMap, BorderFactory.createRaisedBevelBorder());
    GraphConstants.setBackground(vMap, c);
    GraphConstants.setForeground(vMap, Color.white);
    GraphConstants.setFont(vMap,
        GraphConstants.DEFAULTFONT.deriveFont(Font.BOLD, 12));
    GraphConstants.setOpaque(vMap, true);

    AttributeMap map = new AttributeMap();
    map.put(cell, vMap);
    return map;
  }

  private class WorkflowChangeListener implements
      GraphEventListener<ModelNode, IdentifiableEdge> {

    private JungJGraphModelAdapter adapter;

    public WorkflowChangeListener(JungJGraphModelAdapter adapter) {
      this.adapter = adapter;

    }

    /*
     * (non-Javadoc)
     * 
     * @see
     * edu.uci.ics.jung.graph.event.GraphEventListener#handleGraphEvent(edu.
     * uci.ics.jung.graph.event.GraphEvent)
     */
    @Override
    public void handleGraphEvent(GraphEvent<ModelNode, IdentifiableEdge> e) {
      if (e.getType().equals(GraphEvent.Type.EDGE_ADDED)) {
        LOG.log(Level.FINE, "EDGE ADDED!");
        GraphEvent.Edge<ModelNode, IdentifiableEdge> event = (GraphEvent.Edge<ModelNode, IdentifiableEdge>) e;
        addJGraphEdge(event.getEdge());
      } else if (e.getType().equals(GraphEvent.Type.EDGE_REMOVED)) {
        LOG.log(Level.FINE, "EDGE REMOVED!");
      } else if (e.getType().equals(GraphEvent.Type.VERTEX_ADDED)) {
        LOG.log(Level.FINE, "VERTEX ADDED!");
        GraphEvent.Vertex<ModelNode, IdentifiableEdge> event = (GraphEvent.Vertex<ModelNode, IdentifiableEdge>) e;
        addJGraphVertex(event.getVertex());
      } else if (e.getType().equals(GraphEvent.Type.VERTEX_REMOVED)) {
        LOG.log(Level.FINE, "VERTEX REMOVED!");
      }

    }

  }

  private void addJGraphVertex(ModelNode node) {
    DefaultGraphCell cell = new DefaultGraphCell(node);
    cell.add(new DefaultPort());
    insert(new Object[] { cell }, getVertexAttributes(cell), null, null, null);
    cellMap.put(node.getId(), cell);
  }

  private void addJGraphEdge(IdentifiableEdge e) {
    ConnectionSet set = new ConnectionSet();
    DefaultEdge theEdge = new DefaultEdge(e);
    DefaultGraphCell from = null;
    DefaultGraphCell to = null;
    String fromVertexId = e.getFrom().getId();
    String toVertexId = e.getTo().getId();
    if (!cellMap.containsKey(fromVertexId)) {
      addJGraphVertex(e.getFrom());
    }
    from = cellMap.get(fromVertexId);

    if (!cellMap.containsKey(toVertexId)) {
      addJGraphVertex(e.getTo());
    }

    to = cellMap.get(toVertexId);

    set.connect(theEdge, (DefaultPort) from.getChildAt(0),
        (DefaultPort) to.getChildAt(0));
    insert(new Object[] { theEdge }, getEdgeAttributes(theEdge), set, null,
        null);
  }

}