/*

 * Copyright 2000-2006 Sun Microsystems, Inc.  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.  Sun designates this

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

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package java.lang;

import java.io.CharConversionException;

import java.io.UnsupportedEncodingException;

import java.lang.ref.SoftReference;

import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.BufferOverflowException;

import java.nio.BufferUnderflowException;

import java.nio.charset.Charset;

import java.nio.charset.CharsetDecoder;

import java.nio.charset.CharsetEncoder;

import java.nio.charset.CharacterCodingException;

import java.nio.charset.CoderResult;

import java.nio.charset.CodingErrorAction;

import java.nio.charset.IllegalCharsetNameException;

import java.nio.charset.MalformedInputException;

import java.nio.charset.UnsupportedCharsetException;

import java.util.Arrays;

import sun.misc.MessageUtils;

import sun.nio.cs.HistoricallyNamedCharset;

/**

 * Utility class for string encoding and decoding.

 */

class StringCoding {

    private StringCoding() { }

    /** The cached coders for each thread */

    private final static ThreadLocal<SoftReference<StringDecoder>> decoder =

        new ThreadLocal<SoftReference<StringDecoder>>();

    private final static ThreadLocal<SoftReference<StringEncoder>> encoder =

        new ThreadLocal<SoftReference<StringEncoder>>();

    private static boolean warnUnsupportedCharset = true;

    private static <T> T deref(ThreadLocal<SoftReference<T>> tl) {

        SoftReference<T> sr = tl.get();

        if (sr == null)

            return null;

        return sr.get();

    }

    private static <T> void set(ThreadLocal<SoftReference<T>> tl, T ob) {

        tl.set(new SoftReference<T>(ob));

    }

    // Trim the given byte array to the given length

    //

    private static byte[] safeTrim(byte[] ba, int len, Charset cs) {

        if (len == ba.length

            && (System.getSecurityManager() == null

                || cs.getClass().getClassLoader0() == null))

            return ba;

        else

            return Arrays.copyOf(ba, len);

    }

    // Trim the given char array to the given length

    //

    private static char[] safeTrim(char[] ca, int len, Charset cs) {

        if (len == ca.length

            && (System.getSecurityManager() == null

                || cs.getClass().getClassLoader0() == null))

            return ca;

        else

            return Arrays.copyOf(ca, len);

    }

    private static int scale(int len, float expansionFactor) {

        // We need to perform double, not float, arithmetic; otherwise

        // we lose low order bits when len is larger than 2**24.

        return (int)(len * (double)expansionFactor);

    }

    private static Charset lookupCharset(String csn) {

        if (Charset.isSupported(csn)) {

            try {

                return Charset.forName(csn);

            } catch (UnsupportedCharsetException x) {

                throw new Error(x);

            }

        }

        return null;

    }

    private static void warnUnsupportedCharset(String csn) {

        if (warnUnsupportedCharset) {

            // Use sun.misc.MessageUtils rather than the Logging API or

            // System.err since this method may be called during VM

            // initialization before either is available.

            MessageUtils.err("WARNING: Default charset " + csn +

                             " not supported, using ISO-8859-1 instead");

            warnUnsupportedCharset = false;

        }

    }

    // -- Decoding --

    private static class StringDecoder {

        private final String requestedCharsetName;

        private final Charset cs;

        private final CharsetDecoder cd;

        private StringDecoder(Charset cs, String rcn) {

            this.requestedCharsetName = rcn;

            this.cs = cs;

            this.cd = cs.newDecoder()

                .onMalformedInput(CodingErrorAction.REPLACE)

                .onUnmappableCharacter(CodingErrorAction.REPLACE);

        }

        String charsetName() {

            if (cs instanceof HistoricallyNamedCharset)

                return ((HistoricallyNamedCharset)cs).historicalName();

            return cs.name();

        }

        final String requestedCharsetName() {

            return requestedCharsetName;

        }

        char[] decode(byte[] ba, int off, int len) {

            int en = scale(len, cd.maxCharsPerByte());

            char[] ca = new char[en];

            if (len == 0)

                return ca;

            cd.reset();

            ByteBuffer bb = ByteBuffer.wrap(ba, off, len);

            CharBuffer cb = CharBuffer.wrap(ca);

            try {

                CoderResult cr = cd.decode(bb, cb, true);

                if (!cr.isUnderflow())

                    cr.throwException();

                cr = cd.flush(cb);

                if (!cr.isUnderflow())

                    cr.throwException();

            } catch (CharacterCodingException x) {

                // Substitution is always enabled,

                // so this shouldn't happen

                throw new Error(x);

            }

            return safeTrim(ca, cb.position(), cs);

        }

    }

    static char[] decode(String charsetName, byte[] ba, int off, int len)

        throws UnsupportedEncodingException

    {

        StringDecoder sd = deref(decoder);

        String csn = (charsetName == null) ? "ISO-8859-1" : charsetName;

        if ((sd == null) || !(csn.equals(sd.requestedCharsetName())

                              || csn.equals(sd.charsetName()))) {

            sd = null;

            try {

                Charset cs = lookupCharset(csn);

                if (cs != null)

                    sd = new StringDecoder(cs, csn);

            } catch (IllegalCharsetNameException x) {}

            if (sd == null)

                throw new UnsupportedEncodingException(csn);

            set(decoder, sd);

        }

        return sd.decode(ba, off, len);

    }

    static char[] decode(Charset cs, byte[] ba, int off, int len) {

        StringDecoder sd = new StringDecoder(cs, cs.name());

        return sd.decode(Arrays.copyOfRange(ba, off, off + len), 0, len);

    }

    static char[] decode(byte[] ba, int off, int len) {

        String csn = Charset.defaultCharset().name();

        try {

            return decode(csn, ba, off, len);

        } catch (UnsupportedEncodingException x) {

            warnUnsupportedCharset(csn);

        }

        try {

            return decode("ISO-8859-1", ba, off, len);

        } catch (UnsupportedEncodingException x) {

            // If this code is hit during VM initialization, MessageUtils is

            // the only way we will be able to get any kind of error message.

            MessageUtils.err("ISO-8859-1 charset not available: "

                             + x.toString());

            // If we can not find ISO-8859-1 (a required encoding) then things

            // are seriously wrong with the installation.

            System.exit(1);

            return null;

        }

    }

    // -- Encoding --

    private static class StringEncoder {

        private Charset cs;

        private CharsetEncoder ce;

        private final String requestedCharsetName;

        private StringEncoder(Charset cs, String rcn) {

            this.requestedCharsetName = rcn;

            this.cs = cs;

            this.ce = cs.newEncoder()

                .onMalformedInput(CodingErrorAction.REPLACE)

                .onUnmappableCharacter(CodingErrorAction.REPLACE);

        }

        String charsetName() {

            if (cs instanceof HistoricallyNamedCharset)

                return ((HistoricallyNamedCharset)cs).historicalName();

            return cs.name();

        }

        final String requestedCharsetName() {

            return requestedCharsetName;

        }

        byte[] encode(char[] ca, int off, int len) {

            int en = scale(len, ce.maxBytesPerChar());

            byte[] ba = new byte[en];

            if (len == 0)

                return ba;

            ce.reset();

            ByteBuffer bb = ByteBuffer.wrap(ba);

            CharBuffer cb = CharBuffer.wrap(ca, off, len);

            try {

                CoderResult cr = ce.encode(cb, bb, true);

                if (!cr.isUnderflow())

                    cr.throwException();

                cr = ce.flush(bb);

                if (!cr.isUnderflow())

                    cr.throwException();

            } catch (CharacterCodingException x) {

                // Substitution is always enabled,

                // so this shouldn't happen

                throw new Error(x);

            }

            return safeTrim(ba, bb.position(), cs);

        }

    }

    static byte[] encode(String charsetName, char[] ca, int off, int len)

        throws UnsupportedEncodingException

    {

        StringEncoder se = deref(encoder);

        String csn = (charsetName == null) ? "ISO-8859-1" : charsetName;

        if ((se == null) || !(csn.equals(se.requestedCharsetName())

                              || csn.equals(se.charsetName()))) {

            se = null;

            try {

                Charset cs = lookupCharset(csn);

                if (cs != null)

                    se = new StringEncoder(cs, csn);

            } catch (IllegalCharsetNameException x) {}

            if (se == null)

                throw new UnsupportedEncodingException (csn);

            set(encoder, se);

        }

        return se.encode(ca, off, len);

    }

    static byte[] encode(Charset cs, char[] ca, int off, int len) {

        StringEncoder se = new StringEncoder(cs, cs.name());

        return se.encode(Arrays.copyOfRange(ca, off, off + len), 0, len);

    }

    static byte[] encode(char[] ca, int off, int len) {

        String csn = Charset.defaultCharset().name();

        try {

            return encode(csn, ca, off, len);

        } catch (UnsupportedEncodingException x) {

            warnUnsupportedCharset(csn);

        }

        try {

            return encode("ISO-8859-1", ca, off, len);

        } catch (UnsupportedEncodingException x) {

            // If this code is hit during VM initialization, MessageUtils is

            // the only way we will be able to get any kind of error message.

            MessageUtils.err("ISO-8859-1 charset not available: "

                             + x.toString());

            // If we can not find ISO-8859-1 (a required encoding) then things

            // are seriously wrong with the installation.

            System.exit(1);

            return null;

        }

    }

}