///////////////////////////////////////////////////////////////////////////////////////////////
   // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
   // Copyright (C) 2001-2026 the original author or authors.
   //
   // This library is free software; you can redistribute it and/or
   // modify it under the terms of the GNU Lesser General Public
   // License as published by the Free Software Foundation; either
   // version 2.1 of the License, or (at your option) any later version.
   //
  // This library is distributed in the hope that it will be useful,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  // Lesser General Public License for more details.
  //
  // You should have received a copy of the GNU Lesser General Public
  // License along with this library; if not, write to the Free Software
  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  ///////////////////////////////////////////////////////////////////////////////////////////////
  
  package com.puppycrawl.tools.checkstyle.checks.javadoc;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Optional;
  import java.util.function.Function;
  import java.util.regex.Pattern;
  import java.util.stream.Stream;
  
  import com.puppycrawl.tools.checkstyle.FileStatefulCheck;
  import com.puppycrawl.tools.checkstyle.api.DetailNode;
  import com.puppycrawl.tools.checkstyle.api.JavadocCommentsTokenTypes;
  import com.puppycrawl.tools.checkstyle.utils.CommonUtil;
  import com.puppycrawl.tools.checkstyle.utils.JavadocUtil;
  
  /**
   * <div>
   * Checks that
   * <a href="https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html#firstsentence">
   * Javadoc summary sentence</a> does not contain phrases that are not recommended to use.
   * Summaries that contain only the {@code {@inheritDoc}} tag are skipped.
   * Summaries that contain a non-empty {@code {@return}} are allowed.
   * Check also violate Javadoc that does not contain first sentence, though with {@code {@return}} a
   * period is not required as the Javadoc tool adds it.
   * </div>
   *
   * <p>
   * Note: For defining a summary, both the first sentence and the @summary tag approaches
   * are supported.
   * </p>
   *
   * @since 6.0
   */
  @FileStatefulCheck
  public class SummaryJavadocCheck extends AbstractJavadocCheck {
  
      /**
       * A key is pointing to the warning message text in "messages.properties"
       * file.
       */
      public static final String MSG_SUMMARY_FIRST_SENTENCE = "summary.first.sentence";
  
      /**
       * A key is pointing to the warning message text in "messages.properties"
       * file.
       */
      public static final String MSG_SUMMARY_JAVADOC = "summary.javaDoc";
  
      /**
       * A key is pointing to the warning message text in "messages.properties"
       * file.
       */
      public static final String MSG_SUMMARY_JAVADOC_MISSING = "summary.javaDoc.missing";
  
      /**
       * A key is pointing to the warning message text in "messages.properties" file.
       */
      public static final String MSG_SUMMARY_MISSING_PERIOD = "summary.javaDoc.missing.period";
  
      /**
       * This regexp is used to convert multiline javadoc to single-line without stars.
       */
      private static final Pattern JAVADOC_MULTILINE_TO_SINGLELINE_PATTERN =
              Pattern.compile("\n[ \\t]*(\\*)|^[ \\t]*(\\*)");
  
      /**
       * This regexp is used to remove html tags, whitespace, and asterisks from a string.
       */
      private static final Pattern HTML_ELEMENTS =
              Pattern.compile("<[^>]*>");
  
      /** Default period literal. */
      private static final String DEFAULT_PERIOD = ".";
  
      /**
       * Specify the regexp for forbidden summary fragments.
       */
      private Pattern forbiddenSummaryFragments = CommonUtil.createPattern("^$");
  
      /**
      * Specify the period symbol. Used to check the first sentence ends with a period. Periods that
      * are not followed by a whitespace character are ignored (eg. the period in v1.0). Because some
      * periods include whitespace built into the character, if this is set to a non-default value
      * any period will end the sentence, whether it is followed by whitespace or not.
      */
     private String period = DEFAULT_PERIOD;
 
     /**
      * Whether to validate untagged summary text in Javadoc.
      */
     private boolean shouldValidateUntaggedSummary = true;
 
     /**
      * Creates a new {@code SummaryJavadocCheck} instance.
      */
     public SummaryJavadocCheck() {
         // no code by default
     }
 
     /**
      * Setter to specify the regexp for forbidden summary fragments.
      *
      * @param pattern a pattern.
      * @since 6.0
      */
     public void setForbiddenSummaryFragments(Pattern pattern) {
         forbiddenSummaryFragments = pattern;
     }
 
     /**
      * Setter to specify the period symbol. Used to check the first sentence ends with a period.
      * Periods that are not followed by a whitespace character are ignored (eg. the period in v1.0).
      * Because some periods include whitespace built into the character, if this is set to a
      * non-default value any period will end the sentence, whether it is followed by whitespace or
      * not.
      *
      * @param period period's value.
      * @since 6.2
      */
     public void setPeriod(String period) {
         this.period = period;
     }
 
     @Override
     public int[] getDefaultJavadocTokens() {
         return new int[] {
             JavadocCommentsTokenTypes.JAVADOC_CONTENT,
             JavadocCommentsTokenTypes.SUMMARY_INLINE_TAG,
             JavadocCommentsTokenTypes.RETURN_INLINE_TAG,
         };
     }
 
     @Override
     public int[] getRequiredJavadocTokens() {
         return getAcceptableJavadocTokens();
     }
 
     @Override
     public void visitJavadocToken(DetailNode ast) {
         if (isSummaryTag(ast) && isDefinedFirst(ast.getParent())) {
             shouldValidateUntaggedSummary = false;
             validateSummaryTag(ast);
         }
         else if (isInlineReturnTag(ast)) {
             shouldValidateUntaggedSummary = false;
             validateInlineReturnTag(ast);
         }
     }
 
     @Override
     public void leaveJavadocToken(DetailNode ast) {
         if (ast.getType() == JavadocCommentsTokenTypes.JAVADOC_CONTENT) {
             if (shouldValidateUntaggedSummary && !startsWithInheritDoc(ast)) {
                 validateUntaggedSummary(ast);
             }
             shouldValidateUntaggedSummary = true;
         }
     }
 
     /**
      * Checks the javadoc text for {@code period} at end and forbidden fragments.
      *
      * @param ast the javadoc text node
      */
     private void validateUntaggedSummary(DetailNode ast) {
         final String summaryDoc = getSummarySentence(ast);
         if (summaryDoc.isEmpty()) {
             log(ast, MSG_SUMMARY_JAVADOC_MISSING);
         }
         else if (!period.isEmpty()) {
             if (summaryDoc.contains(period)) {
                 final Optional<String> firstSentence = getFirstSentence(ast, period);
 
                 if (firstSentence.isPresent()) {
                     if (containsForbiddenFragment(firstSentence.get())) {
                         log(ast, MSG_SUMMARY_JAVADOC);
                     }
                 }
                 else {
                     log(ast, MSG_SUMMARY_FIRST_SENTENCE);
                 }
             }
             else {
                 log(ast, MSG_SUMMARY_FIRST_SENTENCE);
             }
         }
     }
 
     /**
      * Whether the {@code {@summary}} tag is defined first in the javadoc.
      *
      * @param inlineTagNode node of type {@link JavadocCommentsTokenTypes#JAVADOC_INLINE_TAG}
      * @return {@code true} if the {@code {@summary}} tag is defined first in the javadoc
      */
     private static boolean isDefinedFirst(DetailNode inlineTagNode) {
         boolean isDefinedFirst = true;
         DetailNode currentAst = inlineTagNode.getPreviousSibling();
         while (currentAst != null && isDefinedFirst) {
             switch (currentAst.getType()) {
                 case JavadocCommentsTokenTypes.TEXT ->
                     isDefinedFirst = currentAst.getText().isBlank();
                 case JavadocCommentsTokenTypes.HTML_ELEMENT ->
                     isDefinedFirst = isHtmlTagWithoutText(currentAst);
                 case JavadocCommentsTokenTypes.LEADING_ASTERISK,
                      JavadocCommentsTokenTypes.LEADING_ASTERISKS,
                      JavadocCommentsTokenTypes.NEWLINE -> {
                     // Ignore formatting tokens
                 }
                 default -> isDefinedFirst = false;
             }
             currentAst = currentAst.getPreviousSibling();
         }
         return isDefinedFirst;
     }
 
     /**
      * Whether some text is present inside the HTML element or tag.
      *
      * @param node DetailNode of type {@link JavadocCommentsTokenTypes#HTML_ELEMENT}
      * @return {@code true} if some text is present inside the HTML element
      */
     public static boolean isHtmlTagWithoutText(DetailNode node) {
         boolean isEmpty = true;
         final DetailNode htmlContentToken =
              JavadocUtil.findFirstToken(node, JavadocCommentsTokenTypes.HTML_CONTENT);
 
         if (htmlContentToken != null) {
             final DetailNode child = htmlContentToken.getFirstChild();
             isEmpty = child.getType() == JavadocCommentsTokenTypes.HTML_ELEMENT
                         && isHtmlTagWithoutText(child);
         }
         return isEmpty;
     }
 
     /**
      * Checks if the given node is an inline summary tag.
      *
      * @param javadocInlineTag node
      * @return {@code true} if inline tag is of
      *       type {@link JavadocCommentsTokenTypes#SUMMARY_INLINE_TAG}
      */
     private static boolean isSummaryTag(DetailNode javadocInlineTag) {
         return javadocInlineTag.getType() == JavadocCommentsTokenTypes.SUMMARY_INLINE_TAG;
     }
 
     /**
      * Checks if the given node is an inline return node.
      *
      * @param javadocInlineTag node
      * @return {@code true} if inline tag is of
      *       type {@link JavadocCommentsTokenTypes#RETURN_INLINE_TAG}
      */
     private static boolean isInlineReturnTag(DetailNode javadocInlineTag) {
         return javadocInlineTag.getType() == JavadocCommentsTokenTypes.RETURN_INLINE_TAG;
     }
 
     /**
      * Checks the inline summary (if present) for {@code period} at end and forbidden fragments.
      *
      * @param inlineSummaryTag node of type {@link JavadocCommentsTokenTypes#SUMMARY_INLINE_TAG}
      */
     private void validateSummaryTag(DetailNode inlineSummaryTag) {
         final DetailNode descriptionNode = JavadocUtil.findFirstToken(
                 inlineSummaryTag, JavadocCommentsTokenTypes.DESCRIPTION);
         final String inlineSummary = getContentOfInlineCustomTag(descriptionNode);
         final String summaryVisible = getVisibleContent(inlineSummary);
         if (summaryVisible.isEmpty()) {
             log(inlineSummaryTag, MSG_SUMMARY_JAVADOC_MISSING);
         }
         else if (!period.isEmpty()) {
             final boolean isPeriodNotAtEnd =
                     summaryVisible.lastIndexOf(period) != summaryVisible.length() - 1;
             if (isPeriodNotAtEnd) {
                 log(inlineSummaryTag, MSG_SUMMARY_MISSING_PERIOD);
             }
             else if (containsForbiddenFragment(inlineSummary)) {
                 log(inlineSummaryTag, MSG_SUMMARY_JAVADOC);
             }
         }
     }
 
     /**
      * Checks the inline return for forbidden fragments.
      *
      * @param inlineReturnTag node of type {@link JavadocCommentsTokenTypes#RETURN_INLINE_TAG}
      */
     private void validateInlineReturnTag(DetailNode inlineReturnTag) {
         final DetailNode descriptionNode = JavadocUtil.findFirstToken(
                 inlineReturnTag, JavadocCommentsTokenTypes.DESCRIPTION);
         final String inlineReturn = getContentOfInlineCustomTag(descriptionNode);
         final String returnVisible = getVisibleContent(inlineReturn);
         if (returnVisible.isEmpty()) {
             log(inlineReturnTag, MSG_SUMMARY_JAVADOC_MISSING);
         }
         else if (containsForbiddenFragment(prependJavadocToolWord(inlineReturn))) {
             log(inlineReturnTag, MSG_SUMMARY_JAVADOC);
         }
     }
 
     /**
      * Gets the content of inline custom tag.
      *
      * @param descriptionNode node of type {@link JavadocCommentsTokenTypes#DESCRIPTION}
      * @return String consisting of the content of inline custom tag.
      */
     public static String getContentOfInlineCustomTag(DetailNode descriptionNode) {
         final StringBuilder customTagContent = new StringBuilder(256);
         DetailNode curNode = descriptionNode;
         while (curNode != null) {
             if (curNode.getFirstChild() == null
                 && !isLeadingAsterisk(curNode)) {
                 customTagContent.append(curNode.getText());
             }
 
             DetailNode toVisit = curNode.getFirstChild();
             while (curNode != descriptionNode && toVisit == null) {
                 toVisit = curNode.getNextSibling();
                 curNode = curNode.getParent();
             }
 
             curNode = toVisit;
         }
         return customTagContent.toString();
     }
 
     /**
      * Checks whether the given node is a leading asterisk.
      *
      * @param node the node to check
      * @return true if the node is a leading asterisk
      */
     private static boolean isLeadingAsterisk(DetailNode node) {
         return node.getType() == JavadocCommentsTokenTypes.LEADING_ASTERISK
                 || node.getType() == JavadocCommentsTokenTypes.LEADING_ASTERISKS;
     }
 
     /**
      * Gets the string that is visible to user in javadoc.
      *
      * @param summary entire content of summary javadoc.
      * @return string that is visible to user in javadoc.
      */
     private static String getVisibleContent(String summary) {
         final String visibleSummary = HTML_ELEMENTS.matcher(summary).replaceAll("");
         return visibleSummary.trim();
     }
 
     /**
      * Tests if first sentence contains forbidden summary fragment.
      *
      * @param firstSentence string with first sentence.
      * @return {@code true} if first sentence contains forbidden summary fragment.
      */
     private boolean containsForbiddenFragment(String firstSentence) {
         final String javadocText = JAVADOC_MULTILINE_TO_SINGLELINE_PATTERN
                 .matcher(firstSentence).replaceAll(" ");
         return forbiddenSummaryFragments.matcher(trimExcessWhitespaces(javadocText)).find();
     }
 
     /**
      * Prepends the word "Returns" to the given inline {@code {@return}} tag content,
      * since Javadoc renders {@code {@return ...}} as "Returns ..." in the method summary.
      *
      * @param inlineReturn String consisting of the content of inline {@code {@return}} tag
      * @return the inline return content prefixed with "Returns "
      */
     private static String prependJavadocToolWord(String inlineReturn) {
         return "Returns " + inlineReturn;
     }
 
     /**
      * Trims the given {@code text} of duplicate whitespaces.
      *
      * @param text the text to transform.
      * @return the finalized form of the text.
      */
     private static String trimExcessWhitespaces(String text) {
         final StringBuilder result = new StringBuilder(256);
         boolean previousWhitespace = true;
 
         for (int index = 0; index < text.length(); index++) {
             final char letter = text.charAt(index);
             final char print;
             if (Character.isWhitespace(letter)) {
                 if (previousWhitespace) {
                     continue;
                 }
 
                 previousWhitespace = true;
                 print = ' ';
             }
             else {
                 previousWhitespace = false;
                 print = letter;
             }
 
             result.append(print);
         }
 
         return result.toString();
     }
 
     /**
      * Checks if the node starts with an {&#64;inheritDoc}.
      *
      * @param root the root node to examine.
      * @return {@code true} if the javadoc starts with an {&#64;inheritDoc}.
      */
     private static boolean startsWithInheritDoc(DetailNode root) {
         boolean found = false;
         DetailNode node = root.getFirstChild();
 
         while (node != null) {
             if (node.getType() == JavadocCommentsTokenTypes.JAVADOC_INLINE_TAG
                     && node.getFirstChild().getType()
                             == JavadocCommentsTokenTypes.INHERIT_DOC_INLINE_TAG) {
                 found = true;
             }
             if ((node.getType() == JavadocCommentsTokenTypes.TEXT
                     || node.getType() == JavadocCommentsTokenTypes.HTML_ELEMENT)
                     && !CommonUtil.isBlank(node.getText())) {
                 break;
             }
             node = node.getNextSibling();
         }
 
         return found;
     }
 
     /**
      * Finds and returns summary sentence.
      *
      * @param ast javadoc root node.
      * @return violation string.
      */
     private static String getSummarySentence(DetailNode ast) {
         final StringBuilder result = new StringBuilder(256);
         DetailNode node = ast.getFirstChild();
         while (node != null) {
             if (node.getType() == JavadocCommentsTokenTypes.TEXT) {
                 result.append(node.getText());
             }
             else {
                 final String summary = result.toString();
                 if (CommonUtil.isBlank(summary)
                         && node.getType() == JavadocCommentsTokenTypes.HTML_ELEMENT) {
                     final DetailNode htmlContentToken = JavadocUtil.findFirstToken(
                             node, JavadocCommentsTokenTypes.HTML_CONTENT);
                     result.append(getStringInsideHtmlTag(summary, htmlContentToken));
                 }
             }
             node = node.getNextSibling();
         }
         return result.toString().trim();
     }
 
     /**
      * Get concatenated string within text of html tags.
      *
      * @param result javadoc string
      * @param detailNode htmlContent node
      * @return java doc tag content appended in result
      */
     private static String getStringInsideHtmlTag(String result, DetailNode detailNode) {
         final StringBuilder contents = new StringBuilder(result);
         if (detailNode != null) {
             DetailNode tempNode = detailNode.getFirstChild();
             while (tempNode != null) {
                 if (tempNode.getType() == JavadocCommentsTokenTypes.TEXT) {
                     contents.append(tempNode.getText());
                 }
                 else {
                     final DetailNode htmlContentToken = JavadocUtil.findFirstToken(
                             tempNode, JavadocCommentsTokenTypes.HTML_CONTENT);
                     contents.append(getStringInsideHtmlTag("", htmlContentToken));
                 }
                 tempNode = tempNode.getNextSibling();
             }
         }
         return contents.toString();
     }
 
     /**
      * Finds the first sentence.
      *
      * @param ast The Javadoc root node.
      * @param period The configured period symbol.
      * @return An Optional containing the first sentence
      *     up to and excluding the period, or an empty
      *     Optional if no ending was found.
      */
     private static Optional<String> getFirstSentence(DetailNode ast, String period) {
         final List<String> sentenceParts = new ArrayList<>();
         Optional<String> result = Optional.empty();
         for (String text : (Iterable<String>) streamTextParts(ast)::iterator) {
             final Optional<String> sentenceEnding = findSentenceEnding(text, period);
 
             if (sentenceEnding.isPresent()) {
                 sentenceParts.add(sentenceEnding.get());
                 result = Optional.of(String.join("", sentenceParts));
                 break;
             }
             sentenceParts.add(text);
         }
         return result;
     }
 
     /**
      * Streams through all the text under the given node.
      *
      * @param node The Javadoc node to examine.
      * @return All the text in all nodes that have no child nodes.
      */
     private static Stream<String> streamTextParts(DetailNode node) {
         final Stream<String> result;
         if (node.getFirstChild() == null) {
             result = Stream.of(node.getText());
         }
         else {
             final List<Stream<String>> childStreams = new ArrayList<>();
             DetailNode child = node.getFirstChild();
             while (child != null) {
                 childStreams.add(streamTextParts(child));
                 child = child.getNextSibling();
             }
             result = childStreams.stream().flatMap(Function.identity());
         }
         return result;
     }
 
     /**
      * Finds the end of a sentence. The end of sentence detection here could be replaced in the
      * future by Java's built-in BreakIterator class.
      *
      * @param text The string to search.
      * @param period The period character to find.
      * @return An Optional containing the string up to and excluding the period,
      *     or empty Optional if no ending was found.
      */
     private static Optional<String> findSentenceEnding(String text, String period) {
         int periodIndex = text.indexOf(period);
         Optional<String> result = Optional.empty();
         while (periodIndex >= 0) {
             final int afterPeriodIndex = periodIndex + period.length();
 
             // Handle western period separately as it is only the end of a sentence if followed
             // by whitespace. Other period characters often include whitespace in the character.
             if (!DEFAULT_PERIOD.equals(period)
                 || afterPeriodIndex >= text.length()
                 || Character.isWhitespace(text.charAt(afterPeriodIndex))) {
                 final String resultStr = text.substring(0, periodIndex);
                 result = Optional.of(resultStr);
                 break;
             }
             periodIndex = text.indexOf(period, afterPeriodIndex);
         }
         return result;
     }
 
 }