/*
 *                 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-2003 Sun
 * Microsystems, Inc. All Rights Reserved.
 */
package org.netbeans.modules.refactoring.ui;

import java.util.Iterator;
import javax.jmi.reflect.RefObject;
import org.netbeans.api.mdr.MDRepository;
import javax.swing.SwingUtilities;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.modules.refactoring.api.ui.AbstractRefactoringAction;
import org.netbeans.modules.refactoring.api.ui.RefactoringUI;
import org.netbeans.jmi.javamodel.ElementReference;
import org.netbeans.jmi.javamodel.JavaClass;
import org.netbeans.jmi.javamodel.JavaPackage;
import org.netbeans.jmi.javamodel.MultipartId;
import org.netbeans.jmi.javamodel.Resource;
import org.netbeans.modules.java.JavaDataObject;
import org.netbeans.modules.javacore.internalapi.JavaMetamodel;
import org.netbeans.modules.refactoring.classpath.RefactoringClassPathImplementation;
import org.netbeans.modules.javacore.internalapi.JMIElementCookie;
import org.netbeans.spi.java.classpath.ClassPathFactory;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileStateInvalidException;
import org.openide.filesystems.Repository;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.nodes.Node;
import org.openide.util.NbBundle;

/**
 *
 * @author Pavel Flaska, Martin Matula
 */
public class RenameAction extends AbstractRefactoringAction {
    /** Creates a new instance of RenameAction */
    public RenameAction() {
        super(NbBundle.getMessage(RenameAction.class, "LBL_RenameAction"), null);
    }
    
    protected RefactoringUI createRefactoringUI(Node[] nodes, org.netbeans.jmi.javamodel.Element selectedElement) {
        RefObject representedObject = selectedElement;
        if (representedObject!=null) {
            if (representedObject instanceof MultipartId) {
                RefObject temp = representedObject;
                RefObject last = temp;
                while (temp instanceof MultipartId && ((ElementReference)temp).getElement() instanceof JavaPackage) {
                    last = temp;
                    temp = (RefObject) temp.refImmediateComposite();
                }
                if (temp instanceof Resource) {
                    representedObject = last;
                } else {
                    representedObject = (((ElementReference)temp).getElement() instanceof JavaClass) ? temp : last;
                }
            }
            if (representedObject instanceof ElementReference) {
                representedObject = ((ElementReference)representedObject).getElement();
            }
        } else {
            Node selNode = nodes[0]; 
            JMIElementCookie cookie = (JMIElementCookie) selNode.getCookie(JMIElementCookie.class);
            
            if (cookie!=null)
                representedObject = cookie.getElement();
            else {
                Object ob = selNode.getCookie(JavaDataObject.class);
                if (ob != null) {
                    JavaDataObject o = (JavaDataObject) ob;
                    Resource cr = JavaMetamodel.getManager().getResource(o.getPrimaryFile());
                    representedObject = cr;
                    if (cr != null) {
                        for (Iterator it = cr.getClassifiers().iterator(); it.hasNext();) {
                            Object obj = it.next();
                            if (!(obj instanceof JavaClass))
                                continue;
                            JavaClass cls = (JavaClass) obj;
                            representedObject = cls;
                            if (selNode.getName().equals(cls.getSimpleName())) {
                                break;
                            }
                        }
                    }
                } else {
                    ob = selNode.getCookie(DataFolder.class);
                    FileObject folder = ((DataFolder) ob).getPrimaryFile();
                    try {
                        if (folder.getFileSystem() != Repository.getDefault().getDefaultFileSystem()) {
                            ClassPath cp = ClassPath.getClassPath(folder, ClassPath.SOURCE);
                            representedObject = null;
                            if (cp!=null) {
                                String packageName = cp.getResourceName(folder, '.', false);
                                FileObject root = cp.findOwnerRoot(folder);
                                if (root != null) {
                                    //cannot refactor root
                                    representedObject = JavaMetamodel.getManager().resolveJavaExtent(root).getJavaPackage().resolvePackage(packageName);
                                    return new RenameRefactoringUI(representedObject, folder);
                                }
                            }
                        }
                    } catch (FileStateInvalidException e) {
                        // ignore
                    }
                }
            }
        }
        return new RenameRefactoringUI(representedObject);
    }
    
    protected boolean enabled(Node[] activatedNodes) {
        if (activatedNodes.length != 1) return false;
        return (activatedNodes[0].getCookie(JavaDataObject.class) != null) 
            || (activatedNodes[0].getCookie(DataFolder.class) != null);
    }
    
//    protected String iconResource () {
//        return "org/netbeans/modules/refactoring/resources/refactoring.gif"; // NOI18N
//    }

    // called from RefactoringOperationListener when a package is renamed manually (not by refactoring action)
    void performAction(final RefObject elem, final String name, final String dispOldName, final boolean checkName, final FileObject folder) {
        if (SwingUtilities.isEventDispatchThread()) {
            doRun(elem, name, dispOldName, checkName, folder);
        } else {
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    doRun(elem, name, dispOldName, checkName, folder);
                }
            });
        }
    }
    
    private final void doRun(RefObject elem, String name, String dispOldName, boolean checkName, FileObject folder) {
        MDRepository rep = JavaMetamodel.getDefaultRepository();
        RefactoringUI ui;
        
        rep.beginTrans(false);
        try {
            JavaMetamodel.getManager().setClassPath(
              ClassPathFactory.createClassPath(RefactoringClassPathImplementation.getDefault())
            );
            ui = new RenameRefactoringUI(elem, name, dispOldName, checkName, folder);
        } finally {
            rep.endTrans();
        }
        new RefactoringPanel(ui);
    }
    
}