/*
    * 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 com.puppycrawl.tools.checkstyle.utils.ScopeUtil;
  import java.util.ArrayDeque;
  import java.util.Deque;
  import org.cactoos.text.Joined;
  import org.cactoos.text.UncheckedText;
  
  /**
   * Checks that classes are declared as final. Doesn't check for classes nested
   * in interfaces or annotations, as they are always {@code final} there.
   *
   * <p>An example of how to configure the check is:</p>
   * <pre>
   * &lt;module name="ProhibitNonFinalClassesCheck"/&gt;
   * </pre>
   *
   * @since 0.19
   */
  public final class ProhibitNonFinalClassesCheck extends AbstractCheck {
  
      /**
       * Character separate package names in qualified name of java class.
       */
      private static final String PACKAGE_SEPARATOR = ".";
  
      /**
       * Keeps ClassDesc objects for stack of declared classes.
       */
      private Deque<ClassDesc> classes;
  
      /**
       * Full qualified name of the package.
       */
      private String pack;
  
      /**
       * Default constructor.
       */
      public ProhibitNonFinalClassesCheck() {
          this.classes = new ArrayDeque<>();
      }
  
      @Override
      public int[] getDefaultTokens() {
          return this.getRequiredTokens();
      }
  
      @Override
      public int[] getAcceptableTokens() {
          return this.getRequiredTokens();
      }
  
      @Override
      public int[] getRequiredTokens() {
          return new int[] {TokenTypes.CLASS_DEF};
      }
  
      @Override
      public void beginTree(final DetailAST root) {
          this.classes = new ArrayDeque<>();
          this.pack = "";
      }
  
      @Override
      public void visitToken(final DetailAST ast) {
          final DetailAST modifiers = ast.findFirstToken(TokenTypes.MODIFIERS);
          if (ast.getType() == TokenTypes.CLASS_DEF) {
              this.classes.push(
                  new ClassDesc(
                      this.qualifiedClassName(ast),
                      modifiers.findFirstToken(TokenTypes.FINAL) != null,
                      modifiers.findFirstToken(TokenTypes.ABSTRACT) != null
                  )
              );
          }
      }
  
      @Override
      public void leaveToken(final DetailAST ast) {
          if (ast.getType() == TokenTypes.CLASS_DEF) {
              final ClassDesc desc = this.classes.pop();
              if (!desc.isDeclaredAsAbstract()
                  && !desc.isAsfinal()
                  && !ScopeUtil.isInInterfaceOrAnnotationBlock(ast)) {
                  log(
                      ast.getLineNo(),
                      "Classes should be final",
                      ProhibitNonFinalClassesCheck.getClassNameFromQualifiedName(
                          desc.getQualified()
                      )
                  );
             }
         }
     }
 
     private String qualifiedClassName(final DetailAST classast) {
         String outer = null;
         if (!this.classes.isEmpty()) {
             outer = this.classes.peek().getQualified();
         }
         return ProhibitNonFinalClassesCheck.getQualifiedClassName(
             this.pack,
             outer,
             classast.findFirstToken(TokenTypes.IDENT).getText()
         );
     }
 
     private static String getQualifiedClassName(
         final String pack,
         final String outer,
         final String name) {
         final String qualified;
         if (outer == null) {
             if (pack.isEmpty()) {
                 qualified = name;
             } else {
                 qualified =
                     new UncheckedText(
                         new Joined(
                             ProhibitNonFinalClassesCheck.PACKAGE_SEPARATOR,
                             pack,
                             name
                         )
                     ).asString();
             }
         } else {
             qualified =
                 new UncheckedText(
                     new Joined(
                         ProhibitNonFinalClassesCheck.PACKAGE_SEPARATOR,
                         outer,
                         name
                     )
                 ).asString();
         }
         return qualified;
     }
 
     private static String getClassNameFromQualifiedName(
         final String qualified
     ) {
         return qualified.substring(
             qualified.lastIndexOf(
                 ProhibitNonFinalClassesCheck.PACKAGE_SEPARATOR
             ) + 1
         );
     }
 }