android/src/org/jetbrains/android/dom/AndroidCreateOnClickHandlerAction.java

package org.jetbrains.android.dom;

import com.intellij.codeInsight.FileModificationService;
import com.intellij.codeInsight.intention.AbstractIntentionAction;
import com.intellij.codeInsight.intention.HighPriorityAction;
import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.Messages;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.*;
import com.intellij.psi.codeStyle.CodeStyleManager;
import com.intellij.psi.codeStyle.JavaCodeStyleManager;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.search.searches.ClassInheritorsSearch;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.psi.util.PsiUtilBase;
import com.intellij.psi.xml.XmlAttribute;
import com.intellij.psi.xml.XmlAttributeValue;
import com.intellij.psi.xml.XmlFile;
import com.intellij.util.IncorrectOperationException;
import com.intellij.util.Processor;
import com.intellij.util.PsiNavigateUtil;
import com.intellij.util.xml.DomManager;
import com.intellij.util.xml.GenericAttributeValue;
import org.jetbrains.android.dom.converters.OnClickConverter;
import org.jetbrains.android.facet.AndroidFacet;
import org.jetbrains.android.util.AndroidBundle;
import org.jetbrains.android.util.AndroidUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

/**
 * @author Eugene.Kudelevsky
 */
public class AndroidCreateOnClickHandlerAction extends AbstractIntentionAction implements HighPriorityAction {
  @NotNull
  @Override
  public String getText() {
    return AndroidBundle.message("create.on.click.handler.intention.text");
  }

  @Override
  public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
    if (editor == null || !(file instanceof XmlFile)) {
      return false;
    }
    final AndroidFacet facet = AndroidFacet.getInstance(file);

    if (facet == null) {
      return false;
    }
    final XmlAttributeValue attrValue = getXmlAttributeValue(file, editor);

    if (attrValue == null) {
      return false;
    }
    final PsiElement parent = attrValue.getParent();

    if (!(parent instanceof XmlAttribute)) {
      return false;
    }
    final GenericAttributeValue domValue = DomManager.getDomManager(project).getDomElement((XmlAttribute)parent);

    if (domValue == null || !(domValue.getConverter() instanceof OnClickConverter)) {
      return false;
    }
    final String methodName = attrValue.getValue();
    return methodName != null && StringUtil.isJavaIdentifier(methodName);
  }

  @Nullable
  private static XmlAttributeValue getXmlAttributeValue(PsiFile file, Editor editor) {
    final int offset = editor.getCaretModel().getOffset();
    final PsiElement element = file.findElementAt(offset);
    return element != null ? PsiTreeUtil.getParentOfType(element, XmlAttributeValue.class) : null;
  }

  @Override
  public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
    final AndroidFacet facet = AndroidFacet.getInstance(file);
    assert facet != null;

    final XmlAttributeValue attrValue = getXmlAttributeValue(file, editor);
    assert attrValue != null;
    final String methodName = attrValue.getValue();
    assert methodName != null;
    final GenericAttributeValue domValue = DomManager.getDomManager(project).getDomElement((XmlAttribute)attrValue.getParent());
    assert domValue != null;
    final OnClickConverter converter = (OnClickConverter)domValue.getConverter();

    final PsiClass activityBaseClass = JavaPsiFacade.getInstance(project).findClass(
      AndroidUtils.ACTIVITY_BASE_CLASS_NAME, facet.getModule().getModuleWithDependenciesAndLibrariesScope(false));

    if (activityBaseClass == null) {
      return;
    }
    final GlobalSearchScope scope = facet.getModule().getModuleScope(false);
    final PsiClass selectedClass;

    if (ApplicationManager.getApplication().isUnitTestMode()) {
      final Ref<PsiClass> selClassRef = Ref.create();

      ClassInheritorsSearch.search(activityBaseClass, scope, true, true, false).forEach(new Processor<PsiClass>() {
        @Override
        public boolean process(PsiClass psiClass) {
          if (!psiClass.isInterface() && !psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
            selClassRef.set(psiClass);
            return false;
          }
          return true;
        }
      });
      selectedClass = selClassRef.get();
    }
    else {
      final TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project).createInheritanceClassChooser(
        "Choose Activity to Create the Method", scope, activityBaseClass, null, new ClassFilter() {
        @Override
        public boolean isAccepted(PsiClass aClass) {
          return !converter.findHandlerMethod(aClass, methodName);
        }
      });
      chooser.showDialog();
      selectedClass = chooser.getSelected();
    }

    if (selectedClass != null) {
      addHandlerMethodAndNavigate(project, selectedClass, methodName, converter.getDefaultMethodParameterType(selectedClass));
    }
  }

  @NotNull
  private static String suggestVarName(@NotNull String type) {
    for (int i = type.length() - 1; i >= 0; i--) {
      final char c = type.charAt(i);

      if (Character.isUpperCase(c)) {
        return type.substring(i).toLowerCase();
      }
    }
    return "o";
  }

  @Nullable
  public static PsiMethod addHandlerMethod(@NotNull Project project,
                                           @NotNull PsiClass psiClass,
                                           @NotNull String methodName,
                                           @NotNull String methodParamType) {
    final PsiFile file = psiClass.getContainingFile();

    if (file == null || !FileModificationService.getInstance().prepareFileForWrite(file)) {
      return null;
    }
    final PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory();
    final String varName = suggestVarName(methodParamType);
    PsiMethod method = (PsiMethod)psiClass.add(factory.createMethodFromText(
      "public void " + methodName + "(" + methodParamType + " " + varName + ") {}", psiClass));

    PsiMethod method1 = (PsiMethod)CodeStyleManager.getInstance(project).reformat(method);
    method1 = (PsiMethod)JavaCodeStyleManager.getInstance(project).shortenClassReferences(method1);
    return (PsiMethod)method.replace(method1);
  }

  public static void addHandlerMethodAndNavigate(@NotNull final Project project,
                                                 @NotNull final PsiClass psiClass,
                                                 @NotNull final String methodName,
                                                 @NotNull final String methodParamType) {
    if (!AndroidUtils.isIdentifier(methodName)) {
      Messages.showErrorDialog(project, String.format("%1$s is not a valid Java identifier/method name.", methodName), "Invalid Name");
      return;
    }

    ApplicationManager.getApplication().runWriteAction(new Runnable() {
      @Override
      public void run() {
        final PsiMethod method = addHandlerMethod(project, psiClass, methodName, methodParamType);

        if (method == null) {
          return;
        }
        if (!ApplicationManager.getApplication().isUnitTestMode()) {
          PsiNavigateUtil.navigate(method);
        }
        final PsiFile javaFile = method.getContainingFile();

        if (javaFile == null) {
          return;
        }
        final Editor javaEditor = PsiUtilBase.findEditor(method);

        if (javaEditor == null) {
          return;
        }
        final PsiCodeBlock body = method.getBody();

        if (body != null) {
          final PsiJavaToken lBrace = body.getLBrace();

          if (lBrace != null) {
            javaEditor.getCaretModel().moveToOffset(lBrace.getTextRange().getEndOffset());
          }
        }
      }
    });
  }
}