/*
 *                 Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 *
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2004 Sun
 * Microsystems, Inc. All Rights Reserved.
 */
/*
 * OperationListener.java
 *
 * Created on 26. duben 2004, 19:39
 */

package org.netbeans.modules.refactoring.ui;

import java.awt.datatransfer.Clipboard;
import java.util.*;
import javax.swing.SwingUtilities;
import javax.jmi.reflect.RefObject;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.jmi.javamodel.JavaClass;
import org.netbeans.jmi.javamodel.JavaPackage;
import org.netbeans.jmi.javamodel.Resource;
import org.netbeans.modules.java.JavaDataObject;
import org.netbeans.modules.javacore.internalapi.JavaMetamodel;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.*;
import org.openide.loaders.OperationEvent.Move;
import org.openide.loaders.OperationEvent.Rename;
import org.openide.nodes.Node;
import org.openide.util.Lookup;
import org.openide.util.RequestProcessor;

/**
 * Operational listener listens on move operation and invokes move class refactoring
 * @author jb105785
 */
public class RefactoringOperationListener extends OperationAdapter {

    /**
     * Instance of system clipboard
     */    
    private Clipboard clip;
    /**
     * objects thet are being moved
     */    
    private Set movedObjects = null;
    /**
     * number of objects, that are scheduled for moving
     */    
    private int counter = 0;
    /**
     * instance of MoveClassAction
     */    
    private MoveClassAction moveAction;
    private RequestProcessor rp;
    /**
     * Activated nodes for DND
     */    
    private volatile Node[] activated = null;
    
    /**
     * instance of this class
     */    
    private static OperationListener operationalListener = new RefactoringOperationListener();
    private static DataLoaderPool dataLoaderPool = (DataLoaderPool) Lookup.getDefault().lookup(DataLoaderPool.class); 

    /**
     * Register this operation listener
     */    
    public static void addOperationalListener () {
        dataLoaderPool.addOperationListener(operationalListener);
    }
    /**
     * Unregister this operational listener
     */    
    public static void removeOperationalListener() {
        dataLoaderPool.removeOperationListener(operationalListener);
    }
    
    private RefactoringOperationListener() {
        clip = (Clipboard) Lookup.getDefault().lookup(Clipboard.class);
        moveAction = (MoveClassAction) MoveClassAction.findObject(MoveClassAction.class, true);
        rp = new RequestProcessor();
    }
    
    /**
     * invkoed whenever java file is moved
     */    
    public void operationMove(final Move ev) {
        final DataObject object = ev.getObject();
        
        FileObject newFo = object.getPrimaryFile();
        ClassPath newClassPath = ClassPath.getClassPath(newFo, ClassPath.SOURCE);
        if (newClassPath == null)
            return;
        
        FileObject oldFo = ev.getOriginalPrimaryFile();
        ClassPath oldClassPath = ClassPath.getClassPath(oldFo, ClassPath.SOURCE);
        if (oldClassPath == null)
            return;
        
        if (object instanceof JavaDataObject) {
            //only JavaDataObjects are interesting
            if (counter == 0) {
                //counter == 0 means, that this is first file
                //this branch collects all Objects, that will be moved
                activated = moveAction.getActivatedNodes();
                if (activated.length == 1) {
                    DataFolder folder = (DataFolder) activated[0].getCookie(DataFolder.class);
                    if (folder!=null && FileUtil.isParentOf(folder.getPrimaryFile(), object.getPrimaryFile())) {
                        //it is cut/paste action
                        movedObjects = getJavaChildren(Arrays.asList(LoaderTransfer.getDataObjects(clip.getContents(null), LoaderTransfer.MOVE)));
                    } else {
                        //it is DND action
                        movedObjects = getJDOs(activated);
                    }
                } else {
                    movedObjects=getJDOs(activated);
                }
                //add finaly add this object
                movedObjects.add(object);
                counter = movedObjects.size();
            }
            
            if (newClassPath.getResourceName(newFo).equals(oldClassPath.getResourceName(oldFo))) {
                movedObjects.remove(object);
            }
            
            if (counter == 1) {
                //this is last object from this "transaction"
                if (!movedObjects.isEmpty()) {
                    rp.post(new Runnable() {
                        public void run() {
                            SwingUtilities.invokeLater(new Runnable() {
                                public void run() {
                                    moveAction.performAction(movedObjects);
                                }
                            });
                        }
                        
                    });
                }
            }
            
            if (counter > 0)
                counter --;
        }
    }

    public void operationRename (Rename ev) {
        DataObject o = ev.getObject();
        if (o instanceof JavaDataObject) {
            RenameAction a = (RenameAction) RenameAction.findObject(RenameAction.class, true);
            Resource cr = JavaMetamodel.getManager().getResource(o.getPrimaryFile());
            JavaClass representedObject = null;
            if (cr != null) {
                for (Iterator it = cr.getClassifiers().iterator(); it.hasNext();) {
                    Object obj = it.next();
                    if (!(obj instanceof JavaClass))
                        continue;
                    JavaClass cls = (JavaClass) obj;
                    if (ev.getOriginalName().equals(cls.getSimpleName()) || representedObject == null) {
                        representedObject = cls;
                        break;
                    }
                }
            }
            if (representedObject != null) {
                a.performAction(representedObject, o.getName(), ev.getOriginalName(), false, null);
            }
        } else if (o instanceof DataFolder) {
            /* do nothing for folders
            RenameAction a = (RenameAction) RenameAction.findObject(RenameAction.class, true);
            String origName = ev.getOriginalName();
            FileObject folder = ((DataFolder) o).getPrimaryFile();
            ClassPath cp = ClassPath.getClassPath(folder, ClassPath.SOURCE);
            JavaPackage representedObject = null;
            if (cp != null) {
                String packageName = cp.getResourceName(folder, '.', false);
                int index = packageName.lastIndexOf('.');
                if (index == -1) {
                    packageName = origName;
                } else {
                    packageName = packageName.substring(0, index + 1) + origName;
                }
                FileObject root = cp.findOwnerRoot(folder);
                if (root != folder) {
                    representedObject = JavaMetamodel.getManager().resolveJavaExtent(root).getJavaPackage().resolvePackage(packageName);
                }
            }
            if (representedObject != null) {
                String folderName = representedObject.getName();
                int index = folderName.lastIndexOf('.');
                if (index > -1) {
                    folderName = folderName.substring(index + 1);
                }
                a.performAction(representedObject, ((DataFolder)o).getName(), folderName, false, folder);
            }
             */
        }
        
        /*
        FileObject fo = o.getPrimaryFile();
        String name = fo.getName();
        Resource res = JavaMetamodel.getManager().getResource(fo);
        boolean found = false;
        for (Iterator iter = res.getClassifiers().iterator(); iter.hasNext(); ) {
            Object obj = iter.next();
            if (obj instanceof JavaClass) {
                if (((JavaClass)obj).getSimpleName().equals(name)) {
                    found = true;
                    break;
                }
            }
        }
        if (!found) {
         */
    }
    
    /**
     * JavaDataObjects, that are children of this nodes
     * @param nodes Nodes
     * @return
     */    
    private Set getJDOs(Node[] nodes) {
        Set result = new HashSet(nodes.length);
        for (int i=0; i< nodes.length; i++) {
            JavaDataObject jdo = (JavaDataObject) nodes[i].getCookie (JavaDataObject.class);
            if (jdo != null) {
                result.add(jdo);
            }
            DataFolder folder = (DataFolder) nodes[i].getCookie (DataFolder.class);
            if (folder!=null) {
                result.addAll(getJavaChildren(folder));
            }
        }
        return result;
    }
    
    private Set getJavaChildren(DataFolder folder) {
        List a = new ArrayList();
        a.add(folder);
        return getJavaChildren(a);
    }
    
    private Set getJavaChildren(List folders) {
        LinkedList q = new LinkedList();
        Set result = new HashSet();
        q.addAll(folders);
        while (!q.isEmpty()) {
            DataObject o = (DataObject) q.removeFirst();
            if (o instanceof DataFolder) {
                q.addAll(Arrays.asList(((DataFolder) o).getChildren()));
            } else {
                if (o instanceof JavaDataObject) {
                    result.add(o);
                }
            }
        }
        return result;
    }
}