/*

 * Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 */

package sun.nio.cs.ext;

import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.charset.Charset;

import java.nio.charset.CharsetEncoder;

import java.nio.charset.CoderResult;

import sun.nio.cs.Surrogate;

public abstract class SimpleEUCEncoder

    extends CharsetEncoder

{

    protected short  index1[];

    protected String index2;

    protected String index2a;

    protected String index2b;

    protected String index2c;

    protected int    mask1;

    protected int    mask2;

    protected int    shift;

    private byte[] outputByte = new byte[4];

    private final Surrogate.Parser sgp = new Surrogate.Parser();

    protected SimpleEUCEncoder(Charset cs)

    {

        super(cs, 3.0f, 4.0f);

    }

    /**

     * Returns true if the given character can be converted to the

     * target character encoding.

     */

    public boolean canEncode(char ch) {

       int    index;

       String theChars;

       index = index1[((ch & mask1) >> shift)] + (ch & mask2);

       if (index < 7500)

         theChars = index2;

       else

         if (index < 15000) {

           index = index - 7500;

           theChars = index2a;

         }

         else

           if (index < 22500){

             index = index - 15000;

             theChars = index2b;

           }

           else {

             index = index - 22500;

             theChars = index2c;

           }

       if (theChars.charAt(2*index) != '\u0000' ||

                    theChars.charAt(2*index + 1) != '\u0000')

         return (true);

       // only return true if input char was unicode null - all others are

       //     undefined

       return( ch == '\u0000');

    }

    private CoderResult encodeArrayLoop(CharBuffer src, ByteBuffer dst) {

        char[] sa = src.array();

        int sp = src.arrayOffset() + src.position();

        int sl = src.arrayOffset() + src.limit();

        assert (sp <= sl);

        sp = (sp <= sl ? sp : sl);

        byte[] da = dst.array();

        int dp = dst.arrayOffset() + dst.position();

        int dl = dst.arrayOffset() + dst.limit();

        assert (dp <= dl);

        dp = (dp <= dl ? dp : dl);

        int     index;

        int     spaceNeeded;

        int     i;

        try {

            while (sp < sl) {

                boolean allZeroes = true;

                char inputChar = sa[sp];

                if (Character.isSurrogate(inputChar)) {

                    if (sgp.parse(inputChar, sa, sp, sl) < 0)

                        return sgp.error();

                    return sgp.unmappableResult();

                }

                if (inputChar >= '\uFFFE')

                    return CoderResult.unmappableForLength(1);

                String theChars;

                char   aChar;

                 // We have a valid character, get the bytes for it

                index = index1[((inputChar & mask1) >> shift)] + (inputChar & mask2);

                if (index < 7500)

                    theChars = index2;

                else if (index < 15000) {

                     index = index - 7500;

                     theChars = index2a;

                } else if (index < 22500){

                    index = index - 15000;

                    theChars = index2b;

                }

                else {

                    index = index - 22500;

                    theChars = index2c;

                }

                aChar = theChars.charAt(2*index);

                outputByte[0] = (byte)((aChar & 0xff00)>>8);

                outputByte[1] = (byte)(aChar & 0x00ff);

                aChar = theChars.charAt(2*index + 1);

                outputByte[2] = (byte)((aChar & 0xff00)>>8);

                outputByte[3] = (byte)(aChar & 0x00ff);

            for (i = 0; i < outputByte.length; i++) {

                if (outputByte[i] != 0x00) {

                allZeroes = false;

                break;

                }

            }

            if (allZeroes && inputChar != '\u0000') {

                return CoderResult.unmappableForLength(1);

            }

            int oindex = 0;

            for (spaceNeeded = outputByte.length;

                 spaceNeeded > 1; spaceNeeded--){

                if (outputByte[oindex++] != 0x00 )

                    break;

            }

            if (dp + spaceNeeded > dl)

                return CoderResult.OVERFLOW;

            for (i = outputByte.length - spaceNeeded;

                 i < outputByte.length; i++) {

                    da[dp++] = outputByte[i];

            }

            sp++;

        }

        return CoderResult.UNDERFLOW;

        } finally {

            src.position(sp - src.arrayOffset());

            dst.position(dp - dst.arrayOffset());

        }

    }

    private CoderResult encodeBufferLoop(CharBuffer src, ByteBuffer dst) {

        int     index;

        int     spaceNeeded;

        int     i;

        int mark = src.position();

        try {

            while (src.hasRemaining()) {

                char inputChar = src.get();

                boolean allZeroes = true;

                if (Character.isSurrogate(inputChar)) {

                    if (sgp.parse(inputChar, src) < 0)

                        return sgp.error();

                    return sgp.unmappableResult();

                }

                if (inputChar >= '\uFFFE')

                    return CoderResult.unmappableForLength(1);

                String theChars;

                char   aChar;

                 // We have a valid character, get the bytes for it

                index = index1[((inputChar & mask1) >> shift)] + (inputChar & mask2);

                if (index < 7500)

                    theChars = index2;

                else if (index < 15000) {

                     index = index - 7500;

                     theChars = index2a;

                } else if (index < 22500){

                    index = index - 15000;

                    theChars = index2b;

                }

                else {

                    index = index - 22500;

                    theChars = index2c;

                }

                aChar = theChars.charAt(2*index);

                outputByte[0] = (byte)((aChar & 0xff00)>>8);

                outputByte[1] = (byte)(aChar & 0x00ff);

                aChar = theChars.charAt(2*index + 1);

                outputByte[2] = (byte)((aChar & 0xff00)>>8);

                outputByte[3] = (byte)(aChar & 0x00ff);

            for (i = 0; i < outputByte.length; i++) {

                if (outputByte[i] != 0x00) {

                allZeroes = false;

                break;

                }

            }

            if (allZeroes && inputChar != '\u0000') {

                return CoderResult.unmappableForLength(1);

            }

            int oindex = 0;

            for (spaceNeeded = outputByte.length;

                 spaceNeeded > 1; spaceNeeded--){

                if (outputByte[oindex++] != 0x00 )

                    break;

            }

            if (dst.remaining() < spaceNeeded)

                return CoderResult.OVERFLOW;

            for (i = outputByte.length - spaceNeeded;

                 i < outputByte.length; i++) {

                    dst.put(outputByte[i]);

            }

            mark++;

            }

            return CoderResult.UNDERFLOW;

        } finally {

            src.position(mark);

        }

    }

    protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst) {

        if (true && src.hasArray() && dst.hasArray())

            return encodeArrayLoop(src, dst);

        else

            return encodeBufferLoop(src, dst);

    }

    public byte encode(char inputChar) {

        return (byte)index2.charAt(index1[(inputChar & mask1) >> shift] +

                (inputChar & mask2));

    }

}