/*
 * WhereUsedTestCase.java
 *
 * Created on August 23, 2004, 3:33 PM
 */

package org.netbeans.test.refactoring.usages;

import java.util.ArrayList;
import java.util.Collection;
import org.netbeans.jmi.javamodel.Constructor;
import org.netbeans.jmi.javamodel.Method;
import org.netbeans.modules.refactoring.api.Problem;
import org.netbeans.modules.refactoring.api.RefactoringSupport;
import org.netbeans.modules.refactoring.api.WhereUsedQuery;
import org.netbeans.test.refactoring.RefactoringTestCase;
import org.netbeans.test.refactoring.Utility;

/**
 *
 * @author  eh103527
 */
public class WhereUsedTestCase extends RefactoringTestCase {
    
    /** Creates a new instance of WhereUsedTestCase */
    public WhereUsedTestCase(String name) {
        super(name);
    }
    
    protected void findClass(String className) {
        setJavaClass(className);
        ref("Find usages of: "+className);
        RefactoringSupport support = RefactoringSupport.getDefault();
        WhereUsedQuery wu=new WhereUsedQuery(jc);
        Collection result = new ArrayList();
        refProblems(wu.prepare(result));
        refUsages(result);
        ref("");
    }
    
    protected void findClassParams(String className, boolean subTypes, boolean directSubTypes) {
        setJavaClass(className);
        ref("Find usages of: "+className);
        RefactoringSupport support = RefactoringSupport.getDefault();
        WhereUsedQuery wu=new WhereUsedQuery(jc);
        refProblems(wu.setParametersForClass(subTypes, directSubTypes));
        Collection result = new ArrayList();
        refProblems(wu.prepare(result));
        refUsages(result);
        ref("");
    }
    
    protected void findField(String className, String fieldName) {
        setJavaClass(className);
        Utility.beginTrans(false);
        try {
            RefactoringSupport support = RefactoringSupport.getDefault();
            
            org.netbeans.jmi.javamodel.Field field = jc.getField(fieldName, false);
            ref("Find usages of: "+fieldName);
            WhereUsedQuery wu=new WhereUsedQuery(field);
            Collection result = new ArrayList();
            refProblems(wu.prepare(result));
            refUsages(result);
        } finally {
            Utility.endTrans();
        }
        ref("");
    }
    
    protected void findConstructor(String className, String[] arguments) {
        setJavaClass(className);
        Utility.beginTrans(false);
        try {
            RefactoringSupport support = RefactoringSupport.getDefault();
            ArrayList list=new ArrayList();
            String refs="Find usages of "+className+"(";
            if (arguments != null && arguments.length > 0) {
                for (int i=0;i < arguments.length;i++) {
                    list.add(typeProxy.resolve(arguments[i]));
                    if (i > 0) {
                        refs+=", ";
                    }
                    refs+=arguments[i];
                }
            }
            refs+=")";
            ref(refs);
            Constructor cons = jc.getConstructor(list, false);
            WhereUsedQuery wu=new WhereUsedQuery(cons);
            Collection result = new ArrayList();
            refProblems(wu.prepare(result));
            refUsages(result);
        } finally {
            Utility.endTrans();
        }
        ref("");
    }
    
    protected void findMethod(String className, String methodName, String[] arguments) {
        setJavaClass(className);
        Utility.beginTrans(false);
        try {
            RefactoringSupport support = RefactoringSupport.getDefault();
            ArrayList list=new ArrayList();
            String refs="Find usages of "+className+"."+methodName+"(";
            if (arguments != null && arguments.length > 0) {
                for (int i=0;i < arguments.length;i++) {
                    list.add(typeProxy.resolve(arguments[i]));
                    if (i > 0) {
                        refs+=", ";
                    }
                    refs+=arguments[i];
                }
            }
            refs+=")";
            ref(refs);
            Method method = jc.getMethod(methodName, list, false);
            WhereUsedQuery wu=new WhereUsedQuery(method);
            Collection result = new ArrayList();
            refProblems(wu.prepare(result));
            refUsages(result);
        } finally {
            Utility.endTrans();
        }
        ref("");
    }
    
    protected void findMethodParams(String className, String methodName, String[] arguments, boolean fromBaseClass, boolean methodOverriders, boolean findUsages) {
        setJavaClass(className);
        Utility.beginTrans(false);
        try {
            RefactoringSupport support = RefactoringSupport.getDefault();
            ArrayList list=new ArrayList();
            String refs="Find usages of "+className+"."+methodName+"(";
            if (arguments != null && arguments.length > 0) {
                for (int i=0;i < arguments.length;i++) {
                    list.add(typeProxy.resolve(arguments[i]));
                    if (i > 0) {
                        refs+=", ";
                    }
                    refs+=arguments[i];
                }
            }
            refs+=")";
            ref(refs);
            Method method = jc.getMethod(methodName, list, false);
            WhereUsedQuery wu=new WhereUsedQuery(method);
            Problem p=wu.checkParametersForMethod(fromBaseClass, methodOverriders, findUsages);
            refProblems(p);
            if (p != null && p.isFatal()) return;
            wu.setParametersForMethod(fromBaseClass, methodOverriders, findUsages);
            Collection result = new ArrayList();
            refProblems(wu.prepare(result));
            refUsages(result);
        } finally {
            Utility.endTrans();
        }
        ref("");
    }
    
}