/****************************************************************
    * 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.james.mime4j.codec;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  
  final class QuotedPrintableEncoder {
      private static final byte TAB = 0x09;
      private static final byte SPACE = 0x20;
      private static final byte EQUALS = 0x3D;
      private static final byte CR = 0x0D;
      private static final byte LF = 0x0A;
      private static final byte QUOTED_PRINTABLE_LAST_PLAIN = 0x7E;
      private static final int QUOTED_PRINTABLE_MAX_LINE_LENGTH = 76;
      private static final int QUOTED_PRINTABLE_OCTETS_PER_ESCAPE = 3;
      private static final byte[] HEX_DIGITS = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  
      private final byte[] inBuffer;
      private final byte[] outBuffer;
      private final boolean binary;
      
      private boolean pendingSpace;
      private boolean pendingTab;
      private boolean pendingCR;
      private int nextSoftBreak;
      private int outputIndex;
      private OutputStream out;
      
      
      public QuotedPrintableEncoder(int bufferSize, boolean binary) {
          inBuffer = new byte[bufferSize];
          outBuffer = new byte[3*bufferSize];
          outputIndex = 0;
          nextSoftBreak = QUOTED_PRINTABLE_MAX_LINE_LENGTH + 1;
          out = null;
          this.binary = binary;
          pendingSpace = false;
          pendingTab = false;
          pendingCR = false;
      }
      
      void initEncoding(final OutputStream out) {
          this.out = out;
          pendingSpace = false;
          pendingTab = false;
          pendingCR = false;
          nextSoftBreak = QUOTED_PRINTABLE_MAX_LINE_LENGTH + 1;
      }
      
      void encodeChunk(byte[] buffer, int off, int len) throws IOException {
          for (int inputIndex = off; inputIndex < len + off; inputIndex++) {
              encode(buffer[inputIndex]);
          }
      }
      
      void completeEncoding() throws IOException {
          writePending();
          flushOutput();
      }
      
      public void encode(final InputStream in, final OutputStream out) throws IOException {
          initEncoding(out);
          int inputLength;
          while((inputLength = in.read(inBuffer)) > -1) {
              encodeChunk(inBuffer, 0, inputLength);
          }
          completeEncoding();
      }
      
      private void writePending() throws IOException {
          if (pendingSpace) {
              plain(SPACE);
          } else if (pendingTab) {
              plain(TAB);
          } else if (pendingCR) {
              plain(CR);
          }
          clearPending();
      }
      
     private void clearPending() throws IOException {
         pendingSpace  = false;
         pendingTab = false;
         pendingCR = false;
     }
     
     private void encode(byte next) throws IOException {
         if (next == LF) {
             if (binary) {
                 writePending();
                 escape(next);
             } else {
                 if (pendingCR) {
                     // Expect either space or tab pending 
                     // but not both
                     if (pendingSpace) {
                         escape(SPACE);
                     } else if (pendingTab) {
                         escape(TAB);
                     }
                     lineBreak();
                     clearPending();
                 } else {
                     writePending();
                     plain(next);
                 }
             }
         } else if (next == CR) {
             if (binary)  {
                 escape(next);
             } else {
                 pendingCR = true;
             }
         } else {
             writePending();
             if (next == SPACE) {
                 if (binary)  {
                     escape(next);
                 } else {
                     pendingSpace = true;
                 }
             } else if (next == TAB) {
                 if (binary)  {
                     escape(next);
                 } else {
                     pendingTab = true;
                 }
             } else if (next < SPACE) {
                 escape(next);
             } else if (next > QUOTED_PRINTABLE_LAST_PLAIN) {
                 escape(next);
             } else if (next == EQUALS) {
                 escape(next);
             } else {
                 plain(next);
             }
         }
     }
     
     private void plain(byte next) throws IOException {
         if (--nextSoftBreak <= 1) {
             softBreak();
         }
         write(next);
     }
     
     private void escape(byte next) throws IOException {
         if (--nextSoftBreak <= QUOTED_PRINTABLE_OCTETS_PER_ESCAPE) {
             softBreak();
         }
         
         int nextUnsigned = next & 0xff;
         
         write(EQUALS);
         --nextSoftBreak;
         write(HEX_DIGITS[nextUnsigned >> 4]);
         --nextSoftBreak;
         write(HEX_DIGITS[nextUnsigned % 0x10]);
     }
     
     private void write(byte next) throws IOException {
         outBuffer[outputIndex++] = next;
         if (outputIndex >= outBuffer.length) {
             flushOutput();
         }
     }
     
     private void softBreak() throws IOException {
         write(EQUALS);
         lineBreak();
     }
 
     private void lineBreak() throws IOException {
         write(CR);
         write(LF);
         nextSoftBreak = QUOTED_PRINTABLE_MAX_LINE_LENGTH;
     }
     
     void flushOutput() throws IOException {
         if (outputIndex < outBuffer.length) {
             out.write(outBuffer, 0, outputIndex);
         } else {
             out.write(outBuffer);
         }
         outputIndex = 0;
     }
 }