import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jdt.core.IMethod;

import org.eclipse.jdt.core.IPackageFragment;

import org.eclipse.jdt.core.ITypeHierarchy;

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Label;

import org.eclipse.wst.common.project.facet.core.IFacetedProject;

import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;

import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;

    private class CactusPage1 extends NewTestCaseWizardPageOne

    {

        private Button fBeginButton;

        private Button fEndButton;

        private Button fBeginXXXButton;

        private Button fEndXXXButton;

        private Composite fCactusButtonComposite;

        public CactusPage1(NewTestCaseWizardPageTwo page2) {

            super(page2);

        }

        public void init(IStructuredSelection selection) {

            super.init(selection);

        }

        public void createControl(Composite parent) {

            super.createControl(parent);

            setSuperClass(SUPERCLASS_NAME, true);

        }

        protected IStatus superClassChanged() {

            String superClassName= getSuperClass();

            if (superClassName == null || superClassName.trim().equals("")) { //$NON-NLS-1$

                Status status = new Status(IStatus.ERROR, JavaServerUIPlugin.PLUGIN_ID, IStatus.ERROR, Messages.NewServletTestCaseWizard_WarningMessageSuperclassIsEmpty, null);

                return status;  

            }

            if (superClassName.equals("org.apache.cactus.ServletTestCase")){

                //Short-circuit if this IS ServletTestCase

                return Status.OK_STATUS; 

            }

            if (getPackageFragmentRoot() != null)

            {

                IType type;

                try {

                    type = resolveClassNameToType(getPackageFragmentRoot().getJavaProject(), getPackageFragment(), superClassName);

                    if (type == null) {

                        Status status = new Status(IStatus.WARNING, JavaServerUIPlugin.PLUGIN_ID, IStatus.WARNING, Messages.NewServletTestCaseWizard_WarningMessageSuperclassDoesNotExist, null);

                        return status;                        

                    }

                    if (type.isInterface()) {

                        Status status = new Status(IStatus.WARNING, JavaServerUIPlugin.PLUGIN_ID, IStatus.WARNING, Messages.NewServletTestCaseWizard_WarningMessageSuperclassIsInterface, null);

                        return status;

                    }

                    ITypeHierarchy hierarchy = type.newTypeHierarchy(null);

                    IType [] superTypes = hierarchy.getAllSuperclasses(type);

                    for (int i=0; i<superTypes.length; i++)

                    {

                        if (superTypes[i].getFullyQualifiedName().equals("org.apache.cactus.ServletTestCase"))

                        {

                            return Status.OK_STATUS; 

                        }

                    }

                    Status status = new Status(IStatus.WARNING, JavaServerUIPlugin.PLUGIN_ID, IStatus.WARNING, Messages.NewServletTestCaseWizard_WarningMessageSuperclassNotServletTestCase, null);

                    return status;

                } catch (JavaModelException e) {

                    JavaServerUIPlugin.log(e);

                }    

            }

            return Status.OK_STATUS;

        }

        private IType resolveClassNameToType(IJavaProject jproject, IPackageFragment pack, String classToTestName) throws JavaModelException {

            IType type= jproject.findType(classToTestName);

            // search in current package

            if (type == null && pack != null && !pack.isDefaultPackage()) {

                type= jproject.findType(pack.getElementName(), classToTestName);

            }

            // search in java.lang

            if (type == null) {

                type= jproject.findType("java.lang", classToTestName); //$NON-NLS-1$

            }

            return type;

        }

        protected IStatus validateIfJUnitProject() {

            try {

                if (checkForWebProject())

                {

                    checkForCactusLibraries();                

                }

                else

                {

                    String msg = Messages.NewServletTestCaseWizard_WarningMessageSelectAWebProject;

                    MessageDialog.openWarning(getShell(), Messages.NewServletTestCaseWizard_WarningTitleWebProjectRequired, msg);

                    return new Status(IStatus.WARNING, JavaServerUIPlugin.PLUGIN_ID, IStatus.ERROR, msg, null);

                }

            } catch (CoreException e) {

                return new Status(Status.ERROR, JavaServerUIPlugin.PLUGIN_ID, IStatus.ERROR, "Failed to check for cactus libraries." ,e);

            }

            return Status.OK_STATUS;

        }

        protected void createTypeMembers(IType type, ImportsManager imports, IProgressMonitor monitor) throws CoreException {

            super.createTypeMembers(type, imports, monitor);

            if (fBeginButton.getSelection())

            {

                generateBeginMethod(type, imports);

            }

            if (fEndButton.getSelection())

            {

                generateEndMethod(type, imports);

            }

            if (fBeginXXXButton.getSelection())

            {

                generateBeginXXXMethods(type, imports);

            }

            if (fEndXXXButton.getSelection())

            {

                generateEndXXXMethods(type, imports);

            }

        }

        private void generateBeginMethod(IType type, ImportsManager imports)

        throws JavaModelException

        {

            StringBuilder methodBuffer = new StringBuilder();

            methodBuffer.append("public void begin("); //$NON-NLS-1$

            methodBuffer.append(imports.addImport("org.apache.cactus.WebRequest")); //$NON-NLS-1$

            methodBuffer.append(" request) throws "); //$NON-NLS-1$

            methodBuffer.append(imports.addImport("java.lang.Exception")); //$NON-NLS-1$

            methodBuffer.append(" {\n\n\t} "); //$NON-NLS-1$

            type.createMethod(methodBuffer.toString(), null, false, null);

        }

        private void generateEndMethod(IType type, ImportsManager imports)

        throws JavaModelException

        {

            StringBuilder methodBuffer = new StringBuilder();

            methodBuffer.append("public void end("); //$NON-NLS-1$

            methodBuffer.append(imports.addImport("org.apache.cactus.WebRequest")); //$NON-NLS-1$

            methodBuffer.append(" request) throws "); //$NON-NLS-1$

            methodBuffer.append(imports.addImport("java.lang.Exception")); //$NON-NLS-1$

            methodBuffer.append(" {\n\n\t} "); //$NON-NLS-1$

            type.createMethod(methodBuffer.toString(), null, false, null);       

        }

        private void generateBeginXXXMethods(IType type, ImportsManager imports)

        throws JavaModelException

        {

            generateXXXMethods(type, imports, "begin"); //$NON-NLS-1$

        }

        private void generateXXXMethods(IType type, ImportsManager imports, String prefix) throws JavaModelException

        {

            IMethod [] testMethods = type.getMethods();

            for (int i=0; i<testMethods.length; i++)

            {

                IMethod testMethod = testMethods[i];

                String testMethodName = testMethod.getElementName();

                if (testMethodName.startsWith("test")) //$NON-NLS-1$

                {

                    String newMethodName = prefix + testMethodName.substring(4);

                    StringBuilder methodBuffer = new StringBuilder();

                    methodBuffer.append("public void "); //$NON-NLS-1$

                    methodBuffer.append(newMethodName);

                    methodBuffer.append("("); //$NON-NLS-1$

                    methodBuffer.append(imports.addImport("org.apache.cactus.WebRequest")); //$NON-NLS-1$

                    methodBuffer.append(" request) throws "); //$NON-NLS-1$

                    methodBuffer.append(imports.addImport("java.lang.Exception")); //$NON-NLS-1$

                    methodBuffer.append(" {\n\n\t} "); //$NON-NLS-1$

                    type.createMethod(methodBuffer.toString(), testMethod, false, null);  

                }

            }           

        }

        private void generateEndXXXMethods(IType type, ImportsManager imports)

        throws JavaModelException

        {

            generateXXXMethods(type, imports, "end");          //$NON-NLS-1$

        }

        protected void createMethodStubSelectionControls(Composite composite, int nColumns) {

            super.createMethodStubSelectionControls(composite, nColumns);

            createEmptySpace(composite);

            fCactusButtonComposite = new Composite(composite, SWT.NONE);

            GridData gd = new GridData();

            gd.horizontalSpan = 3;

            fCactusButtonComposite.setLayoutData(gd);

            GridLayout layout = new GridLayout();

            layout.numColumns = 1;

            layout.marginWidth = layout.marginHeight = 0;

            layout.makeColumnsEqualWidth = true;

            fCactusButtonComposite.setLayout(layout);

            fBeginButton = createSelectionButton("begin()", fCactusButtonComposite); //$NON-NLS-1$

            fEndButton = createSelectionButton("end()", fCactusButtonComposite); //$NON-NLS-1$

            fBeginXXXButton = createSelectionButton("beginXXX() methods", fCactusButtonComposite); //$NON-NLS-1$

            fEndXXXButton = createSelectionButton("endXXX() methods", fCactusButtonComposite); //$NON-NLS-1$

        }

        private Button createSelectionButton(String text, Composite group) {

            Button button= new Button(group, SWT.CHECK | SWT.LEFT);

            button.setFont(group.getFont());            

            button.setText(text);

            GridData data = new GridData();

            data.horizontalAlignment = SWT.BEGINNING;

            data.verticalAlignment = GridData.CENTER;

            button.setLayoutData(data);

            return button;

        }

    }

    private static Control createEmptySpace(Composite parent) {

        return createEmptySpace(parent, 1);

    }

    private static Control createEmptySpace(Composite parent, int span) {

        Label label= new Label(parent, SWT.LEFT);

        GridData gd= new GridData();

        gd.horizontalAlignment= GridData.BEGINNING;

        gd.grabExcessHorizontalSpace= false;

        gd.horizontalSpan= span;

        gd.horizontalIndent= 0;

        gd.widthHint= 0;

        gd.heightHint= 0;

        label.setLayoutData(gd);

        return label;

    }

    private boolean checkForWebProject() throws CoreException

    {

        IPackageFragmentRoot root = fPage1.getPackageFragmentRoot();

        if (root == null)

            return false;

        IJavaProject project = root.getJavaProject();

        IFacetedProject facetedProject = ProjectFacetsManager.create(project.getProject());

        if (facetedProject != null)

        {

            Iterator facets = facetedProject.getProjectFacets().iterator();

            while(facets.hasNext())

            {

                IProjectFacetVersion facet = (IProjectFacetVersion) facets.next();

                if (facet.getProjectFacet().getId().equals("jst.web")) //$NON-NLS-1$

                {

                    return true;

                }

            }            

        }

        return false;

    }

    private void checkForCactusLibraries()

    {

        IPackageFragmentRoot root = fPage1.getPackageFragmentRoot();

        if (root == null)

            return;

        IJavaProject project = root.getJavaProject();

        List missingLibraries = new ArrayList();

        try {

            for (int i = 0; i < CLASSES_TO_CHECK.length; i++) {

                IType type = project.findType(CLASSES_TO_CHECK[i]);

                if (type == null) {

                    missingLibraries.add(REQUIRED_LIBRARIES[i]);

                }

            }

            if (missingLibraries.size() > 0)

            {

                if (MessageDialog.openQuestion(getShell(), Messages.NewServletTestCaseWizard_ErrorMessageTitleMissingLibrary,

                        NLS.bind(Messages.NewServletTestCaseWizard_ErrorMessageMissingLibrary, missingLibraries.toArray())))

                {

                    CactusAddLibrariesProposal.installLibraries(project.getProject());

                }

            }

        } catch (JavaModelException e) {

            JavaServerUIPlugin.log(e);

        }        

    }

package org.eclipse.jst.server.ui.internal.cactus;

import java.io.File;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.net.URISyntaxException;

import java.net.URL;

import org.eclipse.core.resources.IContainer;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IFolder;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Platform;

import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.ui.text.java.IInvocationContext;

import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.contentassist.IContextInformation;

import org.eclipse.jst.server.ui.internal.JavaServerUIPlugin;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.actions.CopyFilesAndFoldersOperation;

import org.eclipse.ui.actions.WorkspaceModifyOperation;

import org.eclipse.wst.common.componentcore.ComponentCore;

import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;

import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;

import org.osgi.framework.Bundle;

import com.sun.org.apache.bcel.internal.generic.FCONST;

public class CactusAddLibrariesProposal implements IJavaCompletionProposal {

    private final IInvocationContext fContext;

    public CactusAddLibrariesProposal(IInvocationContext context) {

       fContext = context;

    }

    public int getRelevance() {

        return 0;

    }

    public void apply(IDocument document) {

        ICompilationUnit javaFile = fContext.getCompilationUnit();

        installLibraries(javaFile.getJavaProject().getProject());

    }

    public static void installLibraries(final IProject project)

    {

        Bundle bundle = JavaServerUIPlugin.getInstance().getBundle(); 

        URL cactusLibDir = Platform.find(bundle, new Path("libraries/cactus"));

        try

        {

            URL localURL = Platform.asLocalURL(cactusLibDir);

            final File sourceDirectory = new File(localURL.getPath());

            IVirtualComponent component = ComponentCore.createComponent(project);

            IVirtualFolder vf = component.getRootFolder().getFolder( "WEB-INF/lib" );

            final IContainer destinationDirectory = vf.getUnderlyingFolder();

            IFolder destinationFolder = project.getFolder(destinationDirectory.getProjectRelativePath());

            if (destinationFolder.exists())

            {

                File [] filesToCopy = sourceDirectory.listFiles();

                String [] filesToCopyNames = new String[filesToCopy.length];

                for (int i=0; i<filesToCopy.length; i++)

                {

                    filesToCopyNames[i] = filesToCopy[i].getAbsolutePath();

                }

                CopyFilesAndFoldersOperation operation = new CopyFilesAndFoldersOperation(JavaServerUIPlugin.getActiveWorkbenchShell());

                operation.copyFiles(filesToCopyNames, destinationFolder);

            }

            else

            {

                showInstallFailedDialog();

            }             

        }

        catch (IOException e) {

            JavaServerUIPlugin.log(e);

            showInstallFailedDialog();

        }        

    }

    private static void showInstallFailedDialog()

    {

        MessageDialog.openError(JavaServerUIPlugin.getActiveWorkbenchShell(), "Couldn't install libraries", "Installation of libraries fail.");        

    }

    public Point getSelection(IDocument document) {

        return new Point(fContext.getSelectionOffset(), fContext.getSelectionLength());

    }

    public String getAdditionalProposalInfo() {

        return "Add the Cactus libraries to do the WEB-INF/lib directory";

    }

    public String getDisplayString() {

        return "Add Cactus Libraries";

    }

    public Image getImage() {

        return null;

    }

    public IContextInformation getContextInformation() {

        return null;

    }

}

package org.eclipse.jst.server.ui.internal.cactus;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.jdt.core.IBuffer;

import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.core.compiler.IProblem;

import org.eclipse.jdt.ui.text.java.IInvocationContext;

import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;

import org.eclipse.jdt.ui.text.java.IProblemLocation;

import org.eclipse.jdt.ui.text.java.IQuickFixProcessor;

import org.eclipse.jst.server.ui.internal.JavaServerUIPlugin;

public class CactusQuickFixProcessor implements IQuickFixProcessor {

    public boolean hasCorrections(ICompilationUnit unit, int problemId) {

        return IProblem.ImportNotFound == problemId;

    }

    public IJavaCompletionProposal[] getCorrections(IInvocationContext context,

            IProblemLocation[] locations) throws CoreException {

       if (isCactusProblem(context, locations))

       {

           return new IJavaCompletionProposal[]{new CactusAddLibrariesProposal(context)};

       }

       else

       {

           return new IJavaCompletionProposal[0];

       }

    }

    private boolean isCactusProblem(IInvocationContext context, IProblemLocation[] locations) {

        ICompilationUnit unit= context.getCompilationUnit();

        for (int i= 0; i < locations.length; i++) {

            IProblemLocation location= locations[i];

            try {

                String s= getStringUntilWhiteSpaceOrEnd(location.getOffset(), unit);

                if ("ServletTestCase".equals(s) || s.contains("org.apache.cactus"))

                {

                    return true;

                }

            } catch (JavaModelException e) {

                JavaServerUIPlugin.log(e);

            }

        }

        return false;

    }

    private String getStringUntilWhiteSpaceOrEnd(int offset, ICompilationUnit unit) throws JavaModelException

    {

        StringBuilder builder = new StringBuilder();

        IBuffer buffer = unit.getBuffer();

        int length = buffer.getLength();

        for (int index = offset; index<length ; index++)

        {

            char c = buffer.getChar(index);

            if (Character.isWhitespace(c))

            {

                return builder.toString();

            }

            else

            {

                builder.append(c);        

            }

        }

        return builder.toString();

    }

}