/*
    * 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.
   */
  package org.apache.maven.plugins.assembly.io;
  
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  /**
   * Default Message Holder.
   *
   */
  class DefaultMessageHolder implements MessageHolder {
  
      private List<Message> messages = new ArrayList<>();
  
      private Message currentMessage;
  
      private int defaultMessageLevel = MessageLevels.LEVEL_INFO;
  
      private boolean[] messageLevelStates;
  
      private MessageSink onDemandSink;
  
      /**
       * Create instance.
       */
      DefaultMessageHolder() {
          this.messageLevelStates = MessageLevels.getLevelStates(MessageLevels.LEVEL_INFO);
      }
  
      /** {@inheritDoc} */
      public MessageHolder addMessage(CharSequence messagePart, Throwable error) {
          return addMessage(defaultMessageLevel, messagePart, error);
      }
  
      /**
       * @param level Level.
       * @param messagePart Message part.
       * @param error {@link Throwable}
       * @return {@link MessageHolder}
       */
      MessageHolder addMessage(int level, CharSequence messagePart, Throwable error) {
          newMessage(level);
          append(messagePart.toString());
          append(error);
  
          return this;
      }
  
      /** {@inheritDoc} */
      public MessageHolder addMessage(CharSequence messagePart) {
          return addMessage(defaultMessageLevel, messagePart);
      }
  
      /**
       * @param level level.
       * @param messagePart message part.
       * @return {@link MessageHolder}
       */
      protected MessageHolder addMessage(int level, CharSequence messagePart) {
          newMessage(level);
          append(messagePart.toString());
  
          return this;
      }
  
      /** {@inheritDoc} */
      public MessageHolder addMessage(Throwable error) {
          return addMessage(defaultMessageLevel, error);
      }
  
      /**
       * @param level level.
       * @param error {@link Throwable}
       * @return {@link MessageHolder}
       */
      protected MessageHolder addMessage(int level, Throwable error) {
          newMessage(level);
          append(error);
  
         return this;
     }
 
     /** {@inheritDoc} */
     public MessageHolder append(CharSequence messagePart) {
         if (currentMessage == null) {
             newMessage();
         }
 
         currentMessage.append(messagePart.toString());
 
         return this;
     }
 
     /** {@inheritDoc} */
     public MessageHolder append(Throwable error) {
         if (currentMessage == null) {
             newMessage();
         }
 
         currentMessage.setError(error);
 
         return this;
     }
 
     /** {@inheritDoc} */
     public boolean isEmpty() {
         return messages.isEmpty();
     }
 
     /** {@inheritDoc} */
     public MessageHolder newMessage() {
         newMessage(defaultMessageLevel);
 
         return this;
     }
 
     /**
      * @param messageLevel message level.
      */
     protected void newMessage(int messageLevel) {
         if (onDemandSink != null && currentMessage != null) {
             renderTo(currentMessage, onDemandSink);
         }
 
         currentMessage = new Message(messageLevel, onDemandSink);
         messages.add(currentMessage);
     }
 
     /** {@inheritDoc} */
     public String render() {
         StringBuilder buffer = new StringBuilder();
 
         int counter = 1;
         for (Iterator<Message> it = messages.iterator(); it.hasNext(); ) {
             Message message = it.next();
 
             int ml = message.getMessageLevel();
 
             if (ml >= messageLevelStates.length || ml < 0) {
                 ml = MessageLevels.LEVEL_DEBUG;
             }
 
             if (!messageLevelStates[ml]) {
                 continue;
             }
 
             CharSequence content = message.render();
             String label = MessageLevels.getLevelLabel(message.getMessageLevel());
 
             if (content.length() > label.length() + 3) {
                 buffer.append('[').append(counter++).append("] ");
                 buffer.append(content);
 
                 if (it.hasNext()) {
                     buffer.append("\n\n");
                 }
             }
         }
 
         return buffer.toString();
     }
 
     /** {@inheritDoc} */
     public int size() {
         return messages.size();
     }
 
     private static final class Message {
         private StringBuffer message = new StringBuffer();
 
         private Throwable error;
 
         private final int messageLevel;
 
         private final MessageSink onDemandSink;
 
         Message(int messageLevel, MessageSink onDemandSink) {
             this.messageLevel = messageLevel;
 
             this.onDemandSink = onDemandSink;
         }
 
         public Message setError(Throwable pError) {
             this.error = pError;
             return this;
         }
 
         public Message append(CharSequence pMessage) {
             this.message.append(pMessage.toString());
             return this;
         }
 
         /**
          * @return message level.
          */
         public int getMessageLevel() {
             return messageLevel;
         }
 
         /**
          * @return Sequence.
          */
         public CharSequence render() {
             StringBuffer buffer = new StringBuffer();
 
             if (onDemandSink == null) {
                 buffer.append('[')
                         .append(MessageLevels.getLevelLabel(messageLevel))
                         .append("] ");
             }
             if (message != null && message.length() > 0) {
                 buffer.append(message);
 
                 if (error != null) {
                     buffer.append('\n');
                 }
             }
 
             if (error != null) {
                 buffer.append("Error:\n");
 
                 StringWriter sw = new StringWriter();
                 PrintWriter pw = new PrintWriter(sw);
                 error.printStackTrace(pw);
 
                 buffer.append(sw);
             }
 
             return buffer;
         }
     }
 
     /** {@inheritDoc} */
     public MessageHolder addDebugMessage(CharSequence messagePart, Throwable error) {
         return addMessage(MessageLevels.LEVEL_DEBUG, messagePart, error);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addDebugMessage(CharSequence messagePart) {
         return addMessage(MessageLevels.LEVEL_DEBUG, messagePart);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addDebugMessage(Throwable error) {
         return addMessage(MessageLevels.LEVEL_DEBUG, error);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addErrorMessage(CharSequence messagePart, Throwable error) {
         return addMessage(MessageLevels.LEVEL_ERROR, messagePart, error);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addErrorMessage(CharSequence messagePart) {
         return addMessage(MessageLevels.LEVEL_ERROR, messagePart);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addErrorMessage(Throwable error) {
         return addMessage(MessageLevels.LEVEL_ERROR, error);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addInfoMessage(CharSequence messagePart, Throwable error) {
         return addMessage(MessageLevels.LEVEL_INFO, messagePart, error);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addInfoMessage(CharSequence messagePart) {
         return addMessage(MessageLevels.LEVEL_INFO, messagePart);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addInfoMessage(Throwable error) {
         return addMessage(MessageLevels.LEVEL_INFO, error);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addSevereMessage(CharSequence messagePart, Throwable error) {
         return addMessage(MessageLevels.LEVEL_SEVERE, messagePart, error);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addSevereMessage(CharSequence messagePart) {
         return addMessage(MessageLevels.LEVEL_SEVERE, messagePart);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addSevereMessage(Throwable error) {
         return addMessage(MessageLevels.LEVEL_SEVERE, error);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addWarningMessage(CharSequence messagePart, Throwable error) {
         return addMessage(MessageLevels.LEVEL_WARNING, messagePart, error);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addWarningMessage(CharSequence messagePart) {
         return addMessage(MessageLevels.LEVEL_WARNING, messagePart);
     }
 
     /** {@inheritDoc} */
     public MessageHolder addWarningMessage(Throwable error) {
         return addMessage(MessageLevels.LEVEL_WARNING, error);
     }
 
     /** {@inheritDoc} */
     public int countDebugMessages() {
         return countMessagesOfType(MessageLevels.LEVEL_DEBUG);
     }
 
     /** {@inheritDoc} */
     public int countErrorMessages() {
         return countMessagesOfType(MessageLevels.LEVEL_ERROR);
     }
 
     /** {@inheritDoc} */
     public int countInfoMessages() {
         return countMessagesOfType(MessageLevels.LEVEL_INFO);
     }
 
     /** {@inheritDoc} */
     public int countMessages() {
         return size();
     }
 
     /** {@inheritDoc} */
     public int countSevereMessages() {
         return countMessagesOfType(MessageLevels.LEVEL_SEVERE);
     }
 
     /** {@inheritDoc} */
     public int countWarningMessages() {
         return countMessagesOfType(MessageLevels.LEVEL_WARNING);
     }
 
     /**
      * @param messageLevel leve.
      * @return number of messages.
      */
     private int countMessagesOfType(int messageLevel) {
         int count = 0;
 
         for (Message message : messages) {
             if (messageLevel == message.getMessageLevel()) {
                 count++;
             }
         }
 
         return count;
     }
 
     /** {@inheritDoc} */
     public boolean isDebugEnabled() {
         return messageLevelStates[MessageLevels.LEVEL_DEBUG];
     }
 
     /** {@inheritDoc} */
     public boolean isErrorEnabled() {
         return messageLevelStates[MessageLevels.LEVEL_ERROR];
     }
 
     /** {@inheritDoc} */
     public boolean isInfoEnabled() {
         return messageLevelStates[MessageLevels.LEVEL_INFO];
     }
 
     /** {@inheritDoc} */
     public boolean isSevereEnabled() {
         return messageLevelStates[MessageLevels.LEVEL_SEVERE];
     }
 
     /** {@inheritDoc} */
     public boolean isWarningEnabled() {
         return messageLevelStates[MessageLevels.LEVEL_WARNING];
     }
 
     /** {@inheritDoc} */
     public MessageHolder newDebugMessage() {
         if (isDebugEnabled()) {
             newMessage(MessageLevels.LEVEL_DEBUG);
         }
 
         return this;
     }
 
     /** {@inheritDoc} */
     public MessageHolder newErrorMessage() {
         if (isErrorEnabled()) {
             newMessage(MessageLevels.LEVEL_ERROR);
         }
 
         return this;
     }
 
     /** {@inheritDoc} */
     public MessageHolder newInfoMessage() {
         if (isInfoEnabled()) {
             newMessage(MessageLevels.LEVEL_INFO);
         }
 
         return this;
     }
 
     /** {@inheritDoc} */
     public MessageHolder newSevereMessage() {
         if (isSevereEnabled()) {
             newMessage(MessageLevels.LEVEL_SEVERE);
         }
 
         return this;
     }
 
     /** {@inheritDoc} */
     public MessageHolder newWarningMessage() {
         if (isWarningEnabled()) {
             newMessage(MessageLevels.LEVEL_WARNING);
         }
 
         return this;
     }
 
     /** {@inheritDoc} */
     public void setDebugEnabled(boolean enabled) {
         messageLevelStates[MessageLevels.LEVEL_DEBUG] = enabled;
     }
 
     /** {@inheritDoc} */
     public void setErrorEnabled(boolean enabled) {
         messageLevelStates[MessageLevels.LEVEL_ERROR] = enabled;
     }
 
     /** {@inheritDoc} */
     public void setInfoEnabled(boolean enabled) {
         messageLevelStates[MessageLevels.LEVEL_INFO] = enabled;
     }
 
     /** {@inheritDoc} */
     public void setSevereEnabled(boolean enabled) {
         messageLevelStates[MessageLevels.LEVEL_SEVERE] = enabled;
     }
 
     /** {@inheritDoc} */
     public void setWarningEnabled(boolean enabled) {
         messageLevelStates[MessageLevels.LEVEL_WARNING] = enabled;
     }
 
     /** {@inheritDoc} */
     public void flush() {
         if (onDemandSink != null && currentMessage != null) {
             renderTo(currentMessage, onDemandSink);
             currentMessage = null;
         }
     }
 
     /** {@inheritDoc} */
     public void render(MessageSink sink) {
         for (Message message : messages) {
             renderTo(message, sink);
         }
     }
 
     /**
      * @param message {@link Message}
      * @param sink {@link MessageSink}
      */
     protected void renderTo(Message message, MessageSink sink) {
         switch (message.getMessageLevel()) {
             case (MessageLevels.LEVEL_SEVERE):
                 sink.severe(message.render().toString());
                 break;
 
             case (MessageLevels.LEVEL_ERROR):
                 sink.error(message.render().toString());
                 break;
 
             case (MessageLevels.LEVEL_WARNING):
                 sink.warning(message.render().toString());
                 break;
 
             case (MessageLevels.LEVEL_INFO):
                 sink.info(message.render().toString());
                 break;
 
             default:
                 sink.debug(message.render().toString());
         }
     }
 }