/*

 * 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.CharsetDecoder;

import java.nio.charset.CharsetEncoder;

import java.nio.charset.CoderResult;

import java.nio.charset.CharacterCodingException;

import sun.nio.cs.DoubleByte;

import sun.nio.cs.HistoricallyNamedCharset;

import sun.nio.cs.US_ASCII;

import sun.nio.cs.*;

public class ISO2022_CN

    extends Charset

    implements HistoricallyNamedCharset

{

    private static final byte ISO_ESC = 0x1b;

    private static final byte ISO_SI = 0x0f;

    private static final byte ISO_SO = 0x0e;

    private static final byte ISO_SS2_7 = 0x4e;

    private static final byte ISO_SS3_7 = 0x4f;

    private static final byte MSB = (byte)0x80;

    private static final char REPLACE_CHAR = '\uFFFD';

    private static final byte SODesigGB = 0;

    private static final byte SODesigCNS = 1;

    public ISO2022_CN() {

        super("ISO-2022-CN", ExtendedCharsets.aliasesFor("ISO-2022-CN"));

    }

    public String historicalName() {

        return "ISO2022CN";

    }

    public boolean contains(Charset cs) {

        return ((cs instanceof EUC_CN)     // GB2312-80 repertoire

                || (cs instanceof US_ASCII)

                || (cs instanceof EUC_TW)  // CNS11643 repertoire

                || (cs instanceof ISO2022_CN));

    }

    public CharsetDecoder newDecoder() {

        return new Decoder(this);

    }

    public CharsetEncoder newEncoder() {

        throw new UnsupportedOperationException();

    }

    public boolean canEncode() {

        return false;

    }

    static class Decoder extends CharsetDecoder {

        private boolean shiftOut;

        private byte currentSODesig;

        private static final Charset gb2312 = new EUC_CN();

        private static final Charset cns = new EUC_TW();

        private final DoubleByte.Decoder gb2312Decoder;

        private final EUC_TW.Decoder cnsDecoder;

        Decoder(Charset cs) {

            super(cs, 1.0f, 1.0f);

            shiftOut = false;

            currentSODesig = SODesigGB;

            gb2312Decoder = (DoubleByte.Decoder)gb2312.newDecoder();

            cnsDecoder = (EUC_TW.Decoder)cns.newDecoder();

        }

        protected void implReset() {

            shiftOut= false;

            currentSODesig = SODesigGB;

        }

        private char cnsDecode(byte byte1, byte byte2, byte SS) {

            byte1 |= MSB;

            byte2 |= MSB;

            int p = 0;

            if (SS == ISO_SS2_7)

                p = 1;    //plane 2, index -- 1

            else if (SS == ISO_SS3_7)

                p = 2;    //plane 3, index -- 2

            else

                return REPLACE_CHAR;  //never happen.

            char[] ret = cnsDecoder.toUnicode(byte1 & 0xff,

                                              byte2 & 0xff,

                                              p);

            if (ret == null || ret.length == 2)

                return REPLACE_CHAR;

            return ret[0];

        }

        private char SODecode(byte byte1, byte byte2, byte SOD) {

            byte1 |= MSB;

            byte2 |= MSB;

            if (SOD == SODesigGB) {

                return gb2312Decoder.decodeDouble(byte1 & 0xff,

                                                  byte2 & 0xff);

            } else {    // SOD == SODesigCNS

                char[] ret = cnsDecoder.toUnicode(byte1 & 0xff,

                                                  byte2 & 0xff,

                                                  0);

                if (ret == null)

                    return REPLACE_CHAR;

                return ret[0];

            }

        }

        private CoderResult decodeBufferLoop(ByteBuffer src,

                                             CharBuffer dst)

        {

            int mark = src.position();

            byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;

            int inputSize = 0;

            char c = REPLACE_CHAR;

            try {

                while (src.hasRemaining()) {

                    b1 = src.get();

                    inputSize = 1;

                    while (b1 == ISO_ESC ||

                           b1 == ISO_SO ||

                           b1 == ISO_SI) {

                        if (b1 == ISO_ESC) {  // ESC

                            currentSODesig = SODesigGB;

                            if (src.remaining() < 1)

                                return CoderResult.UNDERFLOW;

                            b2 = src.get();

                            inputSize++;

                            if ((b2 & (byte)0x80) != 0)

                                return CoderResult.malformedForLength(inputSize);

                            if (b2 == (byte)0x24) {

                                if (src.remaining() < 1)

                                    return CoderResult.UNDERFLOW;

                                b3 = src.get();

                                inputSize++;

                                if ((b3 & (byte)0x80) != 0)

                                    return CoderResult.malformedForLength(inputSize);

                                if (b3 == 'A'){              // "$A"

                                    currentSODesig = SODesigGB;

                                } else if (b3 == ')') {

                                    if (src.remaining() < 1)

                                        return CoderResult.UNDERFLOW;

                                    b4 = src.get();

                                    inputSize++;

                                    if (b4 == 'A'){          // "$)A"

                                        currentSODesig = SODesigGB;

                                    } else if (b4 == 'G'){   // "$)G"

                                        currentSODesig = SODesigCNS;

                                    } else {

                                        return CoderResult.malformedForLength(inputSize);

                                    }

                                } else if (b3 == '*') {

                                    if (src.remaining() < 1)

                                        return CoderResult.UNDERFLOW;

                                    b4 = src.get();

                                    inputSize++;

                                    if (b4 != 'H') {         // "$*H"

                                        //SS2Desig -> CNS-P1

                                        return CoderResult.malformedForLength(inputSize);

                                    }

                                } else if (b3 == '+') {

                                    if (src.remaining() < 1)

                                        return CoderResult.UNDERFLOW;

                                    b4 = src.get();

                                    inputSize++;

                                    if (b4 != 'I'){          // "$+I"

                                        //SS3Desig -> CNS-P2.

                                        return CoderResult.malformedForLength(inputSize);

                                    }

                                } else {

                                        return CoderResult.malformedForLength(inputSize);

                                }

                            } else if (b2 == ISO_SS2_7 || b2 == ISO_SS3_7) {

                                if (src.remaining() < 2)

                                    return CoderResult.UNDERFLOW;

                                b3 = src.get();

                                b4 = src.get();

                                inputSize += 2;

                                if (dst.remaining() < 1)

                                    return CoderResult.OVERFLOW;

                                //SS2->CNS-P2, SS3->CNS-P3

                                c = cnsDecode(b3, b4, b2);

                                if (c == REPLACE_CHAR)

                                    return CoderResult.unmappableForLength(inputSize);

                                dst.put(c);

                            } else {

                                return CoderResult.malformedForLength(inputSize);

                            }

                        } else if (b1 == ISO_SO) {

                            shiftOut = true;

                        } else if (b1 == ISO_SI) { // shift back in

                            shiftOut = false;

                        }

                        mark += inputSize;

                        if (src.remaining() < 1)

                            return CoderResult.UNDERFLOW;

                        b1 = src.get();

                        inputSize = 1;

                    }

                    if (dst.remaining() < 1)

                        return CoderResult.OVERFLOW;

                    if (!shiftOut) {

                        dst.put((char)(b1 & 0xff));  //clear the upper byte

                        mark += inputSize;

                    } else {

                        if (src.remaining() < 1)

                            return CoderResult.UNDERFLOW;

                        b2 = src.get();

                        inputSize++;

                        c = SODecode(b1, b2, currentSODesig);

                        if (c == REPLACE_CHAR)

                            return CoderResult.unmappableForLength(inputSize);

                        dst.put(c);

                        mark += inputSize;

                    }

                }

                return CoderResult.UNDERFLOW;

            } finally {

                src.position(mark);

            }

        }

        private CoderResult decodeArrayLoop(ByteBuffer src,

                                            CharBuffer dst)

        {

            int inputSize = 0;

            byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;

            char c = REPLACE_CHAR;

            byte[] sa = src.array();

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

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

            assert (sp <= sl);

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

            char[] da = dst.array();

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

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

            assert (dp <= dl);

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

            try {

                while (sp < sl) {

                    b1 = sa[sp];

                    inputSize = 1;

                    while (b1 == ISO_ESC || b1 == ISO_SO || b1 == ISO_SI) {

                        if (b1 == ISO_ESC) {  // ESC

                            currentSODesig = SODesigGB;

                            if (sp + 2 > sl)

                                return CoderResult.UNDERFLOW;

                            b2 = sa[sp + 1];

                            inputSize++;

                            if ((b2 & (byte)0x80) != 0)

                                return CoderResult.malformedForLength(inputSize);

                            if (b2 == (byte)0x24) {

                                if (sp + 3 > sl)

                                    return CoderResult.UNDERFLOW;

                                b3 = sa[sp + 2];

                                inputSize++;

                                if ((b3 & (byte)0x80) != 0)

                                    return CoderResult.malformedForLength(inputSize);

                                if (b3 == 'A'){              // "$A"

                                    /* <ESC>$A is not a legal designator sequence for

                                       ISO2022_CN, it is listed as an escape sequence

                                       for GB2312 in ISO2022-JP-2. Keep it here just for

                                       the sake of "compatibility".

                                     */

                                    currentSODesig = SODesigGB;

                                } else if (b3 == ')') {

                                    if (sp + 4 > sl)

                                        return CoderResult.UNDERFLOW;

                                    b4 = sa[sp + 3];

                                    inputSize++;

                                    if (b4 == 'A'){          // "$)A"

                                        currentSODesig = SODesigGB;

                                    } else if (b4 == 'G'){   // "$)G"

                                        currentSODesig = SODesigCNS;

                                    } else {

                                        return CoderResult.malformedForLength(inputSize);

                                    }

                                } else if (b3 == '*') {

                                    if (sp + 4 > sl)

                                        return CoderResult.UNDERFLOW;

                                    b4 = sa[sp + 3];

                                    inputSize++;

                                    if (b4 != 'H'){          // "$*H"

                                        return CoderResult.malformedForLength(inputSize);

                                    }

                                } else if (b3 == '+') {

                                    if (sp + 4 > sl)

                                        return CoderResult.UNDERFLOW;

                                    b4 = sa[sp + 3];

                                    inputSize++;

                                    if (b4 != 'I'){          // "$+I"

                                        return CoderResult.malformedForLength(inputSize);

                                    }

                                } else {

                                        return CoderResult.malformedForLength(inputSize);

                                }

                            } else if (b2 == ISO_SS2_7 || b2 == ISO_SS3_7) {

                                if (sp + 4 > sl) {

                                    return CoderResult.UNDERFLOW;

                                }

                                b3 = sa[sp + 2];

                                b4 = sa[sp + 3];

                                if (dl - dp < 1)  {

                                    return CoderResult.OVERFLOW;

                                }

                                inputSize += 2;

                                c = cnsDecode(b3, b4, b2);

                                if (c == REPLACE_CHAR)

                                    return CoderResult.unmappableForLength(inputSize);

                                da[dp++] = c;

                            } else {

                                return CoderResult.malformedForLength(inputSize);

                            }

                        } else if (b1 == ISO_SO) {

                            shiftOut = true;

                        } else if (b1 == ISO_SI) { // shift back in

                            shiftOut = false;

                        }

                        sp += inputSize;

                        if (sp + 1 > sl)

                            return CoderResult.UNDERFLOW;

                        b1 = sa[sp];

                        inputSize = 1;

                    }

                    if (dl - dp < 1) {

                        return CoderResult.OVERFLOW;

                    }

                    if (!shiftOut) {

                        da[dp++] = (char)(b1 & 0xff);  //clear the upper byte

                    } else {

                        if (sp + 2 > sl)

                            return CoderResult.UNDERFLOW;

                        b2 = sa[sp + 1];

                        inputSize++;

                        c = SODecode(b1, b2, currentSODesig);

                        if (c == REPLACE_CHAR)

                            return CoderResult.unmappableForLength(inputSize);

                        da[dp++] = c;

                    }

                    sp += inputSize;

                }

                return CoderResult.UNDERFLOW;

            } finally {

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

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

            }

        }

        protected CoderResult decodeLoop(ByteBuffer src,

                                         CharBuffer dst)

        {

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

                return decodeArrayLoop(src, dst);

            else

                return decodeBufferLoop(src, dst);

        }

    }

}