package org.molwind.chemical.view;
   
   /*
    * This file is part of Molwind.
    *
    * Molwind is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * Molwind 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 General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with Molwind. If not, see <http://www.gnu.org/licenses/>.
   */
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Iterator;
  import java.util.TreeMap;
  
  import java.util.Collection;
  import java.awt.Dimension;
  import java.awt.geom.Point2D;
  
  import org.molwind.graph.DefaultEntityEdge;
  import org.molwind.graph.EntityGraph;
  import org.molwind.graph.EntityEdge;
  import org.molwind.graph.DefaultEntityGraph;
  import org.molwind.model.LayeredPosition;
  import org.molwind.model.RelationshipResolver;
  import org.molwind.graph.EntityVertex;
  import org.molwind.util.MolwindLogger;
  import org.molwind.view.TopologyManager;
  import org.molwind.view.AbstractTopologyManager;
  import org.molwind.model.PlacedWorldEntity;
  
  import org.apache.commons.collections15.Transformer;
  
  import org.openscience.cdk.tools.MFAnalyser;
  import org.openscience.cdk.interfaces.IMolecule;
  
  import edu.uci.ics.jung.graph.SparseGraph;
  import edu.uci.ics.jung.algorithms.layout.SpringLayout2;
  import edu.uci.ics.jung.algorithms.layout.ISOMLayout;
  import edu.uci.ics.jung.algorithms.layout.AbstractLayout;
  import edu.uci.ics.jung.algorithms.layout.AggregateLayout;
  import edu.uci.ics.jung.graph.util.EdgeType;
  import edu.uci.ics.jung.graph.Graph; 
  import edu.uci.ics.jung.graph.util.Pair;
  import edu.uci.ics.jung.visualization.BasicVisualizationServer;
  
  
  
  
  /**
   * ChemicalTopologyManager determines and places visible chemical structures.
   *
   * @author <a href="mailto:oliver.karch@molwind.org">Oliver Karch</a>
   * @version 1.0
   */
  public class ChemicalTopologyManager extends AbstractTopologyManager {
  
      private Iterator entityIterator;
      private RelationshipResolver relationshipResolver;
      private TreeMap entities;
  
      /**
       * Creates a new topology manager to place chemical entities.
       */
      public ChemicalTopologyManager() {
  	super();
          entities = null;
      }
      
      
      private SparseGraph<EntityVertex,EntityEdge> linkToGraph(EntityVertex[] entityArray){
  	SparseGraph<EntityVertex,EntityEdge> resultGraph = new SparseGraph<EntityVertex,EntityEdge>();
  	
  	for(int i = 0;i<entityArray.length;i++){
  	    resultGraph.addVertex(entityArray[i]);
  	    for(int j = i+1;j<entityArray.length;j++){
  		Pair<EntityVertex> endpoints = new Pair<EntityVertex>(entityArray[i],entityArray[j]);
  		int edgeWeight = entityArray[i].getEntity().getDimension()+ entityArray[j].getEntity().getDimension();
  		DefaultEntityEdge edge = new DefaultEntityEdge(entityArray[i],entityArray[j],edgeWeight);
  		resultGraph.addEdge(edge,endpoints,EdgeType.DIRECTED);
  		
  		//parentGraph.addEdge(endpoints,EdgeType.DIRECTED);
  	    }
  	    
  	}
  	
  	return resultGraph;
  	
      }
      
     private EntityVertex[] getChildren(SparseGraph<EntityVertex,EntityEdge> graph,EntityVertex vertex){
 	EntityVertex[] result = new EntityVertex[graph.getIncidentEdges(vertex).size()];
 	int i = 0;
 	for(Object edgeObject:graph.getIncidentEdges(vertex)){
 	    EntityEdge edge =(EntityEdge)edgeObject;
 	    result[i]=edge.getV1();
 	    i++;
 	}
 	
 	
 	return result;
     }
     
     //TODO Method is not well implemented yet
     public void calculatePositions() {
         RelationshipResolver resolver = getRelationshipResolver();
         if (resolver == null) {
             MolwindLogger.warn("Cannot place entities: "
                     + "missing relationship resolver", null);
             return;
         }
         DefaultEntityGraph defaultGraph =(DefaultEntityGraph) resolver.resolve();
 	
 	SparseGraph graph = defaultGraph.getGraph();
 	
 	
 	MolwindLogger.debug( "Entity graph:\n"+graph );
 
 	Transformer<EntityEdge,Integer> transformer = new Transformer<EntityEdge,Integer>(){
 	    public Integer transform(EntityEdge edge){
 		return edge.getEdgeWeight();
 	    }
 	};
 	int size = 1000;
 
 	for(int i = defaultGraph.getLayerCount()-1;i>0;i--){
 	    EntityVertex[] parentLayer = defaultGraph.getLayer(i-1);
 	    EntityVertex[] childrenLayer = defaultGraph.getLayer(i);
 	    
 	    SparseGraph<EntityVertex,EntityEdge> parentGraph,childGraph,wholeGraph;
 	    wholeGraph = new SparseGraph<EntityVertex,EntityEdge>();
 	    parentGraph = linkToGraph(parentLayer);
 	    childGraph =  new SparseGraph<EntityVertex,EntityEdge>();
 	    
 	    
 	    for(EntityVertex vertex:parentLayer)
 		wholeGraph.addVertex(vertex);
 	    
 	    for(EntityVertex vertex:childrenLayer)
 		wholeGraph.addVertex(vertex);
 	    
 	    SpringLayout2<EntityVertex,EntityEdge> springLayout = new SpringLayout2<EntityVertex,EntityEdge>(parentGraph,transformer);
 	    //Maybe a factor for RepulsionRange needed
 	    springLayout.setRepulsionRange(300);
 	    springLayout.setSize(new Dimension(size,size));
 	    springLayout.initialize();
 	    for(int j = 0;j<100;j++)
 		springLayout.step();
 	    //  BasicVisualizationServer basicVisualizationServer = new BasicVisualizationServer(springLayout);
 	    for(EntityVertex vertex:parentLayer){
 		vertex.setPosition((Point2D.Double)springLayout.transform(vertex));
 	    }
 	    
 	    
 	    AggregateLayout aLayout = new AggregateLayout(new SpringLayout2(wholeGraph));
 	    try{
 		for(EntityVertex vertex : parentLayer){
 		    childGraph = linkToGraph(getChildren(graph,vertex));
 		    
 		    int circleSize = 0;
 		    for(EntityVertex childVertex:childGraph.getVertices()){
 			
 			circleSize +=childVertex.getEntity().getDimension();
 			//	childGraph.addVertex(children[i]);
 		    }
 		    
 		    if(circleSize < 40)
 			circleSize = 40;
 		    circleSize *=2;
 		    
 		    ISOMLayout<EntityVertex,EntityEdge> isomLayout = new ISOMLayout<EntityVertex,EntityEdge>(childGraph);
 		    
 		    // BasicVisualizationServer vv2 = new BasicVisualizationServer(aLayout);
 		    
 		    isomLayout.setInitializer(aLayout);
 		    isomLayout.setSize(new Dimension(circleSize,circleSize));
 		    
 		    aLayout.put(isomLayout,vertex.getPosition());
 		    // vv2.repaint();
 		    for(EntityVertex childVertex:childGraph.getVertices()){
 			
 		
 			
 			childVertex.setPosition((Point2D.Double)aLayout.transform(childVertex));
 		    }
 		    
 		}
 	    }catch(java.util.ConcurrentModificationException e){
 		
 	    }
 	    size *=4;
 	}
 	
 	int o = 0;
 	
 	for(EntityVertex vertex:defaultGraph.getGraph().getVertices()){
 	    o++;
 	    System.out.println(vertex.getPosition());
 	}
 	System.out.println("OOO: " + o);
 	
 	//defaultGraph.viewGraph(2000);
 	
         // TODO Complete method, seems unfinished
     }
 
 
     /**
      * Determines the visible entities for the given position.
      *
      * @param position
      *      the position (longitude/latitude/level)
      * @return
      *      an (possibly empty) iterator of entities
      */
     public Iterator getVisibleEntities(final LayeredPosition position) {
         if (entities == null) {
             calculatePositions();
         }
         return visibleIterator(position);
     }
 
     private Iterator visibleIterator(final LayeredPosition position) {
         // TODO Needs implemention
         return (new ArrayList()).iterator();
     }
 
 }