package org.simantics.plant3d.scl;

import java.util.HashSet;
import java.util.Set;

import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.Session;
import org.simantics.db.exception.DatabaseException;
import org.simantics.g3d.ontology.G3D;
import org.simantics.g3d.scenegraph.base.INode;
import org.simantics.g3d.scenegraph.base.ParentNode;
import org.simantics.g3d.scl.ScriptNodeMap;
import org.simantics.objmap.graph.IMapping;
import org.simantics.plant3d.ontology.Plant3D;
import org.simantics.plant3d.scenegraph.IP3DNode;
import org.simantics.plant3d.scenegraph.IP3DVisualNode;
import org.simantics.plant3d.scenegraph.P3DParentNode;
import org.simantics.plant3d.scenegraph.P3DRootNode;
import org.simantics.plant3d.scenegraph.ParameterizedNode;
import org.simantics.plant3d.scenegraph.PipeRun;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;

public class P3DScriptNodeMap extends ScriptNodeMap<Resource,INode> {
	
	private static final boolean DEBUG = false;
	
	public P3DScriptNodeMap(Session session, IMapping mapping, P3DRootNode rootNode) {
		super(session,mapping,rootNode);
		rootNode.setMapping(mapping);
	}
	
	@Override
	protected void updateActor(INode n, Set<String> ids) {
		if (DEBUG) System.out.println("P3DNodeMap update " + n);
		if (!(n instanceof IP3DVisualNode)) {
			if (n instanceof PipeControlPoint) {
				n = ((PipeControlPoint)n).getPipelineComponent();
				if (n == null)
					return;
			} else {
				return;
			}
		}
		
		IP3DVisualNode node = (IP3DVisualNode)n;
		
		if (DEBUG) {
			System.out.print("P3DNodeMap update " + node);
			for (String s : ids)
				System.out.print(" " + s);
			System.out.println();
		}
		
		if (ids.contains(Plant3D.URIs.hasGeometry)) {
			//node.visualize(view);
			//updateRenderObjectsFor(node);
			updateTransform(node);
		} 
		if (n instanceof ParameterizedNode) {
			ParameterizedNode geom = (ParameterizedNode)n;
			for (String id : geom.getParameterMap().keySet()) {
				if (ids.contains(id)) {
//                    node.visualize(view);
//                    updateRenderObjectsFor(node);
					updateTransform(node);
					break;
				}
			}
		} else if (n instanceof PipeRun) {
			// FIXME: may require rule based update!
			PipeRun run = (PipeRun)n;
			Set<String> ids2 = new HashSet<String>();
			ids2.add(Plant3D.URIs.hasGeometry);
			for (PipeControlPoint pcp : run.getControlPoints()) {
				updateActor(pcp, ids2);
			}
		}
		
		if (ids.contains(G3D.URIs.hasPosition) || 
			ids.contains(G3D.URIs.hasOrientation) ||
			ids.contains(G3D.URIs.hasWorldPosition) ||
			ids.contains(G3D.URIs.hasWorldOrientation)) {
			updateTransform(node);
		}
	}
	
	private void updateTransform(IP3DNode node) {
		if (DEBUG) System.out.println("P3DNodeMap update Transform " + node);

		
		if (node instanceof ParentNode<?>) {
			@SuppressWarnings("unchecked")
			ParentNode<IP3DNode> p = (ParentNode<IP3DNode>)node;
			for (IP3DNode n : p.getNodes())
				updateTransform(n);
		}
	}
	
	@Override
	protected void removeActor(INode n) {
		if (DEBUG) System.out.println("P3DNodeMap.removeActor " + n);
		if (!(n instanceof IP3DVisualNode))
			return;
		IP3DVisualNode node = (IP3DVisualNode)n;
//        remActor(node);
		
		if (node instanceof P3DParentNode<?>) {
			for (IP3DNode n2 : ((P3DParentNode<?>)node).getNodes())
				if (n2 instanceof IP3DVisualNode)
					removeActor((IP3DVisualNode)n2);
		}
	}
	
	@Override
	protected void addActor(INode n) {
		if (DEBUG) System.out.println("P3DNodeMap.addActor " + n);
		if (!(n instanceof IP3DVisualNode))
			return;
		IP3DVisualNode node = (IP3DVisualNode)n;
		
//        if (hasActor(node))
//            return;
		
		if (node instanceof P3DParentNode<?>) {
			for (IP3DNode n2 : ((P3DParentNode<?>)node).getNodes())
				if (n2 instanceof IP3DVisualNode)
					addActor((IP3DVisualNode)n2);
		}
		
		updateTransform(node);
	}
	
	@Override
	protected void update(ReadGraph graph) throws DatabaseException {
		validate();
//      System.out.println("Graph updates");
		super.update(graph);
		validate();
	}
	
	@Override
	public void commit(String commitMessage) {
		validate();
//      System.out.println("Graph commit");
		super.commit(commitMessage);
		
	}
	@Override
	protected void doCommit() throws DatabaseException{
//      System.out.println("Do commit");
		validate();
		super.doCommit();
	}
	
	private void validate() {
		for (INode node : rootNode.getNodes()) {
			if (node instanceof PipeRun)
				PipingRules.validate((PipeRun)node);
		}
	}
	
	@Override
	public void update() throws DatabaseException {
		try {
			boolean b = true;
			while (b) {
				updateCycle();
				b = PipingRules.update();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		super.update();
	}

}