/* ====================================================================

  * Copyright (c) 2006 J.T. Beetstra

  *

  * Permission is hereby granted, free of charge, to any person obtaining 

  * a copy of this software and associated documentation files (the 

  * "Software"), to deal in the Software without restriction, including 

  * without limitation the rights to use, copy, modify, merge, publish, 

  * distribute, sublicense, and/or sell copies of the Software, and to 

  * permit persons to whom the Software is furnished to do so, subject to 

  * the following conditions:

  *

  * The above copyright notice and this permission notice shall be 

  * included in all copies or substantial portions of the Software.

  *

  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 

  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 

  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 

  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 

  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 

  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 

  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  * ====================================================================

  */

 package com.beetstra.jutf7;

 import java.nio.ByteBuffer;

 import java.nio.CharBuffer;

 import java.nio.charset.CharsetEncoder;

 import java.nio.charset.CoderResult;

 /**

  * <p>The CharsetEncoder used to encode both variants of the UTF-7 charset and the 

  * modified-UTF-7 charset.</p>

  * 

  * <p><strong>Please note this class does not behave strictly according to the specification in 

  * Sun Java VMs before 1.6.</strong> This is done to get around a bug in the implementation 

  * of {@link java.nio.charset.CharsetEncoder#encode(CharBuffer)}. Unfortunately, that method 

  * cannot be overridden.</p>

  *  

  * @see <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6221056">JDK bug 6221056</a>

  * 

  * @author Jaap Beetstra

  */

 class UTF7StyleCharsetEncoder extends CharsetEncoder {

         private static final float AVG_BYTES_PER_CHAR = 1.5f;

         private static final float MAX_BYTES_PER_CHAR = 5.0f;

         private final UTF7StyleCharset cs;

         private final Base64Util base64;

         private final byte shift;

         private final byte unshift;

         private final boolean strict;

         private boolean base64mode;

         private int bitsToOutput;

         private int sextet;

         static boolean useUglyHackToForceCallToFlushInJava5;

         static {

                 String version = System.getProperty("java.specification.version");

                 String vendor = System.getProperty("java.vm.vendor");

                 useUglyHackToForceCallToFlushInJava5 = "1.4".equals(version) || "1.5".equals(version);

                 useUglyHackToForceCallToFlushInJava5 &= "Sun Microsystems Inc.".equals(vendor);

         }

         UTF7StyleCharsetEncoder(UTF7StyleCharset cs, Base64Util base64, boolean strict) {

                 super(cs, AVG_BYTES_PER_CHAR, MAX_BYTES_PER_CHAR);

                 this.cs = cs;

                 this.base64 = base64;

                 this.strict = strict;

                 this.shift = cs.shift();

                 this.unshift = cs.unshift();

         }

         /* (non-Javadoc)

          * @see java.nio.charset.CharsetEncoder#implReset()

          */

         protected void implReset() {

                 base64mode = false;

                 sextet = 0;

                 bitsToOutput = 0;

         }

         /**

          * {@inheritDoc}

          * 

          * <p>Note that this method might return <code>CoderResult.OVERFLOW</code> (as is 

          * required by the specification) if insufficient space is available in the output 

          * buffer. However, calling it again on JDKs before Java 6 triggers a bug in 

          * {@link java.nio.charset.CharsetEncoder#flush(ByteBuffer)} causing it to throw an 

          * IllegalStateException (the buggy method is <code>final</code>, thus cannot be 

          * overridden).</p>

          * 

          * @see <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6227608">JDK bug 6227608</a>

          * @param out The output byte buffer

          * @return A coder-result object describing the reason for termination

          */

         protected CoderResult implFlush(ByteBuffer out) {

                 if (base64mode) {

                         if (out.remaining() < 2)

                                 return CoderResult.OVERFLOW;

                         if (bitsToOutput != 0)

                                 out.put(base64.getChar(sextet));

                         out.put(unshift);

                 }

                 return CoderResult.UNDERFLOW;

         }

         /**

          * {@inheritDoc}

          * 

          * <p>Note that this method might return <code>CoderResult.OVERFLOW</code>, even 

          * though there is sufficient space available in the output buffer. This is done 

          * to force the broken implementation of 

          * {@link java.nio.charset.CharsetEncoder#encode(CharBuffer)} to call flush 

          * (the buggy method is <code>final</code>, thus cannot be overridden).</p>

          * <p>However, String.getBytes() fails if CoderResult.OVERFLOW is returned, since

          * this assumes it always allocates sufficient bytes (maxBytesPerChar * nr_of_chars).

          * Thus, as an extra check, the size of the input buffer is compared against the size

          * of the output buffer.

          * A static variable is used to indicate if a broken java version is used.</p>

          * <p>It is not possible to directly write the last few bytes, since more bytes 

          * might be waiting to be encoded then those available in the input buffer.</p> 

          * 

          * @see <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6221056">JDK bug 6221056</a>

          * @param in The input character buffer

          * @param out The output byte buffer

          * @return A coder-result object describing the reason for termination

          */

         protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {

                 while (in.hasRemaining()) {

                         if (out.remaining() < 4)

                                 return CoderResult.OVERFLOW;

                         char ch = in.get();

                         if (cs.canEncodeDirectly(ch)) {

                                 unshift(out, ch);

                                 out.put((byte) ch);

                         } else if (!base64mode && ch == shift) {

                                 out.put(shift);

                                 out.put(unshift);

                         } else

                                 encodeBase64(ch, out);

                 }

                 /* <HACK type="ugly">

                  These lines are required to trick JDK 1.5 and earlier into flushing when using 

                  Charset.encode(String), Charset.encode(CharBuffer) or CharsetEncoder.encode(CharBuffer)

                  Without them, the last few bytes may be missing.

                  */

                 if (base64mode && useUglyHackToForceCallToFlushInJava5

                                 && out.limit() != MAX_BYTES_PER_CHAR * in.limit())

                         return CoderResult.OVERFLOW;

                 /* </HACK> */

                 return CoderResult.UNDERFLOW;

         }

         /**

          * <p>Writes the bytes necessary to leave <i>base 64 mode</i>. This might include an unshift 

          * character.</p>

          *  

          * @param out

          * @param ch

          */

         private void unshift(ByteBuffer out, char ch) {

                 if (!base64mode)

                         return;

                 if (bitsToOutput != 0)

                         out.put(base64.getChar(sextet));

                 if (base64.contains(ch) || ch == unshift || strict)

                         out.put(unshift);

                 base64mode = false;

                 sextet = 0;

                 bitsToOutput = 0;

         }

         /**

          * <p>Writes the bytes necessary to encode a character in <i>base 64 mode</i>. All bytes

          * which are fully determined will be written. The fields <code>bitsToOutput</code> and

          * <code>sextet</code> are used to remember the bytes not yet fully determined.</p>

          *  

          * @param out

          * @param ch

          */

         private void encodeBase64(char ch, ByteBuffer out) {

                 if (!base64mode)

                         out.put(shift);

                 base64mode = true;

                 bitsToOutput += 16;

                 while (bitsToOutput >= 6) {

                         bitsToOutput -= 6;

                         sextet += (ch >> bitsToOutput);

                         sextet &= 0x3F;

                         out.put(base64.getChar(sextet));

                         sextet = 0;

                 }

                 sextet = (ch << (6 - bitsToOutput)) & 0x3F;

         }

 }