/*
 * RenameTestCase.java
 *
 * Created on August 23, 2004, 3:45 PM
 */

package org.netbeans.test.refactoring.rename;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import javax.jmi.reflect.RefObject;
import junit.textui.TestRunner;
import org.netbeans.jmi.javamodel.Field;
import org.netbeans.jmi.javamodel.JavaModelPackage;
import org.netbeans.jmi.javamodel.JavaPackage;
import org.netbeans.jmi.javamodel.Method;
import org.netbeans.junit.NbTestSuite;
import org.netbeans.modules.javacore.internalapi.JavaMetamodel;
import org.netbeans.modules.refactoring.api.MoveClassRefactoring;
import org.netbeans.modules.refactoring.api.Problem;
import org.netbeans.modules.refactoring.api.RefactoringSupport;
import org.netbeans.modules.refactoring.api.RenameRefactoring;
import org.netbeans.modules.refactoring.ui.RenameRefactoringUI;
import org.netbeans.test.refactoring.RefactoringTestCase;
import org.netbeans.test.refactoring.Utility;


/**
 *
 * @author  eh103527
 */
public class RenameTestCase extends RefactoringTestCase {
    
    /** Creates a new instance of RenameTestCase */
    public RenameTestCase(String name) {
        super(name);
    }
    
    protected void renameClass(String name, String newName, boolean undo) {
        setJavaClass(name);
        ref("Rename class "+name+" to "+newName);
        rename(jc, name, newName, undo);
    }
    
    protected void renameField(String className, String fieldName, String newFieldName, boolean undo) {
        setJavaClass(className);
        ref("Rename field "+fieldName+" to "+newFieldName+" of class "+className);
        Field field=null;
        JavaMetamodel.getDefaultRepository().beginTrans(true);
        try {
            field = jc.getField(fieldName, false);
        } catch (Throwable t) {
            t.printStackTrace(getLogStream());
            assertTrue(t.getMessage(), false);
        } finally {
            JavaMetamodel.getDefaultRepository().endTrans();
        }
        rename(field, fieldName, newFieldName, undo);
    }
    
    protected void renameMethod(String className, String methodName, String[] attributes, String newMethodName, boolean undo) {
        setJavaClass(className);
        String args="";
        ArrayList list=new ArrayList();
        Method method = null;
        JavaMetamodel.getDefaultRepository().beginTrans(true);
        try {
            if (attributes != null) {
                for (int i=0;i < attributes.length;i++) {
                    list.add(typeProxy.resolve(attributes[i]));
                    args+=attributes[i];
                    if (i < attributes.length-1) {
                        args+=", ";
                    }
                }
            }
            ref("Rename method "+methodName+"("+args+") to "+newMethodName+" of class "+className);
            method = jc.getMethod(methodName, list, false);
        } catch (Throwable t) {
            t.printStackTrace(getLogStream());
            assertTrue(t.getMessage(), false);
        } finally {
            JavaMetamodel.getDefaultRepository().endTrans();
        }
        rename(method, methodName, newMethodName, undo);
    }
    
    //through UI
    protected void renamePackage(String packageName, String newPackageName, String initClass, boolean undo) {
        setJavaClass(initClass);
        Utility.prepareTest();
        ref("Rename package "+packageName+" to "+newPackageName);
        Collection result = new ArrayList();
        boolean finish=false;
        HashMap files=null;
        try {
            JavaPackage pack=((JavaModelPackage)(jc.refOutermostPackage())).getJavaPackage().resolvePackage(packageName);
            RefactoringSupport support = RefactoringSupport.getDefault();
            RenameRefactoringUI ui=new RenameRefactoringUI(pack);
            MoveClassRefactoring refactoring = (MoveClassRefactoring)(ui.getRefactoring());
            if (refProblems(refactoring.preCheck())) throw new Exception("Fatal problem");
            if (refProblems(refactoring.setParameters(newPackageName))) throw new Exception("Fatal problem");
            if (refProblems(refactoring.prepare(result))) throw new Exception("Fatal problem");
            files=getResources(result);
            if (refProblems(support.doRefactoring(result, "Rename package", null))) throw new Exception("Fatal problem");
            JavaMetamodel.getUndoManager().saveAll();
            finish=true;
        } catch (Throwable t) {
            if (t.getMessage() == null || !t.getMessage().equals("Fatal problem")) {
                t.printStackTrace(getLogStream());
                assertTrue(t.getMessage(), false);
            }
        } finally {
            Utility.finishTest();
        }
        if (finish) {
            try {
                Thread.sleep(2000);
                if (undo) {
                    JavaMetamodel.getUndoManager().undo();
                    Thread.sleep(2000);
                }
                compareResources(files, result, packageName, newPackageName);
            } catch (Exception ex) {
                ex.printStackTrace(getLogStream());
                assertTrue(ex.getMessage(), false);
            }
        }
    }
    
    protected void rename(RefObject object, String name, String newName, boolean undo) {
        Utility.prepareTest();
        HashMap files=null;
        Collection result = new ArrayList();
        boolean finish=false;
        try {
            RefactoringSupport support = RefactoringSupport.getDefault();
            RenameRefactoring refactoring = new RenameRefactoring(object);
            if (refProblems(refactoring.preCheck())) throw new Exception("Fatal problem");
            if (refProblems(refactoring.setParameters(newName))) throw new Exception("Fatal problem");
            if (refProblems(refactoring.prepare(result))) throw new Exception("Fatal problem");
            files=getResources(result);
            if (refProblems(support.doRefactoring(result, "Rename", null))) throw new Exception("Fatal problem");
            JavaMetamodel.getUndoManager().saveAll();
            finish=true;
        } catch (Throwable t) {
            if (t.getMessage() == null || !t.getMessage().equals("Fatal problem")) {
                t.printStackTrace(getLogStream());
                assertTrue(t.getMessage(), false);
            }
        } finally {
            Utility.finishTest();
        }
        if (finish) {
            String nm=newName;//generate new name
            if (name.indexOf('.') > -1) { //class with package
                nm=name.substring(0, name.lastIndexOf('.'))+"."+newName;
            }
            try {
                if (undo) {
                    JavaMetamodel.getUndoManager().undo();
                }
                compareResources(files, result, name, nm);
            } catch (Exception ex) {
                ex.printStackTrace(getLogStream());
                assertTrue(ex.getMessage(), false);
            }
        }
    }
}