/*

 * Copyright (c) 2000, 2016, 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 java.lang;

import java.io.UnsupportedEncodingException;

import java.lang.ref.SoftReference;

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.CharacterCodingException;

import java.nio.charset.CoderResult;

import java.nio.charset.CodingErrorAction;

import java.nio.charset.IllegalCharsetNameException;

import java.nio.charset.UnsupportedCharsetException;

import java.util.Arrays;

import jdk.internal.HotSpotIntrinsicCandidate;

import sun.nio.cs.HistoricallyNamedCharset;

import sun.nio.cs.ArrayDecoder;

import sun.nio.cs.ArrayEncoder;

import static java.lang.String.LATIN1;

import static java.lang.String.UTF16;

import static java.lang.String.COMPACT_STRINGS;

import static java.nio.charset.StandardCharsets.ISO_8859_1;

import static java.nio.charset.StandardCharsets.US_ASCII;

import static java.nio.charset.StandardCharsets.UTF_8;

/**

 * Utility class for string encoding and decoding.

 */

class StringCoding {

    private StringCoding() { }

    /** The cached coders for each thread */

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

        new ThreadLocal<>();

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

        new ThreadLocal<>();

    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<>(ob));

    }

    // Trim the given byte array to the given length

    //

    private static byte[] safeTrim(byte[] ba, int len, boolean isTrusted) {

        if (len == ba.length && (isTrusted || System.getSecurityManager() == null))

            return ba;

        else

            return Arrays.copyOf(ba, 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 err(String) rather than the Logging API or System.err

            // since this method may be called during VM initialization

            // before either is available.

            err("WARNING: Default charset " + csn +

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

            warnUnsupportedCharset = false;

        }

    }

    static class Result {

        byte[] value;

        byte coder;

        Result with() {

            coder = COMPACT_STRINGS ? LATIN1 : UTF16;

            value = new byte[0];

            return this;

        }

        Result with(char[] val, int off, int len) {

            if (String.COMPACT_STRINGS) {

                byte[] bs = StringUTF16.compress(val, off, len);

                if (bs != null) {

                    value = bs;

                    coder = LATIN1;

                    return this;

                }

            }

            coder = UTF16;

            value = StringUTF16.toBytes(val, off, len);

            return this;

        }

        Result with(byte[] val, byte coder) {

            this.coder = coder;

            value = val;

            return this;

        }

    }

    @HotSpotIntrinsicCandidate

    public static boolean hasNegatives(byte[] ba, int off, int len) {

        for (int i = off; i < off + len; i++) {

            if (ba[i] < 0) {

                return true;

            }

        }

        return false;

    }

    // -- Decoding --

    static class StringDecoder {

        private final String requestedCharsetName;

        private final Charset cs;

        private final boolean isASCIICompatible;

        private final CharsetDecoder cd;

        protected final Result result;

        StringDecoder(Charset cs, String rcn) {

            this.requestedCharsetName = rcn;

            this.cs = cs;

            this.cd = cs.newDecoder()

                .onMalformedInput(CodingErrorAction.REPLACE)

                .onUnmappableCharacter(CodingErrorAction.REPLACE);

            this.result = new Result();

            this.isASCIICompatible = (cd instanceof ArrayDecoder) &&

                    ((ArrayDecoder)cd).isASCIICompatible();

        }

        String charsetName() {

            if (cs instanceof HistoricallyNamedCharset)

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

            return cs.name();

        }

        final String requestedCharsetName() {

            return requestedCharsetName;

        }

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

            if (len == 0) {

                return result.with();

            }

            // fastpath for ascii compatible

            if (isASCIICompatible && !hasNegatives(ba, off, len)) {

                if (COMPACT_STRINGS) {

                    return result.with(Arrays.copyOfRange(ba, off, off + len),

                                      LATIN1);

                } else {

                    return result.with(StringLatin1.inflate(ba, off, len), UTF16);

                }

            }

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

            char[] ca = new char[en];

            if (cd instanceof ArrayDecoder) {

                int clen = ((ArrayDecoder)cd).decode(ba, off, len, ca);

                return result.with(ca, 0, clen);

            }

            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 result.with(ca, 0, cb.position());

        }

    }

    private static class StringDecoder8859_1 extends StringDecoder {

        StringDecoder8859_1(Charset cs, String rcn) {

            super(cs, rcn);

        }

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

            if (COMPACT_STRINGS) {

                return result.with(Arrays.copyOfRange(ba, off, off + len), LATIN1);

            } else {

                return result.with(StringLatin1.inflate(ba, off, len), UTF16);

            }

        }

    }

    static Result 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) {

                    if (cs == UTF_8) {

                        sd = new StringDecoderUTF8(cs, csn);

                    } else if (cs == ISO_8859_1) {

                        sd = new StringDecoder8859_1(cs, csn);

                    } else {

                        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 Result decode(Charset cs, byte[] ba, int off, int len) {

        // (1)We never cache the "external" cs, the only benefit of creating

        // an additional StringDe/Encoder object to wrap it is to share the

        // de/encode() method. These SD/E objects are short-lived, the young-gen

        // gc should be able to take care of them well. But the best approach

        // is still not to generate them if not really necessary.

        // (2)The defensive copy of the input byte/char[] has a big performance

        // impact, as well as the outgoing result byte/char[]. Need to do the

        // optimization check of (sm==null && classLoader0==null) for both.

        // (3)getClass().getClassLoader0() is expensive

        // (4)There might be a timing gap in isTrusted setting. getClassLoader0()

        // is only checked (and then isTrusted gets set) when (SM==null). It is

        // possible that the SM==null for now but then SM is NOT null later

        // when safeTrim() is invoked...the "safe" way to do is to redundant

        // check (... && (isTrusted || SM == null || getClassLoader0())) in trim

        // but it then can be argued that the SM is null when the operation

        // is started...

        if (cs == UTF_8) {

            return StringDecoderUTF8.decode(ba, off, len, new Result());

        }

        CharsetDecoder cd = cs.newDecoder();

        // ascii fastpath

        if (cs == ISO_8859_1 || ((cd instanceof ArrayDecoder) &&

                                 ((ArrayDecoder)cd).isASCIICompatible() &&

                                 !hasNegatives(ba, off, len))) {

             if (COMPACT_STRINGS) {

                 return new Result().with(Arrays.copyOfRange(ba, off, off + len),

                                          LATIN1);

             } else {

                 return new Result().with(StringLatin1.inflate(ba, off, len), UTF16);

             }

        }

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

        if (len == 0) {

            return new Result().with();

        }

        if (System.getSecurityManager() != null &&

            cs.getClass().getClassLoader0() != null) {

            ba =  Arrays.copyOfRange(ba, off, off + len);

            off = 0;

        }

        cd.onMalformedInput(CodingErrorAction.REPLACE)

          .onUnmappableCharacter(CodingErrorAction.REPLACE)

          .reset();

        char[] ca = new char[en];

        if (cd instanceof ArrayDecoder) {

            int clen = ((ArrayDecoder)cd).decode(ba, off, len, ca);

            return new Result().with(ca, 0, clen);

        }

        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 new Result().with(ca, 0, cb.position());

    }

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

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

        try {

            // use charset name decode() variant which provides caching.

            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, err(String) is

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

            err("ISO-8859-1 charset not available: " + x.toString() + "\n");

            // 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 boolean isASCIICompatible;

        private final String requestedCharsetName;

        private final boolean isTrusted;

        private StringEncoder(Charset cs, String rcn) {

            this.requestedCharsetName = rcn;

            this.cs = cs;

            this.ce = cs.newEncoder()

                .onMalformedInput(CodingErrorAction.REPLACE)

                .onUnmappableCharacter(CodingErrorAction.REPLACE);

            this.isTrusted = (cs.getClass().getClassLoader0() == null);

            this.isASCIICompatible = (ce instanceof ArrayEncoder) &&

                    ((ArrayEncoder)ce).isASCIICompatible();

        }

        String charsetName() {

            if (cs instanceof HistoricallyNamedCharset)

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

            return cs.name();

        }

        final String requestedCharsetName() {

            return requestedCharsetName;

        }

        byte[] encode(byte coder, byte[] val) {

            // fastpath for ascii compatible

            if (coder == LATIN1 && isASCIICompatible &&

                !hasNegatives(val, 0, val.length)) {

                return Arrays.copyOf(val, val.length);

            }

            int len = val.length >> coder;  // assume LATIN1=0/UTF16=1;

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

            byte[] ba = new byte[en];

            if (len == 0) {

                return ba;

            }

            if (ce instanceof ArrayEncoder) {

                if (!isTrusted) {

                    val = Arrays.copyOf(val, val.length);

                }

                int blen = (coder == LATIN1 ) ? ((ArrayEncoder)ce).encodeFromLatin1(val, 0, len, ba)

                                              : ((ArrayEncoder)ce).encodeFromUTF16(val, 0, len, ba);

                if (blen != -1) {

                    return safeTrim(ba, blen, isTrusted);

                }

            }

            char[] ca = (coder == LATIN1 ) ? StringLatin1.toChars(val)

                                           : StringUTF16.toChars(val);

            ce.reset();

            ByteBuffer bb = ByteBuffer.wrap(ba);

            CharBuffer cb = CharBuffer.wrap(ca, 0, 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(), isTrusted);

        }

    }

    @HotSpotIntrinsicCandidate

    private static int implEncodeISOArray(byte[] sa, int sp,

                                          byte[] da, int dp, int len) {

        int i = 0;

        for (; i < len; i++) {

            char c = StringUTF16.getChar(sa, sp++);

            if (c > '\u00FF')

                break;

            da[dp++] = (byte)c;

        }

        return i;

    }

    static byte[] encode8859_1(byte coder, byte[] val) {

        if (coder == LATIN1) {

            return Arrays.copyOf(val, val.length);

        }

        int len = val.length >> 1;

        byte[] dst = new byte[len];

        int dp = 0;

        int sp = 0;

        int sl = len;

        while (sp < sl) {

            int ret = implEncodeISOArray(val, sp, dst, dp, len);

            sp = sp + ret;

            dp = dp + ret;

            if (ret != len) {

                char c = StringUTF16.getChar(val, sp++);

                if (Character.isHighSurrogate(c) && sp < sl &&

                    Character.isLowSurrogate(StringUTF16.getChar(val, sp))) {

                    sp++;

                }

                dst[dp++] = '?';

                len = sl - sp;

            }

        }

        if (dp == dst.length) {

            return dst;

        }

        return Arrays.copyOf(dst, dp);

    }

    static byte[] encodeASCII(byte coder, byte[] val) {

        if (coder == LATIN1) {

            byte[] dst = new byte[val.length];

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

                if (val[i] < 0) {

                    dst[i] = '?';

                } else {

                    dst[i] = val[i];

                }

            }

            return dst;

        }

        int len = val.length >> 1;

        byte[] dst = new byte[len];

        int dp = 0;

        for (int i = 0; i < len; i++) {

            char c = StringUTF16.getChar(val, i);

            if (c < 0x80) {

                dst[dp++] = (byte)c;

                continue;

            }

            if (Character.isHighSurrogate(c) && i + 1 < len &&

                Character.isLowSurrogate(StringUTF16.getChar(val, i + 1))) {

                i++;

            }

            dst[dp++] = '?';

        }

        if (len == dp) {

            return dst;

        }

        return Arrays.copyOf(dst, dp);

    }

   static byte[] encodeUTF8(byte coder, byte[] val) {