/*
 * ChangeSignatureTestCase.java
 *
 * Created on August 23, 2004, 3:53 PM
 */

package org.netbeans.test.refactoring.changesignature;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import org.netbeans.jmi.javamodel.Method;
import org.netbeans.jmi.javamodel.Type;
import org.netbeans.modules.javacore.internalapi.JavaMetamodel;
import org.netbeans.modules.refactoring.api.ChangeParameters;
import org.netbeans.modules.refactoring.api.RefactoringSupport;
import org.netbeans.modules.refactoring.api.ChangeParameters.ParameterInfo;
import org.netbeans.test.refactoring.RefactoringTestCase;
import org.netbeans.test.refactoring.Utility;


/**
 *
 * @author  eh103527
 */
public class ChangeSignatureTestCase extends RefactoringTestCase {
    
    /** Creates a new instance of ChangeSignatureTestCase */
    public ChangeSignatureTestCase(String name) {
        super(name);
    }
    
    protected void changeSignature(String className, String name, String[] arguments, String[][] newArguments, int access, boolean undo) {
        setJavaClass(className);
        Utility.prepareTest();
        
        String args="";
        ArrayList list=new ArrayList();
        boolean finish=false;
        HashMap files=null;
        Collection result = new ArrayList();
        try {
            if (arguments != null) {
                for (int i=0;i < arguments.length;i++) {
                    list.add(Utility.findType(arguments[i], typeProxy));
                    log(Utility.findType(arguments[i], typeProxy));
                /*list.add(typeProxy.resolve(arguments[i]));
                log(typeProxy.resolve(arguments[i]));*/
                    args+=arguments[i];
                    if (i < arguments.length-1) {
                        args+=", ";
                    }
                }
            }
            ref("Change signature of method "+name+"("+args+") of class "+className);
            ref("Add arguments: ");
            for (int i=0;i < newArguments.length;i++) {
                ref(newArguments[i][1]+" "+newArguments[i][0]+" = "+newArguments[i][2]);
            }
            
            //get the method
            Method method=jc.getMethod(name, list, false);
            
            //prepare arguments array
            List origArguments = method.getParameters();
            ParameterInfo[] argTable = new ParameterInfo[origArguments.size()+newArguments.length];
            for (int i=0;i < argTable.length;i++) {
                if (i < origArguments.size()) {
                    argTable[i]=new ParameterInfo(i, null, null, null);;
                } else {
                    Type type=typeProxy.resolve(newArguments[i-origArguments.size()][1]);
                    ParameterInfo newArg = new ParameterInfo(-1,
                    newArguments[i-origArguments.size()][0], type,
                    newArguments[i-origArguments.size()][2]);
                    argTable[i]=newArg;
                }
            }
            //make refactoring sequence
            RefactoringSupport support = RefactoringSupport.getDefault();
            ChangeParameters refactoring = new ChangeParameters(method);
            if (refProblems(refactoring.preCheck())) throw new Exception("Fatal problem");
            if (refProblems(refactoring.setParameters(argTable, access))) throw new Exception("Fatal problem");
            if (refProblems(refactoring.prepare(result))) throw new Exception("Fatal problem");
            files=getResources(result);
            if (refProblems(support.doRefactoring(result, "Change method signature of "+name, 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 {
                if (undo) {
                    JavaMetamodel.getUndoManager().undo();
                }
                compareResources(files, result, className, className);
            } catch (Exception ex) {
                ex.printStackTrace(getLogStream());
                assertTrue(ex.getMessage(), false);
            }
        }
    }
}