/*
    * SPDX-FileCopyrightText: Copyright (c) 2011-2026 Yegor Bugayenko
    * SPDX-License-Identifier: MIT
    */
   package com.qulice.checkstyle;
   
   import com.google.common.base.Optional;
   import com.google.common.collect.ImmutableMap;
   import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
  import com.puppycrawl.tools.checkstyle.api.DetailAST;
  import com.puppycrawl.tools.checkstyle.api.TokenTypes;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  
  /**
   * Checks the order of methods declaration.
   *
   * Right order is: public, protected and private
   *
   * @since 0.6
   */
  public final class MethodsOrderCheck extends AbstractCheck {
  
      @Override
      public int[] getDefaultTokens() {
          return new int[]{
              TokenTypes.CLASS_DEF,
              TokenTypes.ENUM_DEF,
          };
      }
  
      @Override
      public int[] getAcceptableTokens() {
          return this.getDefaultTokens();
      }
  
      @Override
      public int[] getRequiredTokens() {
          return this.getDefaultTokens();
      }
  
      @Override
      public void visitToken(final DetailAST ast) {
          if (ast.getType() == TokenTypes.CLASS_DEF
              || ast.getType() == TokenTypes.ENUM_DEF) {
              this.checkClass(ast);
          }
      }
  
      /**
       * Checks class definition to satisfy the rule.
       * @param node Tree node, containing class definition (CLASS_DEF)
       */
      private void checkClass(final DetailAST node) {
          final DetailAST obj = node.findFirstToken(TokenTypes.OBJBLOCK);
          if (obj != null) {
              this.checkOrder(
                  MethodsOrderCheck.findAllChildren(
                      obj, TokenTypes.METHOD_DEF
                  )
              );
          }
      }
  
      /**
       * Checks order of methods.
       * @param methods Nodes representing class methods
       */
      private void checkOrder(final Iterable<DetailAST> methods) {
          MethodsOrderCheck.Modifiers prev = MethodsOrderCheck.Modifiers.PUB;
          for (final DetailAST method : methods) {
              final MethodsOrderCheck.Modifiers mtype =
                  MethodsOrderCheck.getModifierType(method);
              if (mtype.getOrder() < prev.getOrder()) {
                  this.log(
                      method.getLineNo(),
                      "Wrong method declaration order"
                  );
              } else {
                  prev = mtype;
              }
          }
      }
  
      /**
       * Get method modifier as enum {@code Modifiers}.
       * @param method DetailAST of method
       * @return Element of {@code Modifiers} enum
       */
      private static MethodsOrderCheck.Modifiers getModifierType(
          final DetailAST method
      ) {
          final DetailAST modifiers = method.findFirstToken(TokenTypes.MODIFIERS);
          final DetailAST modifier = Optional.fromNullable(
              modifiers.findFirstToken(
                  MethodsOrderCheck.Modifiers.PUB.getType()
              )
          ).or(
             Optional.fromNullable(
                 modifiers.findFirstToken(
                     MethodsOrderCheck.Modifiers.PROT.getType()
                 )
             )
         ).or(
             Optional.fromNullable(
                 modifiers.findFirstToken(
                     MethodsOrderCheck.Modifiers.PRIV.getType()
                 )
             )
         ).orNull();
         final MethodsOrderCheck.Modifiers mod;
         if (modifier == null) {
             mod = MethodsOrderCheck.Modifiers.DEF;
         } else {
             mod = getByType(modifier.getType());
         }
         return mod;
     }
 
     /**
      * Search for all children of given type.
      * @param base Parent node to start from
      * @param type Node type
      * @return Iterable
      */
     private static Iterable<DetailAST> findAllChildren(final DetailAST base,
         final int type) {
         final List<DetailAST> children = new ArrayList<>(base.getChildCount());
         DetailAST child = base.getFirstChild();
         while (child != null) {
             if (child.getType() == type) {
                 children.add(child);
             }
             child = child.getNextSibling();
         }
         return children;
     }
 
     /**
      * Get Modifiers enum constant by TokenType id.
      * @param type TokenType
      * @return Modifiers constant
      */
     private static MethodsOrderCheck.Modifiers getByType(final int type) {
         return MethodsOrderCheck.Modifiers.mdos.get(type);
     }
 
     /**
      * Enumeration for constants of method modifiers.
      */
     private enum Modifiers {
 
         /**
          * PUBLIC method modifier.
          */
         PUB(TokenTypes.LITERAL_PUBLIC, 1),
 
         /**
          * PROTECTED method modifier.
          */
         PROT(TokenTypes.LITERAL_PROTECTED, 2),
 
         /**
          * DEFAULT method modifier.
          * No correspondent constant in TokenType.
          */
         DEF(-1, 3),
 
         /**
          * PRIVATE method modifier.
          */
         PRIV(TokenTypes.LITERAL_PRIVATE, 4);
 
         /**
          * Convenient map of {@code TokenType} on {@code Modifiers}.
          */
         private static Map<Integer, MethodsOrderCheck.Modifiers> mdos;
 
         static {
             MethodsOrderCheck.Modifiers.mdos =
                 ImmutableMap.<Integer, MethodsOrderCheck.Modifiers>builder()
                     .put(PUB.getType(), PUB)
                     .put(PROT.getType(), PROT)
                     .put(-1, DEF)
                     .put(PRIV.getType(), PRIV)
                     .build();
         }
 
         /**
          * TokenType.
          */
         private final Integer type;
 
         /**
          * Order of modifier.
          */
         private final int order;
 
         /**
          * Constructor.
          * @param type TokenType of DetailAST which represents modifier
          * @param ord Order of the modifier in class definition
          */
         Modifiers(final Integer type, final Integer ord) {
             this.type = type;
             this.order = ord;
         }
 
         /**
          * TokenType.
          * @return TokenType
          */
         int getType() {
             return this.type;
         }
 
         /**
          * Order of modifier.
          * @return Order number
          */
         int getOrder() {
             return this.order;
         }
     }
 }