package com.atlassian.messagequeue;
   
   import com.atlassian.annotations.PublicApi;
   
   import javax.annotation.Nullable;
   import java.util.Objects;
   import java.util.Optional;
   
   import static java.util.Objects.requireNonNull;
  
  /**
   * Encapsulates information that is passed to {@link MessageRunnerService#addMessage(Message)}.
   *
   * <p>A {@code Message} contains a {@link MessageRunnerKey} which specifies a {@link com.atlassian.messagequeue.registry.MessageRunner}
   * with which the {@code Message} should be handled by.
   *
   * <p>A {@code Message} also contains an optional String payload that is passed to the execution of the corresponding
   * {@link com.atlassian.messagequeue.registry.MessageRunner}.
   *
   * @since 1.0
   */
  @PublicApi
  public final class Message {
      private final MessageRunnerKey runnerKey;
      @Nullable private final String payload;
  
      Message(MessageRunnerKey runnerKey, @Nullable String payload) {
          this.runnerKey = requireNonNull(runnerKey, "runnerKey");
          this.payload = payload;
  
          if (this.payload != null && this.payload.length() > MessageRunnerConstants.payloadMaxSize()) {
              throw new MessagePayloadSizeExceededException(runnerKey, MessageRunnerConstants.payloadMaxSize());
          }
  
          getFirstInvalidCodePoint(payload).ifPresent(codePoint -> {
              throw new InvalidMessagePayloadException(runnerKey, codePoint);
          });
      }
  
      /**
       * Returns the {@link MessageRunnerKey} which specifies a {@link com.atlassian.messagequeue.registry.MessageRunner}
       * with which this <tt>Message</tt> should be handled by.
       *
       * @return message runner key
       */
      public MessageRunnerKey getRunnerKey() {
          return runnerKey;
      }
  
      /**
       * @return Returns the message payload or {@link Optional#empty()} when no payload was specified in the construction of a <tt>Message</tt>
       * (or null was specified for construction).
       */
      public Optional<String> getPayload() {
          return Optional.ofNullable(payload);
      }
  
      /**
       * Message factory method
       *
       * @param runnerKey message runner key
       * @param payload message payload
       *
       * @return Message instance
       * @throws MessagePayloadSizeExceededException if payload exceeds {@link MessageRunnerConstants#payloadMaxSize()}.
       */
      public static Message create(MessageRunnerKey runnerKey, @Nullable String payload) {
          return new Message(runnerKey, payload);
      }
  
      private static Optional<Integer> getFirstInvalidCodePoint(@Nullable String payload) {
          if (payload == null) {
              return Optional.empty();
          }
  
          int codePoint;
          for (int i = 0; i < payload.length(); i++) {
              codePoint = Character.codePointAt(payload, i);
              if (!isValidCodePoint(codePoint)) {
                  return Optional.of(codePoint);
              }
          }
  
          return Optional.empty();
      }
  
      /**
       * For valid code point definitions also see https://www.w3.org/TR/REC-xml/#charsets
       */
      private static boolean isValidCodePoint(int codePoint) {
          return codePoint == 0x9 || codePoint == 0xA || codePoint == 0xD
                  || (0x20 <= codePoint && codePoint <= 0xD7FF)
                  || (0xE000 <= codePoint && codePoint <= 0xFFFD)
                  || (0x10000 <= codePoint && codePoint <= 0x10FFFF);
      }
  
      @Override
      public boolean equals(Object o) {
          if (this == o) {
             return true;
         }
         if (o == null || getClass() != o.getClass()) {
             return false;
         }
 
         final Message message = (Message) o;
 
         return Objects.equals(runnerKey, message.runnerKey) &&
                 Objects.equals(payload, message.payload);
     }
 
     @Override
     public int hashCode() {
         return Objects.hash(runnerKey, payload);
     }
 
     /**
      * Builder factory method
      * @param runnerKey message runner key
      * @return Message Builder
      */
     public static Builder builder(MessageRunnerKey runnerKey) {
         return new Builder(runnerKey);
     }
 
     /**
      * Message Builder
      */
     @PublicApi
     public static class Builder {
         private final MessageRunnerKey runnerKey;
         @Nullable private String payload;
 
         /**
          * @param runnerKey message runner key
          */
         Builder(MessageRunnerKey runnerKey) {
             this.runnerKey = requireNonNull(runnerKey, "runnerKey");
         }
 
         /**
          * @return a message instance
          */
         public Message build() {
             return new Message(runnerKey, payload);
         }
 
         /**
          * @param payload message payload
          * @return message
          */
         public Builder payload(@Nullable String payload) {
             this.payload = payload;
             return this;
         }
     }
 }