package com.checks.lint2.detectors;

import com.android.tools.lint.detector.api.Category;
import com.android.tools.lint.detector.api.Detector;
import com.android.tools.lint.detector.api.Issue;
import com.android.tools.lint.detector.api.JavaContext;
import com.android.tools.lint.detector.api.Location;
import com.android.tools.lint.detector.api.Severity;
import com.intellij.psi.JavaElementVisitor;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiClassType;
import com.intellij.psi.PsiElement;

public class HashSpecificMethodExistDetector extends Detector
    implements Detector.JavaPsiScanner {

  public static final Issue ISSUE =
      IssueBuilder.create("HashSpecificMethodExist")
          .description("Implement hashCodeSpecific method.")
          .explanation(
              "")
          .category(Category.CORRECTNESS)
          .severity(Severity.ERROR)
          .detectorClass(HashSpecificMethodExistDetector.class)
          .build();

  @Override
  public List<Class<? extends PsiElement>> getApplicablePsiTypes() {
    return Collections.<Class<? extends PsiElement>>singletonList(PsiClass.class);
  } @Override
  public JavaElementVisitor createPsiVisitor(final JavaContext context) {
    return new Visitor(context);
  }

  private static class Visitor extends JavaElementVisitor {

    private static final String HASH_CODE_METHOD = "hashCodeSpecificMethod";

    private final JavaContext mContext;

    public Visitor(JavaContext context) {
      mContext = context;
    }

    @Override
    public void visitClass(PsiClass aClass) {
      if (!mContext.getDriver().isSuppressed(mContext, ISSUE, aClass)) {
        if (checkSuperClassesForSpecificMethodIfc(aClass)) {
          checkHashCodeSpecificMethod(aClass);
        }
      }
      super.visitClass(aClass);
    }

private boolean checkInterfacesForHashCodeSpecificMethod(PsiClass aClass) {for (PsiClass anInterface : aClass.getInterfaces()) {
        if (anInterface.getName().equals("HashCodeSpecificMethodInterface")) {
          return true;
        }
      }
      return false;
    }

    private boolean checkSuperClassesForSpecificMethodIfc(PsiClass currentClass) {
      boolean foundInInterfaces = checkInterfacesForHashCodeSpecificMethod(currentClass);
      if (foundInInterfaces) {
        return true;
      }
      PsiClass superClass = currentClass.getSuperClass();
      if (superClass != null) {
        return checkSuperClassesForSpecificMethodIfc(superClass);
      }
      return false;
    }

    private void checkHashCodeSpecificMethod(PsiClass aClass) {
      PsiMethod[] hashCodeMethods = aClass.findMethodsByName(HASH_CODE_METHOD, false);
      if (hashCodeMethods == null || hashCodeMethods.length == 0) {
        mContext.report(
            ISSUE,
            Location.create(
                mContext.file,
                mContext.getContents(),
                aClass.getNameIdentifier().getTextOffset(),
                aClass.getNameIdentifier().getTextOffset()
                    + aClass.getNameIdentifier().getTextLength()),
            "");
      }
    }
  }
}