/*
 * Moonlight|3D Copyright (C) 2005 The Moonlight|3D team
 * 
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 * 
 * This library 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 Lesser General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 * 
 * Created on Apr 24, 2005
 */
package ml.backend.selection;

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

import ml.core.exceptions.Exception;
import ml.core.helper.StringTools;

/**
 *
 * This class manages a selection on top of the operator graph and
 * its contents. Selections are named subsets of the operator graph
 * and its children of a certain type.
 * 
 * The objects in a selection are refered to by path names. For 
 * example, a path to a scene graph element has the following format:<br>
 * 
 * [operator graph node]/[slot name]/[scene graph node](/[scene graph node]...)<br>
 * 
 * Theses paths may also refer to elements inside scene graph nodes.
 * Mesh elements are referred to by paths ending in:<br>
 * 
 * [scene graph node]:faces[face id]<br>
 * 
 * [scene graph node]:edges[edge id]<br>
 * 
 * [scene graph node]:vertices[vertex id]<br>
 *
 * @author gregor
 */
public class Selection  {
    /**
     * The name of this selection
     */
    protected String name;
    
    /**
     * The current type of the objects within this collection
     */
    protected SelectionType currentType;
    /**
     * The list of names of currently selected objects in this selection set
     */
    protected ArrayList<String> selectedObjects;
    /**
     * The name of the active object
     */
    protected String activeObject;
    /**
     * The list of registered listeners
     */
    protected ArrayList<SelectionListener> listeners;
    protected Manager selectionManager;
    
    /**
     * Creates a new selection with the provided name. The name cannot
     * be altered after creation.
     * 
     * @param name Name of the selection
     */
    public Selection(Manager manager, String name)
    {
        this.selectionManager=manager;
        this.name=name;
        selectedObjects=new ArrayList<String>();
        listeners=new ArrayList<SelectionListener>();
    }
    
    /**
     * Register a listener for this selection. The listener will get
     * notified of any changes from that point onward.
     * 
     * @param listener the listener to register
     */
    public void registerListener(SelectionListener listener) {
    	listeners.add(listener);
    }
    
    /**
     * Unregister a listener for this selection. The listener will no
     * longer be notified about changes to this selection.
     * 
     * @param listener the listener to unregister
     */
    public void unregisterListener(SelectionListener listener) {
    	listeners.remove(listener);
    }
    
    /**
     * Clears the selection and resets the type of objects in this selection.
     * Every selection can only hold items of the same type.
     * 
     * @param newType The new type for the objects in the selection
     */
    public void clearSelection(SelectionType newType)
    {
        this.currentType=newType;
        selectedObjects.clear();
        activeObject=null;
       
        for(SelectionListener listener : listeners) {
        	listener.selectionCleared();
        }
    }
    
    /**
     * This helper function returns a reference to the object that
     * a given path string points to. If the given string is invalid,
     * an exception is thrown.
     * 
     * @param object name of object
     * @return reference of object with given name
     * @throws ml.core.exceptions.Exception
     */
    public Object getObjectFromSelectionString(String object) throws ml.core.exceptions.Exception
    {
        // general plan: walk through path while trying to deduce where it points to
    	String[] splitted=StringTools.split(object,':');
    	String[] path=StringTools.split(splitted[0],'/');
//        String[] splitted=object.split(":");
//        String[] path=splitted[0].split("/");
        
        if(path.length==0) {
            throw new Exception("invalid object name: given string is empty");
        }
        
        PathElement pathElement=selectionManager.getRootPathElement(path[0]);
        
        for(int i=1;i<path.length;i++) {
            pathElement=pathElement.findChildElement(path[i]);
            if(pathElement==null) {
                throw new Exception("invalid object name: element at position " + i + " in path doesn't exist");
            }
        }
        
        if(splitted.length==1) {
            return pathElement;
        }
        
        String appendix=splitted[1];

        if(pathElement.isValidAppendixName(appendix)) {
            return pathElement.getFromAppendix(appendix);
        } else {
            throw new Exception("invalid object name: invalid appendix to path");            
        }
    }
    
    /**
     * Returns type of object with given name. This function is used to check
     * the type of objects which were asked to be added to the selection.
     * 
     * @param ref The name of the object
     * @return Type of object with given name
     * @throws Exception
     */
    private SelectionType getObjectType(String ref) throws Exception
    {
        Object object=getObjectFromSelectionString(ref);
        List<SelectionType> selectionTypes=selectionManager.getSelectionTypes();
        
        for(SelectionType type : selectionTypes) {
        		if(type.isThisType(object)) {
        			return type;
        		}
        }
        
        throw new Exception("Object type is unknown");        
    }
    
    /**
     * Adds a object with the given name to the Selection. This operation fails
     * if the given object has an incorrect type or the referencing string is 
     * invalid for some reasons.
     * 
     * @param object name of the object
     * @throws Exception
     */
    public void add(String object) throws Exception
    {
        // check if named object has correct type
        if(getObjectType(object)!=currentType) {
            throw new Exception("unable to add object to selection because of type mismatch");
        }
        
        boolean alreadySelected=false;
        for(int i=0;i<selectedObjects.size();i++) {
            if(selectedObjects.get(i).equals(object)) {
                alreadySelected=true;
                break;
            }
        }
        if(!alreadySelected) {
            selectedObjects.add(object);
        }
        activeObject=object;
        
        for(SelectionListener listener : listeners) {
        	listener.elementAdded(object);
        }
    }
    
    /**
     * Adds a list of objecst with the given names to the Selection. This operation 
     * fails if one the given objects has an incorrect type or the referencing string 
     * is invalid for some reasons.
     * 
     * @param objects list of name of the objects
     * @throws Exception
     */
    public void add(List<String> objects) throws Exception
    {
        // check if named object has correct type
    	for(String object : objects) {
    		if(getObjectType(object)!=currentType) {
    			throw new Exception("unable to add object to selection because of type mismatch");
    		}
        
    		boolean alreadySelected=false;
    		for(int i=0;i<selectedObjects.size();i++) {
    			if(selectedObjects.get(i).equals(object)) {
    				alreadySelected=true;
    				break;
    			}
    		}
    		if(!alreadySelected) {
    			selectedObjects.add(object);
    		}
    		activeObject=object;
    	}
        
        for(SelectionListener listener : listeners) {
        	listener.elementsAdded(objects);
        }
    }
    
    /**
     * Remove object from selection. May be used to "unselect" objects during 
     * multiple selection. If the object to remove is the active object, the
     * last object in the selection will arbitrarily be made active.
     * 
     * @param object name of object to remove
     */
    public void remove(String object)
    {
        selectedObjects.remove(object);
        
        if(activeObject.equals(object)) {
            activeObject=selectedObjects.get(selectedObjects.size()-1);
        }
        
        for(SelectionListener listener : listeners) {
        	listener.elementRemoved(object);
        }
    }
    
    public void replace(String oldObject, String newObject) throws Exception {
        // check if named object has correct type
        if(getObjectType(newObject)!=currentType) {
            throw new Exception("unable to replace object in selection because of type mismatch of new object");
        }
        
        boolean alreadySelected=false;
        for(int i=0;i<selectedObjects.size();i++) {
            if(selectedObjects.get(i).equals(newObject)) {
                alreadySelected=true;
                break;
            }
        }
        
        if(alreadySelected) {
        	return;
        }
        
		for (int i = 0; i < selectedObjects.size(); i++) {
			if (selectedObjects.get(i).equals(oldObject)) {
				for(SelectionListener listener : listeners) {
					listener.elementUpdated(oldObject,newObject);
				}
				selectedObjects.set(i, newObject);
			}
		}
		/*
		 * note that we do not notify listeners here because the active object is also
		 * in the list of selected objects and has already been processed as such.
		 */
		if(activeObject.equals(oldObject)) {
			activeObject=newObject;
		}    	
    }
    
    /**
     * Convenience function to replace base paths of selected objects with updated
     * ones. For example, the current selection is updated that way after inserting
     * a new operator graph node.
     * 
     * @param oldBase
     * @param newBase
     */
    public void updateBase(String oldBase, String newBase) {
		/*
		 * note that we do not notify listeners here because the active object is also
		 * in the list of selected objects and will be processed as such further down.
		 */
		if(activeObject.substring(0,oldBase.length()).equals(oldBase)) {
			String newPath=activeObject.replaceFirst(oldBase,newBase);
			activeObject=newPath;
		}
		for (int i = 0; i < selectedObjects.size(); i++) {
			if (selectedObjects.get(i).substring(0, oldBase.length()).equals(oldBase)) {
				String newPath = selectedObjects.get(i).replaceFirst(oldBase, newBase);
				String oldPath = selectedObjects.get(i);
				selectedObjects.set(i, newPath);
				for(SelectionListener listener : listeners) {
					listener.elementUpdated(oldPath,newPath);
				}
			}
		}
    }
    
    /**
     * Returns a list of names of the objects in this selection.
     * 
     * @return list of object names in the selection
     */
    public ArrayList<String> getSelection()
    {
        return (ArrayList<String>) selectedObjects.clone();
    }
    
    /**
     * Returns a list of object references for the objects in this selection.
     * 
     * @return list of object references in this selection
     * @throws ml.core.exceptions.Exception
     */
    public ArrayList<Object> getSelectionObjects() throws ml.core.exceptions.Exception
    {
        ArrayList<Object> objects=new ArrayList<Object>();
        
        for(int i=0;i<selectedObjects.size();i++) {
            objects.add(getObjectFromSelectionString(selectedObjects.get(i)));
        }
        
        return objects;
    }
    
    /**
     * Returns the name of the currently active object. By convention, every
     * selection has a single active object, which usually is the last one
     * added to the selection. It is the object single-object operations work on.
     * 
     * @return name of active object
     */
    public String getActiveObject()
    {
        return activeObject;
    }
    
    /**
     * Returns the name of this selection
     * 
     * @return name of selection
     */
    
    public String getName()
    {
        return name;
    }
    
    /**
     * Returns the current type of the contents of this selection.
     * 
     * @return type of selection contents
     */
    public SelectionType getType()
    {
        return currentType;
    }
}