/*
 * Copyright (c) 2001, 2003, 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.io;

import sun.nio.cs.ext.GB18030;

public class ByteToCharGB18030 extends ByteToCharGB18030DB {

    private static final int GB18030_SINGLE_BYTE = 1;
    private static final int GB18030_DOUBLE_BYTE = 2;
    private static final int GB18030_FOUR_BYTE = 3;
    private static short[] decoderIndex1;
    private static String[] decoderIndex2;

    private int currentState;
    private int savedSize;
    private byte[] savedBytes;

    public ByteToCharGB18030() {
        super();
        GB18030 nioCoder = new GB18030();
        savedBytes = new byte[3];
        currentState = GB18030_DOUBLE_BYTE;
        decoderIndex1 = nioCoder.getDecoderIndex1();
        decoderIndex2 = nioCoder.getDecoderIndex2();
        savedSize = 0;
    }

    public short[] getOuter() {
        return(index1);
    }

    public String[] getInner() {
        return(index2);
    }

    public short[] getDBIndex1() {
        return(super.index1);
    }

    public String[] getDBIndex2() {
        return(super.index2);
    }

    public int flush(char [] output, int outStart, int outEnd)
        throws MalformedInputException
    {
        if (savedSize != 0) {
            savedSize = 0;
            currentState = GB18030_DOUBLE_BYTE;
            badInputLength = 0;
            throw new MalformedInputException();
        }
        byteOff = charOff = 0;
        return 0;
    }


    
Character conversion
/**
     * Character conversion
     */
    public int convert(byte[] input, int inOff, int inEnd,
                       char[] output, int outOff, int outEnd)
        throws UnknownCharacterException, MalformedInputException,
               ConversionBufferFullException
    {
        int inputSize = 0;
        char outputChar = '\uFFFD';
        // readOff keeps the actual buffer's pointer.
        // byteOff keeps original buffer's pointer.
        int readOff = byteOff = inOff;

        if (savedSize != 0) {
            // Filter illegal bytes when they are detected in saved
            // partial input from a previous conversion attempt.
            if (((savedBytes[0] & 0xFF) < 0x81 || savedBytes[0] > 0xFE) ||
                 (savedSize > 1 &&
                 (savedBytes[1] & 0xFF) < 0x30 ) ||
                 (savedSize > 2 &&
                 ((savedBytes[2] & 0xFF) < 0x81 ||
                 (savedBytes[2] & 0xFF) > 0xFE ))) {
                    badInputLength = 0;
                    throw new MalformedInputException();
            }

            byte[] newBuf = new byte[inEnd - inOff + savedSize];
            for (int i = 0; i < savedSize; i++) {
                newBuf[i] = savedBytes[i];
            }
            System.arraycopy(input, inOff, newBuf, savedSize, inEnd - inOff);
            byteOff -= savedSize;
            input = newBuf;
            inOff = 0;
            inEnd = newBuf.length;
            savedSize = 0;
        }

        charOff = outOff;
        readOff = inOff;

        while(readOff < inEnd) {
            int byte1 = 0 , byte2 = 0, byte3 = 0, byte4 = 0;

            // Is there room in the output buffer for the result?
            if (charOff >= outEnd) {
                throw new ConversionBufferFullException();
            }

            // Get the input byte
            byte1 = input[readOff++] & 0xFF;
            inputSize = 1;

            if ((byte1 & (byte)0x80) == 0){ // US-ASCII range
                outputChar = (char)byte1;
                currentState = GB18030_SINGLE_BYTE;
            }

            else if (byte1 < 0x81 || byte1 > 0xfe) {
                if (subMode)
                    outputChar = subChars[0];
                else {
                    badInputLength = 1;
                    throw new UnknownCharacterException();
                }
            }
            else {
                // Either 2 or 4 byte sequence follows
                // If an underrun is detected save for later
                // replay.

                if (readOff + inputSize > inEnd) {
                    savedBytes[0]=(byte)byte1;
                    savedSize = 1;
                    break;
                }

                byte2 = input[readOff++] & 0xFF;
                inputSize = 2;

                if (byte2 < 0x30) {
                    badInputLength = 1;
                    throw new MalformedInputException();
                }
                else if (byte2 >= 0x30 && byte2 <= 0x39) {
                    currentState = GB18030_FOUR_BYTE;
                    inputSize = 4;

                    if (readOff + 2 > inEnd) {
                        if (readOff + 1 > inEnd) {
                            savedBytes[0] = (byte)byte1;
                            savedBytes[1] = (byte)byte2;
                            savedSize = 2;
                        }
                        else {
                            savedBytes[0] = (byte)byte1;
                            savedBytes[1] = (byte)byte2;
                            savedBytes[2] = input[readOff++];
                            savedSize = 3;
                        }
                        break;
                    }
                    byte3 = input[readOff++] & 0xFF;
                    if (byte3 < 0x81 || byte3 > 0xfe) {
                        badInputLength = 3;
                        throw new MalformedInputException();
                    }

                    byte4 = input[readOff++] & 0xFF;

                    if (byte4 < 0x30 || byte4 > 0x39) {
                        badInputLength = 4;
                        throw new MalformedInputException();
                    }
                }
                else if (byte2 == 0x7f || byte2 == 0xff ||
                        (byte2 < 0x40 )) {
                   badInputLength = 2;
                   throw new MalformedInputException();
                }
                else
                    currentState = GB18030_DOUBLE_BYTE;
            }

            switch (currentState){
                case GB18030_SINGLE_BYTE:
                    output[charOff++] = (char)(byte1);
                    break;
                case GB18030_DOUBLE_BYTE:
                    output[charOff++] = super.getUnicode(byte1, byte2);
                    break;
                case GB18030_FOUR_BYTE:
                    int offset = (((byte1 - 0x81) * 10 +
                                   (byte2 - 0x30)) * 126 +
                                    byte3 - 0x81) * 10 + byte4 - 0x30;
                    int hiByte = (offset >>8) & 0xFF;
                    int lowByte = (offset & 0xFF);

                // Mixture of table lookups and algorithmic calculation
                // of character values.

                // BMP Ranges

                if (offset <= 0x4A62)
                    output[charOff++] = getChar(offset);
                else if (offset > 0x4A62 && offset <= 0x82BC)
                    output[charOff++] = (char) (offset + 0x5543);
                else if (offset >= 0x82BD && offset <= 0x830D)
                    output[charOff++] = getChar(offset);
                else if (offset >= 0x830D && offset <= 0x93A8)
                    output[charOff++] = (char) (offset + 0x6557);
                else if (offset >= 0x93A9 && offset <= 0x99FB)
                    output[charOff++] = getChar(offset);
                // Supplemental UCS planes handled via surrogates
                else if (offset >= 0x2E248 && offset < 0x12E248) {
                    if (offset >= 0x12E248) {
                        if (subMode)
                           return subChars[0];
                        else {
                           badInputLength = 4;
                           throw new UnknownCharacterException();
                        }
                    }

                    if (charOff +2 > outEnd) {
                        throw new ConversionBufferFullException();
                    }
                    offset -= 0x1e248;
                    char highSurr = (char) ((offset - 0x10000) / 0x400 + 0xD800);
                    char lowSurr = (char) ((offset - 0x10000) % 0x400 + 0xDC00);
                    output[charOff++] = highSurr;
                    output[charOff++] = lowSurr;
                }
                else {
                    badInputLength = 4;
                    throw new MalformedInputException();
                    }
                break;
              }
        byteOff += inputSize;
        }

        byteOff += savedSize;
        return charOff - outOff;
    }

    public void reset() {
        byteOff = charOff = 0;
        currentState = GB18030_DOUBLE_BYTE;
        savedSize = 0;
    }

    public String getCharacterEncoding() {
        return "GB18030";
    }

    private char getChar(int offset) throws UnknownCharacterException {
        int byte1 = (offset >>8) & 0xFF;
        int byte2 = (offset & 0xFF);
        int start = 0, end = 0xFF;

        if (((byte1 < 0) || (byte1 > getOuter().length))
             || ((byte2 < start) || (byte2 > end))) {
                if (subMode)
                   return subChars[0];
                else {
                   badInputLength = 1;
                   throw new UnknownCharacterException();
                }
        }

        int n = (decoderIndex1[byte1] & 0xf) * (end - start + 1) + (byte2 - start);
        return decoderIndex2[decoderIndex1[byte1] >> 4].charAt(n);
    }
}