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.Objects;
  import java.util.Optional;
  
  /**
   * Wraps a fully qualified (and resolved) code reference used in javadoc tags {@code see}, {@code link} and
   * {@code linkplain}. Similar to {@link JavadocReference} but can distinguish between package names and class names. The
   * package name is always set for a resolved reference (except for references to modules). The member is always the
   * normalized form containing only fully qualified type names (without argument names), separated by {@code ,} without
   * any whitespace characters. Also the member type is always resolved to one of {@link MemberType} (in case the
   * reference contains a member part).
   */
  public class FullyQualifiedJavadocReference
      extends JavadocReference
  {
  
      /** if false, points to a class/package which is part of the current classloader (and not any of its parents) */
      private final boolean isExternal;
  
      private final Optional<String> packageName;
  
      private final Optional<MemberType> memberType;
  
      /** The type of the member part of the reference. */
      public enum MemberType
      {
          FIELD, METHOD, CONSTRUCTOR
      }
  
      public FullyQualifiedJavadocReference( String packageName, boolean isExternal )
      {
          this( packageName, Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(), isExternal );
      }
  
      public FullyQualifiedJavadocReference( String packageName, Optional<String> label, boolean isExternal )
      {
          this( packageName, Optional.empty(), Optional.empty(), Optional.empty(), label, isExternal );
      }
  
      public FullyQualifiedJavadocReference( String packageName, String className, boolean isExternal )
      {
          this( packageName, Optional.of( className ), Optional.empty(), Optional.empty(), Optional.empty(),
                isExternal );
      }
  
      public FullyQualifiedJavadocReference( String packageName, String className, String member, MemberType memberType,
                                             boolean isExternal )
      {
          this( packageName, Optional.of( className ), Optional.of( member ), Optional.of( memberType ),
                Optional.empty(), isExternal );
      }
  
      public FullyQualifiedJavadocReference( String packageName, Optional<String> className, Optional<String> member,
                                             Optional<MemberType> memberType, Optional<String> label, boolean isExternal )
      {
          this( Optional.empty(), Optional.of( packageName ), className, member, memberType, label, isExternal );
      }
  
      public FullyQualifiedJavadocReference( Optional<String> moduleName, Optional<String> packageName,
                                             Optional<String> className, Optional<String> member,
                                             Optional<MemberType> memberType, Optional<String> label,
                                             boolean isExternal )
      {
          super( moduleName, className, member, label );
          this.packageName = packageName;
          this.isExternal = isExternal;
          if ( !moduleName.isPresent() && !packageName.isPresent() )
          {
              throw new IllegalArgumentException( "At least one of module name or package name needs to be set" );
          }
          if ( member.isPresent() )
          {
              if ( !memberType.isPresent() )
              {
                  throw new IllegalArgumentException( "When member is set, also the member type needs to be set" );
              }
              if ( member.get().matches( ".*\\s.*" ) )
              {
                  throw new IllegalArgumentException( "member must not contain any whitespace characters!" );
             }
         }
         this.memberType = memberType;
     }
 
     /**
      * 
      * @return {@code true} in case this class/package is part of another classloader
      */
     public boolean isExternal()
     {
         return isExternal;
     }
 
     /** @return the package name of the referenced class */
     public Optional<String> getPackageName()
     {
         return packageName;
     }
 
     /**
      * @return the simple class name of the referenced class, may be prefixed by the declaring class names, separated by
      *         '.' (for inner classes)
      */
     public Optional<String> getClassName()
     {
         return getPackageNameClassName();
     }
 
     /** @return the type of the member. Only empty if no member is set. */
     public Optional<MemberType> getMemberType()
     {
         return memberType;
     }
 
     public Optional<String> getFullyQualifiedClassName()
     {
         if ( getClassName().isPresent() && getPackageName().isPresent() )
         {
             return Optional.of( getPackageName().get() + "." + getClassName().get() );
         }
         else
         {
             return Optional.empty();
         }
     }
 
     @Override
     public String toString()
     {
         return "FullyQualifiedJavadocReference [moduleName=" + getModuleName() + ", packageName=" + packageName
             + ", className=" + getClassName() + ", memberType=" + memberType + ", member=" + getMember() + ", label="
             + getLabel() + ", isExternal=" + isExternal + "]";
     }
 
     @Override
     public int hashCode()
     {
         final int prime = 31;
         int result = super.hashCode();
         result = prime * result + Objects.hash( memberType, packageName, isExternal );
         return result;
     }
 
     @Override
     public boolean equals( Object obj )
     {
         if ( this == obj )
         {
             return true;
         }
         if ( !super.equals( obj ) )
         {
             return false;
         }
         if ( getClass() != obj.getClass() )
         {
             return false;
         }
         FullyQualifiedJavadocReference other = (FullyQualifiedJavadocReference) obj;
         return Objects.equals( memberType, other.memberType ) && Objects.equals( packageName, other.packageName )
                         && isExternal == other.isExternal;
     }
 
 }