/*******************************************************************************
 * Copyright (c) 2012, 2013 Association for Decentralized Information Management in
 * Industry THTH ry.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.g3d.vtk.common;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IWorkbenchPart;
import org.simantics.db.Resource;
import org.simantics.g3d.scenegraph.IG3DNode;
import org.simantics.g3d.scenegraph.base.INode;
import org.simantics.g3d.tools.AdaptationUtils;
import org.simantics.objmap.graph.IMapping;
import org.simantics.objmap.structural.StructuralResource;
import org.simantics.utils.ui.AdaptionUtils;

import vtk.vtkProp;

public class NodeSelectionProvider2<DBObject,JavaObject> implements ISelectionProvider, ISelectionChangedListener, ISelectionListener{
    protected ISelection selection = new StructuredSelection();
	protected List<ISelectionChangedListener> listeners = new ArrayList<ISelectionChangedListener>();
	
	protected List<INode> selectedNodes = new ArrayList<>(); // selection is ordered
	//List<Resource> selectedResources = new ArrayList<Resource>();
	protected List<VTKSelectionItem<DBObject>> selectedItems = new ArrayList<VTKSelectionItem<DBObject>>();
	
	protected IEditorPart part;
	protected IMapping<DBObject,JavaObject> mapping;
	protected VTKNodeMap<DBObject, ? extends INode> nodeMap;
	
	public NodeSelectionProvider2(IEditorPart part, IMapping<DBObject,JavaObject> mapping, VTKNodeMap<DBObject, ? extends INode> nodeMap) {
		this.part = part;
		this.mapping = mapping;
		this.nodeMap = nodeMap;
	}
	
	@Override
	public void addSelectionChangedListener(
			ISelectionChangedListener listener) {
		listeners.add(listener);
	}
	
	@Override
	public void removeSelectionChangedListener(
			ISelectionChangedListener listener) {
		listeners.remove(listener);
	}
	
	@Override
	public ISelection getSelection() {
		return selection;
	}
	
	@Override
	public void setSelection(ISelection selection) {
	    Collection<IG3DNode> nodes = AdaptionUtils.adaptToCollection(selection, IG3DNode.class);
	    Collection<Resource> resources= AdaptionUtils.adaptToCollection(selection, Resource.class);
	    if (nodes.size() > 0) {
	        processSelection(selection);
	        fireSelectionChanged(this);
	    } else if (resources.size() > 0) {
	        nodes = new ArrayList<IG3DNode>();
	        for (Resource r : resources) {
	            @SuppressWarnings("unchecked")
	            JavaObject n  = mapping.get((DBObject)r);
	            if (n instanceof IG3DNode) {
	                nodes.add((IG3DNode)n);
	            }
	        }
	        processSelection(new StructuredSelection(nodes.toArray()));
	        fireSelectionChanged(this);
	    } else {
	        processSelection(selection);
            fireSelectionChanged(this);
	    }
		
	}
	
	// events coming from vtk	
	@Override
	public void selectionChanged(SelectionChangedEvent event) {
		ISelection s = event.getSelection();
		
		processSelection(s);
		fireSelectionChanged(event.getSource());
	}
	
	protected void processSelection(ISelection s) {
		selectedNodes.clear();
		selectedItems.clear();
		_processSelection(s);
	}
	
	protected void _processSelection(ISelection s) {
	    Collection<vtkProp> selectedActors = AdaptationUtils.adaptToCollection(s, vtkProp.class);
        if (selectedActors.size() > 0) {
            for (vtkProp a : selectedActors) {
                INode node = nodeMap.getNode(a);
                if (node == null)
                    continue;
                if (!selectedNodes.contains(node))
                    selectedNodes.add(node);
                @SuppressWarnings("unchecked")
                DBObject r = mapping.inverseGet((JavaObject)node);
                selectedItems.add(new VTKSelectionItem<DBObject>(a, node,r));
            }
        } else {
            Collection<IG3DNode> selectedNds = AdaptationUtils.adaptToCollection(s, IG3DNode.class);
            for (INode node : selectedNds) {
                if (!selectedNodes.contains(node))
                    selectedNodes.add((IG3DNode)node);
                @SuppressWarnings("unchecked")
                DBObject r = mapping.inverseGet((JavaObject)node);
                selectedItems.add(new VTKSelectionItem<DBObject>(null, (IG3DNode)node,r));
            }
        }
        
        
        selection = new StructuredSelection(selectedItems);
	}
	
	protected void fireSelectionChanged(Object source) {
		SelectionChangedEvent evt = new SelectionChangedEvent((ISelectionProvider)source, selection);
		for (ISelectionChangedListener l : listeners) {
			l.selectionChanged(evt);
		}
	}
	
	
	
	// events coming from workbench
	@Override
	public void selectionChanged(IWorkbenchPart part, ISelection selection) {
		if (part == this.part)
			return;
		processSelection(selection);
		
	}
	
	public List<INode> getSelectedNodes() {
		return selectedNodes;
	}
	
	public List<VTKSelectionItem<DBObject>> getSelectedItems() {
        return selectedItems;
    }
	
	@SuppressWarnings("unchecked")
	public List<DBObject> getSelectedResources() {
		
		List<DBObject> list = new ArrayList<DBObject>();
		for (VTKSelectionItem<DBObject> i : selectedItems) {
			DBObject r = (DBObject)i.getAdapter(Resource.class);
			if (r == null)
				r = (DBObject)i.getAdapter(StructuralResource.class);
			if (r == null)
				continue;
			if (!list.contains(r))
				list.add(r);
		}
		return list;
	}
	
	protected INode getNode(DBObject r) {
		return (INode)mapping.get(r);
	}
}