package org.apache.maven.tools.plugin.javadoc;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.List;
  import java.util.StringTokenizer;
  
  import javax.swing.text.AttributeSet;
  import javax.swing.text.MutableAttributeSet;
  import javax.swing.text.SimpleAttributeSet;
  
  import com.sun.javadoc.Tag;
  import com.sun.tools.doclets.Taglet;
  
  /**
   * Abstract <code>Taglet</code> for <a href="http://maven.codehaus.org/"/>Maven</a> Mojo annotations.
   * <br/>
   * A Mojo annotation is defined like the following:
   * <pre>
   * &#64;annotation &lt;annotationValue&gt; &lt;parameterName="parameterValue"&gt;
   * </pre>
   *
   * @see <a href="package-summary.html#package_description">package-summary.html</a>
   *
   * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
   * @version $Id: AbstractMojoTaglet.html 1024032 2018-01-19 18:16:30Z hboutemy $
   */
  public abstract class AbstractMojoTaglet
      implements Taglet
  {
      /** {@inheritDoc} */
      public String toString( Tag tag )
      {
          if ( tag == null )
          {
              return null;
          }
  
          String tagValue = getTagValue( tag );
          MutableAttributeSet tagAttributes = getTagAttributes( tag );
  
          StringBuilder sb = new StringBuilder();
  
          appendTag( sb, tag, tagAttributes, tagValue );
  
          return sb.toString();
      }
  
      /** {@inheritDoc} */
      public String toString( Tag[] tags )
      {
          if ( tags.length == 0 )
          {
              return null;
          }
  
          StringBuilder sb = new StringBuilder();
          for ( int i = 0; i < tags.length; i++ )
          {
              String tagValue = getTagValue( tags[i] );
              MutableAttributeSet tagAttributes = getTagAttributes( tags[i] );
  
              appendTag( sb, tags[i], tagAttributes, tagValue );
          }
  
          return sb.toString();
      }
  
      /**
       * @return the header, i.e. the message, to display
       */
      public abstract String getHeader();
  
      /**
       * @return the given annotation value, or <code>null</code> if the given Mojo annotation/tag does't allow
       * annotation value.
       * <br/>
       * <b>Note</b>: the value could be a pattern value, i.e.: <code>*</code> for every values, <code>a|b|c</code>
      * for <code>a OR b OR c</code>.
      */
     public abstract String getAllowedValue();
 
     /**
      * @return an array of the allowed parameter names for the given Mojo annotation/tag, or <code>null</code>
      * if the annotation/tag doesn't allow parameter.
      */
     public abstract String[] getAllowedParameterNames();
 
     /**
      * @return <code>true</code> if taglet has annotation value, <code>false</code> otherwise.
      * @see #getAllowedValue()
      */
     public boolean hasAnnotationValue()
     {
         return getAllowedValue() != null;
     }
 
     /**
      * @return <code>true</code> if taglet has parameters, <code>false</code> otherwise.
      * @see #getAllowedParameterNames()
      */
     public boolean hasAnnotationParameters()
     {
         return getAllowedParameterNames() != null;
     }
 
     /**
      * @param tag not null.
      * @return a not null String or <code>null</code> if no annotation value was found.
      */
     private String getTagValue( Tag tag )
     {
         if ( tag == null )
         {
             throw new IllegalArgumentException( "tag should be not null" );
         }
 
         String text = tag.text();
         if ( isEmpty( text ) )
         {
             // using pattern: @annotation
             return null;
         }
 
         String tagValue = null;
         StringTokenizer token = new StringTokenizer( text, " " );
         while ( token.hasMoreTokens() )
         {
             String nextToken = token.nextToken();
 
             if ( nextToken.indexOf( '=' ) == -1 )
             {
                 // using pattern: @annotation <annotationValue>
                 tagValue = nextToken;
             }
         }
 
         return tagValue;
     }
 
     /**
      * @param tag not null.
      * @return a not null MutableAttributeSet.
      */
     private MutableAttributeSet getTagAttributes( Tag tag )
     {
         if ( tag == null )
         {
             throw new IllegalArgumentException( "tag should be not null" );
         }
 
         String text = tag.text();
 
         StringTokenizer token = new StringTokenizer( text, " " );
         MutableAttributeSet tagAttributes = new SimpleAttributeSet();
         while ( token.hasMoreTokens() )
         {
             String nextToken = token.nextToken();
 
             if ( nextToken.indexOf( '=' ) == -1 )
             {
                 // using pattern: @annotation <annotationValue>
                 continue;
             }
 
             StringTokenizer token2 = new StringTokenizer( nextToken, "=" );
             if ( token2.countTokens() != 2 )
             {
                 System.err.println( "The annotation '" + tag.name() + "' has no name/value pairs parameter: "
                     + tag.name() + " " + text + " (" + tag.position().file() + ":" + tag.position().line() + ":"
                     + tag.position().column() + ")" );
                 tagAttributes.addAttribute( token2.nextToken(), "" );
                 continue;
             }
 
             String name = token2.nextToken();
             String value = token2.nextToken().replaceAll( "\"", "" );
 
             if ( getAllowedParameterNames() != null && !Arrays.asList( getAllowedParameterNames() ).contains( name ) )
             {
                 System.err.println( "The annotation '" + tag.name() + "' has wrong parameter name: " + tag.name() + " "
                     + text + " (" + tag.position().file() + ":" + tag.position().line() + ":" + tag.position().column()
                     + ")" );
             }
 
             tagAttributes.addAttribute( name, value );
         }
 
         return tagAttributes;
     }
 
     /**
      * Append a tag
      *
      * @param sb not null
      * @param tag not null
      * @param tagAttributes not null
      * @param tagValue not null
      */
     private void appendTag( StringBuilder sb, Tag tag, MutableAttributeSet tagAttributes, String tagValue )
     {
         if ( !hasAnnotationParameters() )
         {
             if ( tagAttributes.getAttributeCount() > 0 )
             {
                 System.err.println( "The annotation '@" + getName() + "' should have no attribute ("
                     + tag.position().file() + ":" + tag.position().line() + ":" + tag.position().column() + ")" );
             }
 
             if ( hasAnnotationValue() )
             {
                 sb.append( "<DT><B>" ).append( getHeader() ).append( ":</B></DT>" );
                 if ( isEveryValues( getAllowedValue() ) )
                 {
                     if ( isNotEmpty( tagValue ) )
                     {
                         sb.append( "<DD>" ).append( tagValue ).append( "</DD>" );
                     }
                     else
                     {
                         System.err.println( "The annotation '@" + getName() + "' is specified to have a value but "
                             + "no value is defined (" + tag.position().file() + ":" + tag.position().line() + ":"
                             + tag.position().column() + ")" );
                         sb.append( "<DD>" ).append( "NOT DEFINED" ).append( "</DD>" );
                     }
                 }
                 else
                 {
                     List<String> l = getOnlyValues( getAllowedValue() );
                     if ( isNotEmpty( tagValue ) )
                     {
                         if ( l.contains( tagValue ) )
                         {
                             sb.append( "<DD>" ).append( tagValue ).append( "</DD>" );
                         }
                         else
                         {
                             System.err.println( "The annotation '@" + getName() + "' is specified to be a value of "
                                 + l + " (" + tag.position().file() + ":" + tag.position().line() + ":"
                                 + tag.position().column() + ")" );
                             sb.append( "<DD>" ).append( tagValue ).append( "</DD>" );
                         }
                     }
                     else
                     {
                         sb.append( "<DD>" ).append( l.get( 0 ) ).append( "</DD>" );
                     }
                 }
             }
             else
             {
                 if ( isNotEmpty( tagValue ) )
                 {
                     System.err.println( "The annotation '@" + getName() + "' should have no value ("
                         + tag.position().file() + ":" + tag.position().line() + ":" + tag.position().column() + ")" );
                 }
                 sb.append( "<DT><B>" ).append( getHeader() ).append( "</B></DT>" );
                 sb.append( "<DD></DD>" );
             }
         }
         else
         {
             if ( hasAnnotationValue() )
             {
                 sb.append( "<DT><B>" ).append( getHeader() ).append( ":</B></DT>" );
                 if ( isEveryValues( getAllowedValue() ) )
                 {
                     if ( isNotEmpty( tagValue ) )
                     {
                         sb.append( "<DD>" ).append( tagValue );
                     }
                     else
                     {
                         System.err.println( "The annotation '@" + getName() + "' is specified to have a value but "
                             + "no value is defined (" + tag.position().file() + ":" + tag.position().line() + ":"
                             + tag.position().column() + ")" );
                         sb.append( "<DD>" ).append( "NOT DEFINED" );
                     }
                 }
                 else
                 {
                     List<String> l = getOnlyValues( getAllowedValue() );
                     if ( isNotEmpty( tagValue ) )
                     {
                         if ( l.contains( tagValue ) )
                         {
                             sb.append( "<DD>" ).append( tagValue );
                         }
                         else
                         {
                             System.err.println( "The annotation '@" + getName() + "' is specified to be a value in "
                                 + l + " (" + tag.position().file() + ":" + tag.position().line() + ":"
                                 + tag.position().column() + ")" );
                             sb.append( "<DD>" ).append( tagValue );
                         }
                     }
                     else
                     {
                         sb.append( "<DD>" ).append( l.get( 0 ) );
                     }
                 }
             }
             else
             {
                 if ( isNotEmpty( tagValue ) )
                 {
                     System.err.println( "The annotation '@" + getName() + "' should have no value ("
                         + tag.position().file() + ":" + tag.position().line() + ":" + tag.position().column() + ")" );
                 }
                 sb.append( "<DT><B>" ).append( getHeader() ).append( ":</B></DT>" );
                 sb.append( "<DD>" );
             }
 
             appendAnnotationParameters( sb, tagAttributes );
             sb.append( "</DD>" );
         }
     }
 
     /**
      * Append the annotation parameters as a definition list.
      *
      * @param sb not null
      * @param att not null
      */
     private static void appendAnnotationParameters( StringBuilder sb, MutableAttributeSet att )
     {
         sb.append( "<DL>" );
 
         Enumeration<?> names = att.getAttributeNames();
         while ( names.hasMoreElements() )
         {
             Object key = names.nextElement();
             Object value = att.getAttribute( key );
 
             if ( value instanceof AttributeSet )
             {
                 // ignored
             }
             else
             {
                 sb.append( "<DT><B>" ).append( key ).append( ":</B></DT>" );
                 sb.append( "<DD>" ).append( value ).append( "</DD>" );
             }
         }
 
         sb.append( "</DL>" );
     }
 
     /**
      * @param text not null
      * @return <code>true</code> if text contains <code>*</code>, <code>false</code> otherwise.
      */
     private static boolean isEveryValues( String text )
     {
         return text.trim().equals( "*" );
     }
 
     /**
      * Splits the provided text into a array, using pipe as the separator.
      *
      * @param text not null
      * @return a list of parsed Strings or <code>Collections.EMPTY_LIST</code>.
      * By convention, the default value is the first element.
      */
     private static List<String> getOnlyValues( String text )
     {
         if ( text.indexOf( '|' ) == -1 )
         {
             return Collections.emptyList();
         }
 
         List<String> l = new ArrayList<String>();
         StringTokenizer token = new StringTokenizer( text, "|" );
         while ( token.hasMoreTokens() )
         {
             l.add( token.nextToken() );
         }
 
         return l;
     }
 
     /**
      * <p>Checks if a String is non <code>null</code> and is
      * not empty (<code>length > 0</code>).</p>
      *
      * @param str the String to check
      * @return true if the String is non-null, and not length zero
      */
     private static boolean isNotEmpty( String str )
     {
         return ( str != null && str.length() > 0 );
     }
 
     /**
      * <p>Checks if a (trimmed) String is <code>null</code> or empty.</p>
      *
      * @param str the String to check
      * @return <code>true</code> if the String is <code>null</code>, or
      *  length zero once trimmed
      */
     private static boolean isEmpty( String str )
     {
         return ( str == null || str.trim().length() == 0 );
     }
 }