/*
* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/


package com.nokia.sdt.emf.dm.impl;

import com.nokia.sdt.component.IComponent;
import com.nokia.sdt.datamodel.IDesignerDataModel;
import com.nokia.sdt.datamodel.util.ModelUtils;
import com.nokia.sdt.datamodel.util.NamePropertySupport;
import com.nokia.sdt.datamodel.util.NamePropertySupport.INameFilter;
import com.nokia.sdt.editor.IComponentEditor;
import com.nokia.sdt.emf.dm.*;
import com.nokia.sdt.emf.dm.impl.NodeCopier.IFilter;
import com.nokia.cpp.internal.api.utils.core.Check;

import org.eclipse.emf.common.command.AbstractCommand;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.edit.EMFEditPlugin;
import org.eclipse.emf.edit.domain.EditingDomain;

import java.util.*;

/**
 * 
 *
 */
public class PasteInstancesFromClipboardCommand extends AbstractCommand implements Command {

	  protected static final String LABEL = 
		  EMFEditPlugin.INSTANCE.getString("_UI_PasteFromClipboardCommand_label");
	  protected static final String DESCRIPTION = 
		  EMFEditPlugin.INSTANCE.getString("_UI_PasteFromClipboardCommand_description");

	
	private String ownerName;
	private IDesignerDataModel ownerModel;
	private EditingDomain editingDomain;
	private Collection clipboard;
	private List<INode> affectedObjects;
	private List<String> pastedNames;
	private List<NodeCopier> copiedNodesForRedo;
	
	class NameReplaceVisitor implements INodeVisitor {
		private INode root;
		private IDesignerDataModel model;
		
		/**
		 * When visiting each node, check it for clashes with the new model
		 * If clashes, assign the node a new name that does not clash with the new model
		 * or any of the children of the current node (which themselves may already have a name)
		 * @param root the root INode of the new model
		 */
		public NameReplaceVisitor(INode root) {
			this.root = root;
			model = root.getDesignerData().getDesignerDataModel();
		}
		
		private IComponent getComponent(INode node) {
			String componentId = node.getComponentId();
			return model.getComponentSet().lookupComponent(componentId);
		}
		
		private void assignNewName(final INode node, IComponent component) {
			// This filter is passed to the name generator to allow it to check
			// not only the target model, but also the children of the root of the current node
			final INode root = node.getRootContainer();
			INameFilter filter = new INameFilter() {
				public boolean test(final String name) {
					INodeVisitor visitor = new INodeVisitor() {
						public Object visit(INode node) {
							if (name.equals(node.getName()))
								return node;
							return null;
						}
					};
					return root.visitPreorder(visitor) == null;
				}
			};
			String generatedName = 
				NamePropertySupport.generateNameForModel(model, component, null, true, filter);
			StringValue sv = new StringValue(StringValue.LITERAL, generatedName);
			node.getProperties().set(INode.NAME_PROPERTY, sv, true);
		}

		public Object visit(INode node) {
			if (hasClashingName(root, node)) {
				assignNewName(node, getComponent(node));
			}
			return null;
		}
		
	}
	
	class NameClashDetector implements INodeVisitor {
		private INode root;
		
		public NameClashDetector(INode root) {
			this.root = root;
		}

		public Object visit(INode node) {
			if (hasClashingName(root, node)) {
				return node;
			}
			return null;
		}
		
	}
	
	public PasteInstancesFromClipboardCommand(EditingDomain editingDomain, EObject owner) {
		super(LABEL, DESCRIPTION);
		Check.checkArg(owner instanceof INode);
		Check.checkArg(editingDomain);
		this.ownerName = ((INode) owner).getName();
		this.ownerModel = ((INode) owner).getDesignerData().getDesignerDataModel();
		this.editingDomain = editingDomain;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.emf.common.command.AbstractCommand#prepare()
	 */
	protected boolean prepare() {
		affectedObjects = new ArrayList<INode>();
		pastedNames = new ArrayList<String>();
		copiedNodesForRedo = new ArrayList<NodeCopier>();
		clipboard = editingDomain.getClipboard();
		return (clipboard != null) && !clipboard.isEmpty();
	}
	
	private boolean hasNameClashes(INode root, INode node) {
		return node.visitPreorder(new NameClashDetector(root)) != null;
	}
	
	private void replaceClashingNames(INode root, INode node) {
		node.visitPreorder(new NameReplaceVisitor(root));
	}
	
	/**
	 * @param root the INode whose tree we check for clashing names
	 * @param node the INode whose name is checked for clashes
	 * @return true if INode.getName() exists in root's tree
	 */
	protected boolean hasClashingName(INode root, INode node) {
		String name = node.getName();
		return (name != null) && (root.findByNameProperty(name) != null);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.emf.common.command.Command#execute()
	 */
	public void execute() {
		if (!canExecute())
			return;
		
		affectedObjects.clear();
		pastedNames.clear();
		copiedNodesForRedo.clear();
		INode owner = getOwner();
		INode root = owner.getRootContainer();
		// For each node on the clipboard, 
		// if it, or any of its children's names clashes with the owner's model, 
		// make a copy of the node and replace any clashing names
		// Copy the resulting node (or the original, if no clashes) to the owner
		for (Iterator iter = clipboard.iterator(); iter.hasNext();) {
			INode node = (INode) iter.next();
			NodeCopier localCopier = new NodeCopier(node, new IFilter() {
				public boolean test(INode node) {
					IComponentEditor componentEditor = ModelUtils.getComponentEditor(node);
					return (componentEditor == null) || !componentEditor.isTemporaryObject();
				}
			});
			if (hasNameClashes(root, node)) {
				node = localCopier.getCopy();
				replaceClashingNames(root, node);
			}
			INode copy = NodeCopier.copyNode(node, owner, IDesignerDataModel.AT_END, false);
			if (copy != null) {
				ModelUtils.getPropertyInformation(copy).refresh();
				affectedObjects.add(copy);
				pastedNames.add(copy.getName());
				copiedNodesForRedo.add(localCopier);
			}
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.emf.common.command.AbstractCommand#undo()
	 */
	public void undo() {
		INode owner = getOwner();
		// don't use removeAll, because notification is indices, instead of objects
		EList children = owner.getChildren();
		for (String name : pastedNames) {
			INode child = owner.findByNameProperty(name);
			if (child != null)
				children.remove(child);
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.emf.common.command.Command#redo()
	 */
	public void redo() {
		affectedObjects.clear();
		pastedNames.clear();
		INode owner = getOwner();
		for (NodeCopier copier : copiedNodesForRedo) {
			INode copy = NodeCopier.copyNode(copier.getCopy(), owner, IDesignerDataModel.AT_END, false);
			if (copy != null) {
				ModelUtils.getPropertyInformation(copy).refresh();
				affectedObjects.add(copy);
				pastedNames.add(copy.getName());
			}
		}
	}
	
	private INode getOwner() {
		return (INode) ownerModel.findByNameProperty(ownerName);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.emf.common.command.AbstractCommand#getAffectedObjects()
	 */
	public Collection getAffectedObjects() {
		return affectedObjects;
	}

}