/*
    * SPDX-FileCopyrightText: Copyright (c) 2011-2026 Yegor Bugayenko
    * SPDX-License-Identifier: MIT
    */
   package com.qulice.checkstyle;
   
   import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
   import com.puppycrawl.tools.checkstyle.api.DetailAST;
   import com.puppycrawl.tools.checkstyle.api.FileContents;
  import com.puppycrawl.tools.checkstyle.api.TokenTypes;
  import com.puppycrawl.tools.checkstyle.utils.AnnotationUtil;
  import java.util.regex.Pattern;
  
  /**
   * Checks that non static method must contain at least one reference to
   * {@code this}.
   *
   * <p>If your method doesn't need {@code this} than why it is not
   * {@code static}?</p>
   *
   * <p>The exception here is when method has {@code @Override} annotation. There's
   * no concept of inheritance and polymorphism for static methods even if they
   * don't need {@code this} to perform the actual work.</p>
   *
   * <p>Another exception is when method is {@code abstract} or {@code native}.
   * Such methods don't have body so detection based on {@code this} doesn't
   * make sense for them.</p>
   *
   * @since 0.3
   */
  public final class NonStaticMethodCheck extends AbstractCheck {
  
      /**
       * Pattern that matches an empty string only.
       */
      private static final Pattern EMPTY = Pattern.compile("^$");
  
      /**
       * Files to exclude from this check.
       * This is mostly to exclude JUnit tests.
       */
      private Pattern exclude;
  
      /**
       * Default constructor.
       */
      public NonStaticMethodCheck() {
          this.exclude = NonStaticMethodCheck.EMPTY;
      }
  
      /**
       * Exclude files matching given pattern.
       *
       * @param excl Regexp of classes to exclude
       */
      public void setExcludeFileNamePattern(final String excl) {
          this.exclude = Pattern.compile(excl);
      }
  
      @Override
      public int[] getDefaultTokens() {
          return new int[] {
              TokenTypes.METHOD_DEF,
          };
      }
  
      @Override
      public int[] getAcceptableTokens() {
          return this.getDefaultTokens();
      }
  
      @Override
      public int[] getRequiredTokens() {
          return this.getDefaultTokens();
      }
  
      @Override
      @SuppressWarnings("deprecation")
      public void visitToken(final DetailAST ast) {
          if (this.exclude.matcher(this.getFileContents().getFileName())
              .find()) {
              return;
          }
          if (TokenTypes.CLASS_DEF == ast.getParent().getParent().getType()) {
              this.checkClassMethod(ast);
          }
      }
  
      private void checkClassMethod(final DetailAST method) {
          final DetailAST modifiers = method
              .findFirstToken(TokenTypes.MODIFIERS);
          if (modifiers.findFirstToken(TokenTypes.LITERAL_STATIC) != null) {
              return;
          }
          final BranchContains checker = new BranchContains(method);
          final boolean onlythrow =
              checker.check(TokenTypes.LITERAL_THROW)
                  && !checker.check(TokenTypes.LCURLY)
                  && this.countSemiColons(method) == 1;
         final boolean skip = AnnotationUtil.containsAnnotation(method, "Override")
             || isInAbstractOrNativeMethod(method)
             || onlythrow;
         if (!skip
             && !checker.check(TokenTypes.LITERAL_THIS)
             && !checker.check(TokenTypes.LITERAL_SUPER)) {
             this.log(
                 method.getLineNo(),
                 "This method must be static, because it does not refer to \"this\""
             );
         }
     }
 
     private static boolean isInAbstractOrNativeMethod(final DetailAST method) {
         final BranchContains checker = new BranchContains(
             method.findFirstToken(TokenTypes.MODIFIERS)
         );
         return checker.check(TokenTypes.ABSTRACT)
             || checker.check(TokenTypes.LITERAL_NATIVE);
     }
 
     @SuppressWarnings("deprecation")
     private int countSemiColons(final DetailAST method) {
         final DetailAST openingbrace = method.findFirstToken(TokenTypes.SLIST);
         int count = 0;
         if (openingbrace != null) {
             final DetailAST closingbrace =
                 openingbrace.findFirstToken(TokenTypes.RCURLY);
             final int lastline = closingbrace.getLineNo();
             final int firstline = openingbrace.getLineNo();
             final FileContents contents = this.getFileContents();
             for (int line = firstline - 1; line < lastline; line += 1) {
                 if (!contents.lineIsBlank(line)
                     && !contents.lineIsComment(line)
                     && contents.getLine(line).contains(";")) {
                     count += 1;
                 }
             }
         }
         return count;
     }
 }