/*
    * 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.TokenTypes;
  import java.util.Comparator;
  import java.util.regex.Pattern;
  import java.util.stream.StreamSupport;
  
  /**
   * Check for empty lines inside methods and constructors.
   *
   * <p>We believe that comments and empty lines are evil. If you need to use
   * an empty line in order to add a vertical separator of concepts - refactor
   * your code and make it more cohesive and readable. The bottom line is
   * that every method should look solid and do just <b>one thing</b>.</p>
   *
   * <p>This class is not thread safe. It builds a list of line ranges by visiting
   * each method definition and each anonymous inner type, keeps them in
   * instance fields until finishTree() reports and clears them, so a single
   * instance must not be shared between threads.</p>
   *
   * @since 0.3
   */
  public final class EmptyLinesCheck extends AbstractCheck {
  
      /**
       * Pattern for empty line check.
       */
      private static final Pattern PATTERN = Pattern.compile("^\\s*$");
  
      /**
       * Line ranges of all anonymous inner types.
       */
      private final LineRanges anons;
  
      /**
       * Line ranges of all method and constructor bodies.
       */
      private final LineRanges methods;
  
      /**
       * Default constructor.
       */
      public EmptyLinesCheck() {
          this.anons = new LineRanges();
          this.methods = new LineRanges();
      }
  
      @Override
      public int[] getDefaultTokens() {
          return new int[] {
              TokenTypes.METHOD_DEF,
              TokenTypes.CTOR_DEF,
              TokenTypes.OBJBLOCK,
          };
      }
  
      @Override
      public int[] getAcceptableTokens() {
          return this.getDefaultTokens();
      }
  
      @Override
      public int[] getRequiredTokens() {
          return this.getDefaultTokens();
      }
  
      @Override
      public void visitToken(final DetailAST ast) {
          this.getLine(ast.getLastChild().getLineNo() - 1);
          if (ast.getType() == TokenTypes.OBJBLOCK
              && ast.getParent() != null
              && ast.getParent().getType() == TokenTypes.LITERAL_NEW) {
              final DetailAST left = ast.getFirstChild();
              final DetailAST right = ast.getLastChild();
              if (left != null && right != null) {
                  this.anons.add(
                      new LineRange(left.getLineNo(), right.getLineNo())
                  );
              }
          } else if (ast.getType() == TokenTypes.METHOD_DEF
              || ast.getType() == TokenTypes.CTOR_DEF) {
              final DetailAST opening = ast.findFirstToken(TokenTypes.SLIST);
              if (opening != null) {
                  this.methods.add(
                      new LineRange(
                          opening.getLineNo(),
                          opening.findFirstToken(TokenTypes.RCURLY).getLineNo()
                      )
                  );
              }
          }
      }
  
     @Override
     public void finishTree(final DetailAST root) {
         final String[] lines = this.getLines();
         for (int line = 0; line < lines.length; ++line) {
             if (this.methods.inRange(line + 1)
                 && EmptyLinesCheck.PATTERN.matcher(lines[line]).find()
                 && this.insideMethod(line + 1)) {
                 this.log(line + 1, "Empty line inside method");
             }
         }
         this.methods.clear();
         this.anons.clear();
         super.finishTree(root);
     }
 
     private boolean insideMethod(final int line) {
         return EmptyLinesCheck.linesBetweenBraces(
             line, this.methods::iterator, Integer.MIN_VALUE
         ) < EmptyLinesCheck.linesBetweenBraces(
             line, this.anons::iterator, Integer.MAX_VALUE
         );
     }
 
     private static int linesBetweenBraces(final int line,
         final Iterable<LineRange> iterator, final int def) {
         return StreamSupport.stream(iterator.spliterator(), false)
             .filter(r -> r.within(line))
             .min(Comparator.comparingInt(r -> r.last() - r.first()))
             .map(r -> r.last() - r.first())
             .orElse(def);
     }
 }