/*

 * Copyright (c) 2015, 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.datatransfer;

import java.awt.datatransfer.DataFlavor;

import java.awt.datatransfer.FlavorMap;

import java.io.IOException;

import java.io.InputStream;

import java.io.Reader;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.charset.Charset;

import java.nio.charset.IllegalCharsetNameException;

import java.nio.charset.StandardCharsets;

import java.nio.charset.UnsupportedCharsetException;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.ServiceLoader;

import java.util.Set;

import java.util.SortedSet;

import java.util.TreeSet;

import java.util.function.Supplier;

/**

 * Utility class with different datatransfer helper functions

 *

 * @since 1.9

 */

public class DataFlavorUtil {

    private DataFlavorUtil() {

        // Avoid instantiation

    }

    private static Comparator<String> getCharsetComparator() {

       return CharsetComparator.INSTANCE;

    }

    public static Comparator<DataFlavor> getDataFlavorComparator() {

       return DataFlavorComparator.INSTANCE;

    }

    public static Comparator<Long> getIndexOrderComparator(Map<Long, Integer> indexMap) {

        return new IndexOrderComparator(indexMap);

    }

    public static Comparator<DataFlavor> getTextFlavorComparator() {

        return TextFlavorComparator.INSTANCE;

    }

    /**

     * Tracks whether a particular text/* MIME type supports the charset

     * parameter. The Map is initialized with all of the standard MIME types

     * listed in the DataFlavor.selectBestTextFlavor method comment. Additional

     * entries may be added during the life of the JRE for text/<other> types.

     */

    private static final Map<String, Boolean> textMIMESubtypeCharsetSupport;

    static {

        Map<String, Boolean> tempMap = new HashMap<>(17);

        tempMap.put("sgml", Boolean.TRUE);

        tempMap.put("xml", Boolean.TRUE);

        tempMap.put("html", Boolean.TRUE);

        tempMap.put("enriched", Boolean.TRUE);

        tempMap.put("richtext", Boolean.TRUE);

        tempMap.put("uri-list", Boolean.TRUE);

        tempMap.put("directory", Boolean.TRUE);

        tempMap.put("css", Boolean.TRUE);

        tempMap.put("calendar", Boolean.TRUE);

        tempMap.put("plain", Boolean.TRUE);

        tempMap.put("rtf", Boolean.FALSE);

        tempMap.put("tab-separated-values", Boolean.FALSE);

        tempMap.put("t140", Boolean.FALSE);

        tempMap.put("rfc822-headers", Boolean.FALSE);

        tempMap.put("parityfec", Boolean.FALSE);

        textMIMESubtypeCharsetSupport = Collections.synchronizedMap(tempMap);

    }

    /**

     * Lazy initialization of Standard Encodings.

     */

    private static class StandardEncodingsHolder {

        private static final SortedSet<String> standardEncodings = load();

        private static SortedSet<String> load() {

            final SortedSet<String> tempSet = new TreeSet<>(getCharsetComparator().reversed());

            tempSet.add("US-ASCII");

            tempSet.add("ISO-8859-1");

            tempSet.add("UTF-8");

            tempSet.add("UTF-16BE");

            tempSet.add("UTF-16LE");

            tempSet.add("UTF-16");

            tempSet.add(Charset.defaultCharset().name());

            return Collections.unmodifiableSortedSet(tempSet);

        }

    }

    /**

     * Returns a {@code SortedSet} of Strings which are a total order of the standard

     * character sets supported by the JRE. The ordering follows the same principles as

     * {@link java.awt.datatransfer.DataFlavor#selectBestTextFlavor(java.awt.datatransfer.DataFlavor[])}.

     * So as to avoid loading all available character converters, optional, non-standard,

     * character sets are not included.

     */

    public static Set<String> standardEncodings() {

        return StandardEncodingsHolder.standardEncodings;

    }

    /**

     * Converts an arbitrary text encoding to its canonical name.

     */

    public static String canonicalName(String encoding) {

        if (encoding == null) {

            return null;

        }

        try {

            return Charset.forName(encoding).name();

        } catch (IllegalCharsetNameException icne) {

            return encoding;

        } catch (UnsupportedCharsetException uce) {

            return encoding;

        }

    }

    /**

     * Tests only whether the flavor's MIME type supports the charset

     * parameter. Must only be called for flavors with a primary type of

     * "text".

     */

    public static boolean doesSubtypeSupportCharset(DataFlavor flavor) {

        String subType = flavor.getSubType();

        if (subType == null) {

            return false;

        }

        Boolean support = textMIMESubtypeCharsetSupport.get(subType);

        if (support != null) {

            return support;

        }

        boolean ret_val = (flavor.getParameter("charset") != null);

        textMIMESubtypeCharsetSupport.put(subType, ret_val);

        return ret_val;

    }

    public static boolean doesSubtypeSupportCharset(String subType,

                                                    String charset)

    {

        Boolean support = textMIMESubtypeCharsetSupport.get(subType);

        if (support != null) {

            return support;

        }

        boolean ret_val = (charset != null);

        textMIMESubtypeCharsetSupport.put(subType, ret_val);

        return ret_val;

    }

    /**

     * Returns whether this flavor is a text type which supports the

     * 'charset' parameter.

     */

    public static boolean isFlavorCharsetTextType(DataFlavor flavor) {

        // Although stringFlavor doesn't actually support the charset

        // parameter (because its primary MIME type is not "text"), it should

        // be treated as though it does. stringFlavor is semantically

        // equivalent to "text/plain" data.

        if (DataFlavor.stringFlavor.equals(flavor)) {

            return true;

        }

        if (!"text".equals(flavor.getPrimaryType()) ||

                !doesSubtypeSupportCharset(flavor))

        {

            return false;

        }

        Class<?> rep_class = flavor.getRepresentationClass();

        if (flavor.isRepresentationClassReader() ||

                String.class.equals(rep_class) ||

                flavor.isRepresentationClassCharBuffer() ||

                char[].class.equals(rep_class))

        {

            return true;

        }

        if (!(flavor.isRepresentationClassInputStream() ||

                flavor.isRepresentationClassByteBuffer() ||

                byte[].class.equals(rep_class))) {

            return false;

        }

        String charset = flavor.getParameter("charset");

        // null equals default encoding which is always supported

        return (charset == null) || isEncodingSupported(charset);

    }

    /**

     * Returns whether this flavor is a text type which does not support the

     * 'charset' parameter.

     */

    public static boolean isFlavorNoncharsetTextType(DataFlavor flavor) {

        if (!"text".equals(flavor.getPrimaryType()) || doesSubtypeSupportCharset(flavor)) {

            return false;

        }

        return (flavor.isRepresentationClassInputStream() ||

                flavor.isRepresentationClassByteBuffer() ||

                byte[].class.equals(flavor.getRepresentationClass()));

    }

    /**

     * If the specified flavor is a text flavor which supports the "charset"

     * parameter, then this method returns that parameter, or the default

     * charset if no such parameter was specified at construction. For non-

     * text DataFlavors, and for non-charset text flavors, this method returns

     * null.

     */

    public static String getTextCharset(DataFlavor flavor) {

        if (!isFlavorCharsetTextType(flavor)) {

            return null;

        }

        String encoding = flavor.getParameter("charset");

        return (encoding != null) ? encoding : Charset.defaultCharset().name();

    }

    /**

     * Determines whether this JRE can both encode and decode text in the

     * specified encoding.

     */

    private static boolean isEncodingSupported(String encoding) {

        if (encoding == null) {

            return false;

        }

        try {

            return Charset.isSupported(encoding);

        } catch (IllegalCharsetNameException icne) {

            return false;

        }

    }

    /**

     * Helper method to compare two objects by their Integer indices in the

     * given map. If the map doesn't contain an entry for either of the

     * objects, the fallback index will be used for the object instead.

     *

     * @param indexMap the map which maps objects into Integer indexes.

     * @param obj1 the first object to be compared.

     * @param obj2 the second object to be compared.

     * @param fallbackIndex the Integer to be used as a fallback index.

     * @return a negative integer, zero, or a positive integer as the

     *             first object is mapped to a less, equal to, or greater

     *             index than the second.

     */

    static <T> int compareIndices(Map<T, Integer> indexMap,

                                  T obj1, T obj2,

                                  Integer fallbackIndex) {

        Integer index1 = indexMap.getOrDefault(obj1, fallbackIndex);

        Integer index2 = indexMap.getOrDefault(obj2, fallbackIndex);

        return index1.compareTo(index2);

    }

    /**

     * An IndexedComparator which compares two String charsets. The comparison

     * follows the rules outlined in DataFlavor.selectBestTextFlavor. In order

     * to ensure that non-Unicode, non-ASCII, non-default charsets are sorted

     * in alphabetical order, charsets are not automatically converted to their

     * canonical forms.

     */

    private static class CharsetComparator implements Comparator<String> {

        static final CharsetComparator INSTANCE = new CharsetComparator();

        private static final Map<String, Integer> charsets;

        private static final Integer DEFAULT_CHARSET_INDEX = 2;

        private static final Integer OTHER_CHARSET_INDEX = 1;

        private static final Integer WORST_CHARSET_INDEX = 0;

        private static final Integer UNSUPPORTED_CHARSET_INDEX = Integer.MIN_VALUE;

        private static final String UNSUPPORTED_CHARSET = "UNSUPPORTED";

        static {

            Map<String, Integer> charsetsMap = new HashMap<>(8, 1.0f);

            // we prefer Unicode charsets

            charsetsMap.put(canonicalName("UTF-16LE"), 4);

            charsetsMap.put(canonicalName("UTF-16BE"), 5);

            charsetsMap.put(canonicalName("UTF-8"), 6);

            charsetsMap.put(canonicalName("UTF-16"), 7);

            // US-ASCII is the worst charset supported

            charsetsMap.put(canonicalName("US-ASCII"), WORST_CHARSET_INDEX);

            charsetsMap.putIfAbsent(Charset.defaultCharset().name(), DEFAULT_CHARSET_INDEX);

            charsetsMap.put(UNSUPPORTED_CHARSET, UNSUPPORTED_CHARSET_INDEX);

            charsets = Collections.unmodifiableMap(charsetsMap);

        }

        /**

         * Compares charsets. Returns a negative integer, zero, or a positive

         * integer as the first charset is worse than, equal to, or better than

         * the second.

         * <p>

         * Charsets are ordered according to the following rules:

         * <ul>

         * <li>All unsupported charsets are equal.

         * <li>Any unsupported charset is worse than any supported charset.

         * <li>Unicode charsets, such as "UTF-16", "UTF-8", "UTF-16BE" and

         *     "UTF-16LE", are considered best.

         * <li>After them, platform default charset is selected.

         * <li>"US-ASCII" is the worst of supported charsets.

         * <li>For all other supported charsets, the lexicographically less

         *     one is considered the better.

         * </ul>

         *

         * @param charset1 the first charset to be compared

         * @param charset2 the second charset to be compared.

         * @return a negative integer, zero, or a positive integer as the

         *             first argument is worse, equal to, or better than the

         *             second.

         */

        public int compare(String charset1, String charset2) {

            charset1 = getEncoding(charset1);

            charset2 = getEncoding(charset2);

            int comp = compareIndices(charsets, charset1, charset2, OTHER_CHARSET_INDEX);

            if (comp == 0) {

                return charset2.compareTo(charset1);

            }

            return comp;

        }

        /**

         * Returns encoding for the specified charset according to the

         * following rules:

         * <ul>

         * <li>If the charset is <code>null</code>, then <code>null</code> will

         *     be returned.

         * <li>Iff the charset specifies an encoding unsupported by this JRE,

         *     <code>UNSUPPORTED_CHARSET</code> will be returned.

         * <li>If the charset specifies an alias name, the corresponding

         *     canonical name will be returned iff the charset is a known

         *     Unicode, ASCII, or default charset.

         * </ul>

         *

         * @param charset the charset.

         * @return an encoding for this charset.

         */

        static String getEncoding(String charset) {

            if (charset == null) {

                return null;

            } else if (!isEncodingSupported(charset)) {

                return UNSUPPORTED_CHARSET;

            } else {

                // Only convert to canonical form if the charset is one

                // of the charsets explicitly listed in the known charsets

                // map. This will happen only for Unicode, ASCII, or default

                // charsets.

                String canonicalName = canonicalName(charset);

                return (charsets.containsKey(canonicalName))

                        ? canonicalName

                        : charset;

            }

        }

    }

    /**

     * An IndexedComparator which compares two DataFlavors. For text flavors,

     * the comparison follows the rules outlined in

     * DataFlavor.selectBestTextFlavor. For non-text flavors, unknown

     * application MIME types are preferred, followed by known

     * application/x-java-* MIME types. Unknown application types are preferred

     * because if the user provides his own data flavor, it will likely be the

     * most descriptive one. For flavors which are otherwise equal, the

     * flavors' string representation are compared in the alphabetical order.

     */

    private static class DataFlavorComparator implements Comparator<DataFlavor> {

        static final DataFlavorComparator INSTANCE = new DataFlavorComparator();

        private static final Map<String, Integer> exactTypes;

        private static final Map<String, Integer> primaryTypes;

        private static final Map<Class<?>, Integer> nonTextRepresentations;

        private static final Map<String, Integer> textTypes;

        private static final Map<Class<?>, Integer> decodedTextRepresentations;

        private static final Map<Class<?>, Integer> encodedTextRepresentations;

        private static final Integer UNKNOWN_OBJECT_LOSES = Integer.MIN_VALUE;

        private static final Integer UNKNOWN_OBJECT_WINS = Integer.MAX_VALUE;

        static {

            {

                Map<String, Integer> exactTypesMap = new HashMap<>(4, 1.0f);

                // application/x-java-* MIME types

                exactTypesMap.put("application/x-java-file-list", 0);

                exactTypesMap.put("application/x-java-serialized-object", 1);

                exactTypesMap.put("application/x-java-jvm-local-objectref", 2);

                exactTypesMap.put("application/x-java-remote-object", 3);

                exactTypes = Collections.unmodifiableMap(exactTypesMap);

            }

            {

                Map<String, Integer> primaryTypesMap = new HashMap<>(1, 1.0f);

                primaryTypesMap.put("application", 0);

                primaryTypes = Collections.unmodifiableMap(primaryTypesMap);

            }

            {

                Map<Class<?>, Integer> nonTextRepresentationsMap = new HashMap<>(3, 1.0f);

                nonTextRepresentationsMap.put(java.io.InputStream.class, 0);

                nonTextRepresentationsMap.put(java.io.Serializable.class, 1);

                nonTextRepresentationsMap.put(RMI.remoteClass(), 2);

                nonTextRepresentations = Collections.unmodifiableMap(nonTextRepresentationsMap);

            }

            {

                Map<String, Integer> textTypesMap = new HashMap<>(16, 1.0f);

                // plain text

                textTypesMap.put("text/plain", 0);

                // stringFlavor

                textTypesMap.put("application/x-java-serialized-object", 1);

                // misc

                textTypesMap.put("text/calendar", 2);

                textTypesMap.put("text/css", 3);

                textTypesMap.put("text/directory", 4);

                textTypesMap.put("text/parityfec", 5);

                textTypesMap.put("text/rfc822-headers", 6);

                textTypesMap.put("text/t140", 7);

                textTypesMap.put("text/tab-separated-values", 8);

                textTypesMap.put("text/uri-list", 9);

                // enriched

                textTypesMap.put("text/richtext", 10);

                textTypesMap.put("text/enriched", 11);

                textTypesMap.put("text/rtf", 12);

                // markup

                textTypesMap.put("text/html", 13);

                textTypesMap.put("text/xml", 14);

                textTypesMap.put("text/sgml", 15);

                textTypes = Collections.unmodifiableMap(textTypesMap);

            }

            {

                Map<Class<?>, Integer> decodedTextRepresentationsMap = new HashMap<>(4, 1.0f);

                decodedTextRepresentationsMap.put(char[].class, 0);

                decodedTextRepresentationsMap.put(CharBuffer.class, 1);

                decodedTextRepresentationsMap.put(String.class, 2);

                decodedTextRepresentationsMap.put(Reader.class, 3);

                decodedTextRepresentations =

                        Collections.unmodifiableMap(decodedTextRepresentationsMap);

            }

            {

                Map<Class<?>, Integer> encodedTextRepresentationsMap = new HashMap<>(3, 1.0f);

                encodedTextRepresentationsMap.put(byte[].class, 0);

                encodedTextRepresentationsMap.put(ByteBuffer.class, 1);

                encodedTextRepresentationsMap.put(InputStream.class, 2);

                encodedTextRepresentations =

                        Collections.unmodifiableMap(encodedTextRepresentationsMap);

            }

        }

        public int compare(DataFlavor flavor1, DataFlavor flavor2) {

            if (flavor1.equals(flavor2)) {

                return 0;

            }

            int comp;

            String primaryType1 = flavor1.getPrimaryType();