/**
    *
    * Copyright 2003-2006 The Apache Software Foundation
    *
    *  Licensed 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.geronimo.mail.util;
  
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.io.UnsupportedEncodingException;
  
  import javax.mail.internet.MimeUtility;
  
  /**
   * Encoder for RFC2231 encoded parameters
   *
   * RFC2231 string are encoded as
   *
   *    charset'language'encoded-text
   *
   * and
   *
   *    encoded-text = *(char / hexchar)
   *
   * where
   *
   *    char is any ASCII character in the range 33-126, EXCEPT
   *    the characters "%" and " ".
   *
   *    hexchar is an ASCII "%" followed by two upper case
   *    hexadecimal digits.
   */
  
  public class RFC2231Encoder implements Encoder
  {
      protected final byte[] encodingTable =
          {
              (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5', (byte)'6', (byte)'7',
              (byte)'8', (byte)'9', (byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F'
          };
  
      protected String DEFAULT_SPECIALS = " *'%";
      protected String specials = DEFAULT_SPECIALS;
  
      /*
       * set up the decoding table.
       */
      protected final byte[] decodingTable = new byte[128];
  
      protected void initialiseDecodingTable()
      {
          for (int i = 0; i < encodingTable.length; i++)
          {
              decodingTable[encodingTable[i]] = (byte)i;
          }
      }
  
      public RFC2231Encoder()
      {
          this(null);
      }
  
      public RFC2231Encoder(String specials)
      {
          if (specials != null) {
              this.specials = DEFAULT_SPECIALS + specials;
          }
          initialiseDecodingTable();
      }
  
  
      /**
       * encode the input data producing an RFC2231 output stream.
       *
       * @return the number of bytes produced.
       */
      public int encode(byte[] data, int off, int length, OutputStream out) throws IOException {
  
          int bytesWritten = 0;
          for (int i = off; i < (off + length); i++)
          {
              int ch = data[i] & 0xff;
              // character tha must be encoded?  Prefix with a '%' and encode in hex.
              if (ch <= 32 || ch >= 127 || specials.indexOf(ch) != -1) {
                  out.write((byte)'%');
                  out.write(encodingTable[ch >> 4]);
                 out.write(encodingTable[ch & 0xf]);
                 bytesWritten += 3;
             }
             else {
                 // add unchanged.
                 out.write((byte)ch);
                 bytesWritten++;
             }
         }
 
         return bytesWritten;
     }
 
 
     /**
      * decode the RFC2231 encoded byte data writing it to the given output stream
      *
      * @return the number of bytes produced.
      */
     public int decode(byte[] data, int off, int length, OutputStream out) throws IOException {
         int        outLen = 0;
         int        end = off + length;
 
         int i = off;
         while (i < end)
         {
             byte v = data[i++];
             // a percent is a hex character marker, need to decode a hex value.
             if (v == '%') {
                 byte b1 = decodingTable[data[i++]];
                 byte b2 = decodingTable[data[i++]];
                 out.write((b1 << 4) | b2);
             }
             else {
                 // copied over unchanged.
                 out.write(v);
             }
             // always just one byte added
             outLen++;
         }
 
         return outLen;
     }
 
     /**
      * decode the RFC2231 encoded String data writing it to the given output stream.
      *
      * @return the number of bytes produced.
      */
     public int decode(String data, OutputStream out) throws IOException
     {
         int        length = 0;
         int        end = data.length();
 
         int i = 0;
         while (i < end)
         {
             char v = data.charAt(i++);
             if (v == '%') {
                 byte b1 = decodingTable[data.charAt(i++)];
                 byte b2 = decodingTable[data.charAt(i++)];
 
                 out.write((b1 << 4) | b2);
             }
             else {
                 out.write((byte)v);
             }
             length++;
         }
 
         return length;
     }
 
 
     /**
      * Encode a string as an RFC2231 encoded parameter, using the
      * given character set and language.
      *
      * @param charset  The source character set (the MIME version).
      * @param language The encoding language.
      * @param data     The data to encode.
      *
      * @return The encoded string.
      */
     public String encode(String charset, String language, String data) throws IOException {
 
         byte[] bytes = null;
         try {
             // the charset we're adding is the MIME-defined name.  We need the java version
             // in order to extract the bytes.
             bytes = data.getBytes(MimeUtility.javaCharset(charset));
         } catch (UnsupportedEncodingException e) {
             // we have a translation problem here.
             return null;
         }
 
         StringBuffer result = new StringBuffer();
 
         // append the character set, if we have it.
         if (charset != null) {
             result.append(charset);
         }
         // the field marker is required.
         result.append("'");
 
         // and the same for the language.
         if (language != null) {
             result.append(language);
         }
         // the field marker is required.
         result.append("'");
 
         // wrap an output stream around our buffer for the decoding
         OutputStream out = new StringBufferOutputStream(result);
 
         // encode the data stream
         encode(bytes, 0, bytes.length, out);
 
         // finis!
         return result.toString();
     }
 
 
     /**
      * Decode an RFC2231 encoded string.
      *
      * @param data   The data to decode.
      *
      * @return The decoded string.
      * @exception IOException
      * @exception UnsupportedEncodingException
      */
     public String decode(String data) throws IOException, UnsupportedEncodingException {
         // get the end of the language field
         int charsetEnd = data.indexOf('\'');
         // uh oh, might not be there
         if (charsetEnd == -1) {
             throw new IOException("Missing charset in RFC2231 encoded value");
         }
 
         String charset = data.substring(0, charsetEnd);
 
         // now pull out the language the same way
         int languageEnd = data.indexOf('\'', charsetEnd + 1);
         if (languageEnd == -1) {
             throw new IOException("Missing language in RFC2231 encoded value");
         }
 
         String language = data.substring(charsetEnd + 1, languageEnd);
 
         ByteArrayOutputStream out = new ByteArrayOutputStream(data.length());
 
         // decode the data
         decode(data.substring(languageEnd + 1), out);
 
         byte[] bytes = out.toByteArray();
         // build a new string from this using the java version of the encoded charset.
         return new String(bytes, 0, bytes.length, MimeUtility.javaCharset(charset));
     }
 }