package org.simantics.plant3d.utils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.simantics.Simantics;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.WriteGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.request.Read;
import org.simantics.g3d.scenegraph.base.INode;
import org.simantics.layer0.Layer0;
import org.simantics.plant3d.ontology.Plant3D;
import org.simantics.plant3d.scenegraph.Equipment;
import org.simantics.plant3d.scenegraph.P3DRootNode;
import org.simantics.plant3d.scenegraph.PipeRun;
import org.simantics.plant3d.scenegraph.PipelineComponent;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
import org.simantics.plant3d.utils.Item.Type;

public class P3DUtil {
    
    public static List<Item> getEquipments() throws DatabaseException {
        return getEquipments(Plant3D.URIs.Builtin);
    }
	
	public static List<Item> getEquipments(final String libUri) throws DatabaseException {
		return Simantics.getSession().syncRequest(new Read<List<Item>>() {
			@Override
			public List<Item> perform(ReadGraph graph) throws DatabaseException {
				Plant3D p3d = Plant3D.getInstance(graph);
				Resource project = Simantics.getProject().get();
				Resource builtins = graph.getResource(libUri);
				List<Item> actions = getItems(graph, project,p3d.Equipment);
				actions.addAll(getItems(graph, builtins,p3d.Equipment));
				return actions;
			}
			
			
		});
	}
	
	public static List<Item> getNozzles() throws DatabaseException {
		return Simantics.getSession().syncRequest(new Read<List<Item>>() {
			@Override
			public List<Item> perform(ReadGraph graph) throws DatabaseException {
				Plant3D p3d = Plant3D.getInstance(graph);
				ItemQuery query = new ItemQuery(p3d.Nozzle, Plant3D.URIs.Builtin);
				return graph.syncRequest(query);
			}
		});
	}
	
	public static class ItemQuery implements Read<List<Item>> {
		private Resource type;
		private String libUri;
		public ItemQuery(Resource type, String libUri) {
			this.type = type;
			this.libUri = libUri;
		}
		
		@Override
		public List<Item> perform(ReadGraph graph) throws DatabaseException {
			Resource project = Simantics.getProject().get();
			Resource builtins = graph.getResource(libUri);
			List<Item> actions = getItems(graph, project,type);
			actions.addAll(getItems(graph, builtins,type));
			return actions;
		}
		
		@Override
		public boolean equals(Object obj) {
		    if (obj.getClass() != this.getClass())
		        return false;
		    ItemQuery other = (ItemQuery)obj;
		    if (!type.equals(other.type))
		        return false;
		    return libUri.equals(other.libUri);
		}
		
		@Override
		public int hashCode() {
		    return type.hashCode() + libUri.hashCode();
		}
	}
	
	public static List<Item> getEnds() throws DatabaseException {
		return Simantics.getSession().syncRequest(new Read<List<Item>>() {
			@Override
			public List<Item> perform(ReadGraph graph) throws DatabaseException {
				Plant3D p3d = Plant3D.getInstance(graph);
				ItemQuery query = new ItemQuery(p3d.EndComponent, Plant3D.URIs.Builtin);
				return graph.syncRequest(query);
			}
		});
	}
	
	public static List<Item> getTurns() throws DatabaseException {
		return Simantics.getSession().syncRequest(new Read<List<Item>>() {
			@Override
			public List<Item> perform(ReadGraph graph) throws DatabaseException {
				Plant3D p3d = Plant3D.getInstance(graph);
				ItemQuery query = new ItemQuery(p3d.TurnComponent, Plant3D.URIs.Builtin);
				return graph.syncRequest(query);
			}
		});
	}
	
	public static List<Item> getInlines() throws DatabaseException {
		return Simantics.getSession().syncRequest(new Read<List<Item>>() {
			@Override
			public List<Item> perform(ReadGraph graph) throws DatabaseException {
				Plant3D p3d = Plant3D.getInstance(graph);
				ItemQuery query = new ItemQuery(p3d.InlineComponent, Plant3D.URIs.Builtin);
				return graph.syncRequest(query);
			}
		});
	}
	
	public static List<Item> filterUserComponents(List<Item> items) {
	    List<Item> result = new ArrayList<Item>(items.size());
	    for (Item i : items) {
	        if (!i.isCode())
	            result.add(i);
	    }
	    return result;
	}
	
	private static List<Item> getItems(ReadGraph graph, Resource lib, Resource type) throws DatabaseException{
		Plant3D p3d = Plant3D.getInstance(graph);
		Layer0 l0 = Layer0.getInstance(graph);
		List<Item> result = new ArrayList<Item>();
		for (Resource r : graph.getObjects(lib, l0.ConsistsOf)) {
			if (graph.isInstanceOf(r, type) ) {
				Resource geom = graph.getPossibleObject(r,p3d.hasGeometry);
				if (geom != null || graph.hasStatement(r,p3d.NonVisibleComponent)) {
					
					result.add(createItem(graph, r));
				}
			} 
			if (graph.isInheritedFrom(r, type)) {
				boolean asserts = false;
				for (Resource a : graph.getObjects(r, l0.Asserts)) {
					if (p3d.hasGeometry.equals(graph.getPossibleObject(a, l0.HasPredicate))) {
						asserts = true;
						break;
					}
				}
				if (asserts) {		
					result.add(createItem(graph, r));
				}
			}
		}
		Collections.sort(result, new Comparator<Item>() {
		    @Override
		    public int compare(Item o1, Item o2) {
		        return o1.getName().compareTo(o2.getName());
		    }
        });
		return result;
	}
	
	public static Item createItem(ReadGraph graph, Resource r) throws DatabaseException {
		Layer0 l0 = Layer0.getInstance(graph);
		Plant3D p3d = Plant3D.getInstance(graph);
		String name = graph.getRelatedValue(r, l0.HasName);
		String uri = graph.getURI(r);
		Item item = new Item(uri, name);
		if (graph.isInstanceOf(r, p3d.Equipment))
			item.setType(Type.EQUIPMENT);
		else if (graph.isInstanceOf(r, p3d.InlineComponent))
			item.setType(Type.INLINE);
		else if (graph.isInstanceOf(r, p3d.EndComponent))
			item.setType(Type.END);
		else if (graph.isInstanceOf(r, p3d.TurnComponent))
			item.setType(Type.TURN);
		else if (graph.isInstanceOf(r, p3d.Nozzle))
			item.setType(Type.NOZZLE);
		else 
			throw new RuntimeException("Cannot detect type for " + r);
		
		if (graph.hasStatement(r, p3d.CodeComponent))
			item.setCode(true);
		if (graph.hasStatement(r, p3d.VariableAngleTurnComponent) ||
		    graph.hasStatement(r, p3d.VariableLengthInlineComponent))
			item.setVariable(true);
		if (graph.hasStatement(r, p3d.SizeChangeComponent))
			item.setSizeChange(true);
		return item;
	}
	
	public static Resource createModel(WriteGraph graph, String name) throws DatabaseException{
		Layer0 l0 = Layer0.getInstance(graph);
		Plant3D p3d = Plant3D.getInstance(graph);
		Resource model = graph.newResource();
		graph.claim(model, l0.InstanceOf, p3d.Plant);
		graph.claimLiteral(model, l0.HasName, name);
		
		return model;
	}
	
	public static void finalizeDBLoad(P3DRootNode rootNode) throws Exception{
	    for (INode node : rootNode.getChild()) {
            if (node instanceof PipeRun) {
                for (PipelineComponent pc : ((PipeRun) node).getChild())
                    pc.sync();
            } else if (node instanceof Equipment) {
                for (PipelineComponent pc : ((Equipment) node).getChild())
                    pc.sync();
            }
        }
        
        for (INode node : rootNode.getChild()) {
            if (node instanceof PipeRun) {
                for (PipelineComponent pc : ((PipeRun) node).getChild())
                    pc.sync2();
            } else if (node instanceof Equipment) {
                for (PipelineComponent pc : ((Equipment) node).getChild())
                    pc.sync2();
            }
        }
        for (INode node : rootNode.getChild()) {
            if (node instanceof PipeRun) {
                PipingRules.validate((PipeRun)node);
            }
        }
        PipingRules.setEnabled(true);
        for (INode node : rootNode.getChild()) {
            if (node instanceof PipeRun) {
                PipeRun run = (PipeRun)node;
                for (PipeControlPoint pcp : run.getControlPoints())
                    PipingRules.positionUpdate(pcp);        
            }
        }
	}

}