/*

 * 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.awt.datatransfer;

import sun.datatransfer.DataFlavorUtil;

import sun.datatransfer.DesktopDatatransferService;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.lang.ref.SoftReference;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

/**

 * The SystemFlavorMap is a configurable map between "natives" (Strings), which

 * correspond to platform-specific data formats, and "flavors" (DataFlavors),

 * which correspond to platform-independent MIME types. This mapping is used

 * by the data transfer subsystem to transfer data between Java and native

 * applications, and between Java applications in separate VMs.

 *

 * @since 1.2

 */

public final class SystemFlavorMap implements FlavorMap, FlavorTable {

    /**

     * Constant prefix used to tag Java types converted to native platform

     * type.

     */

    private static String JavaMIME = "JAVA_DATAFLAVOR:";

    private static final Object FLAVOR_MAP_KEY = new Object();

    /**

     * The list of valid, decoded text flavor representation classes, in order

     * from best to worst.

     */

    private static final String[] UNICODE_TEXT_CLASSES = {

        "java.io.Reader", "java.lang.String", "java.nio.CharBuffer", "\"[C\""

    };

    /**

     * The list of valid, encoded text flavor representation classes, in order

     * from best to worst.

     */

    private static final String[] ENCODED_TEXT_CLASSES = {

        "java.io.InputStream", "java.nio.ByteBuffer", "\"[B\""

    };

    /**

     * A String representing text/plain MIME type.

     */

    private static final String TEXT_PLAIN_BASE_TYPE = "text/plain";

    /**

     * A String representing text/html MIME type.

     */

    private static final String HTML_TEXT_BASE_TYPE = "text/html";

    /**

     * Maps native Strings to Lists of DataFlavors (or base type Strings for

     * text DataFlavors).

     * Do not use the field directly, use getNativeToFlavor() instead.

     */

    private final Map<String, LinkedHashSet<DataFlavor>> nativeToFlavor = new HashMap<>();

    /**

     * Accessor to nativeToFlavor map.  Since we use lazy initialization we must

     * use this accessor instead of direct access to the field which may not be

     * initialized yet.  This method will initialize the field if needed.

     *

     * @return nativeToFlavor

     */

    private Map<String, LinkedHashSet<DataFlavor>> getNativeToFlavor() {

        if (!isMapInitialized) {

            initSystemFlavorMap();

        }

        return nativeToFlavor;

    }

    /**

     * Maps DataFlavors (or base type Strings for text DataFlavors) to Lists of

     * native Strings.

     * Do not use the field directly, use getFlavorToNative() instead.

     */

    private final Map<DataFlavor, LinkedHashSet<String>> flavorToNative = new HashMap<>();

    /**

     * Accessor to flavorToNative map.  Since we use lazy initialization we must

     * use this accessor instead of direct access to the field which may not be

     * initialized yet.  This method will initialize the field if needed.

     *

     * @return flavorToNative

     */

    private synchronized Map<DataFlavor, LinkedHashSet<String>> getFlavorToNative() {

        if (!isMapInitialized) {

            initSystemFlavorMap();

        }

        return flavorToNative;

    }

    /**

     * Maps a text DataFlavor primary mime-type to the native. Used only to store

     * standard mappings registered in the flavormap.properties

     * Do not use this field directly, use getTextTypeToNative() instead.

     */

    private Map<String, LinkedHashSet<String>> textTypeToNative = new HashMap<>();

    /**

     * Shows if the object has been initialized.

     */

    private boolean isMapInitialized = false;

    /**

     * An accessor to textTypeToNative map.  Since we use lazy initialization we

     * must use this accessor instead of direct access to the field which may not

     * be initialized yet. This method will initialize the field if needed.

     *

     * @return textTypeToNative

     */

    private synchronized Map<String, LinkedHashSet<String>> getTextTypeToNative() {

        if (!isMapInitialized) {

            initSystemFlavorMap();

            // From this point the map should not be modified

            textTypeToNative = Collections.unmodifiableMap(textTypeToNative);

        }

        return textTypeToNative;

    }

    /**

     * Caches the result of getNativesForFlavor(). Maps DataFlavors to

     * SoftReferences which reference LinkedHashSet of String natives.

     */

    private final SoftCache<DataFlavor, String> nativesForFlavorCache = new SoftCache<>();

    /**

     * Caches the result getFlavorsForNative(). Maps String natives to

     * SoftReferences which reference LinkedHashSet of DataFlavors.

     */

    private final SoftCache<String, DataFlavor> flavorsForNativeCache = new SoftCache<>();

    /**

     * Dynamic mapping generation used for text mappings should not be applied

     * to the DataFlavors and String natives for which the mappings have been

     * explicitly specified with setFlavorsForNative() or

     * setNativesForFlavor(). This keeps all such keys.

     */

    private Set<Object> disabledMappingGenerationKeys = new HashSet<>();

    /**

     * Returns the default FlavorMap for this thread's ClassLoader.

     *

     * @return the default FlavorMap for this thread's ClassLoader

     */

    public static FlavorMap getDefaultFlavorMap() {

        return DataFlavorUtil.getDesktopService().getFlavorMap(SystemFlavorMap::new);

    }

    private SystemFlavorMap() {

    }

    /**

     * Initializes a SystemFlavorMap by reading flavormap.properties

     * For thread-safety must be called under lock on this.

     */

    private void initSystemFlavorMap() {

        if (isMapInitialized) {

            return;

        }

        isMapInitialized = true;

        InputStream is = SystemFlavorMap.class.getResourceAsStream("/sun/datatransfer/resources/flavormap.properties");

        if (is == null) {

            throw new InternalError("Default flavor mapping not found");

        }

        try (InputStreamReader isr = new InputStreamReader(is);

             BufferedReader reader = new BufferedReader(isr)) {

            String line;

            while ((line = reader.readLine()) != null) {

                line = line.trim();

                if (line.startsWith("#") || line.isEmpty()) continue;

                while (line.endsWith("\\")) {

                    line = line.substring(0, line.length() - 1) + reader.readLine().trim();

                }

                int delimiterPosition = line.indexOf('=');

                String[] values = line.substring(delimiterPosition + 1, line.length()).split(",");

                for (String value : values) {

                    try {

                        value = loadConvert(value);

                        MimeType mime = new MimeType(value);

                        if ("text".equals(mime.getPrimaryType())) {

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

                            if (DataFlavorUtil.doesSubtypeSupportCharset(mime.getSubType(), charset))

                            {

                                // We need to store the charset and eoln

                                // parameters, if any, so that the

                                // DataTransferer will have this information

                                // for conversion into the native format.

                                DesktopDatatransferService desktopService =

                                        DataFlavorUtil.getDesktopService();

                                if (desktopService.isDesktopPresent()) {

                                    desktopService.registerTextFlavorProperties(

                                            key, charset,

                                            mime.getParameter("eoln"),

                                            mime.getParameter("terminators"));

                                }

                            }

                            // But don't store any of these parameters in the

                            // DataFlavor itself for any text natives (even

                            // non-charset ones). The SystemFlavorMap will

                            // synthesize the appropriate mappings later.

                            mime.removeParameter("charset");

                            mime.removeParameter("class");

                            mime.removeParameter("eoln");

                            mime.removeParameter("terminators");

                            value = mime.toString();

                        }

                    } catch (MimeTypeParseException e) {

                        e.printStackTrace();

                        continue;

                    }

                    DataFlavor flavor;

                    try {

                        flavor = new DataFlavor(value);

                    } catch (Exception e) {

                        try {

                            flavor = new DataFlavor(value, null);

                        } catch (Exception ee) {

                            ee.printStackTrace();

                            continue;

                        }

                    }

                    final LinkedHashSet<DataFlavor> dfs = new LinkedHashSet<>();

                    dfs.add(flavor);

                    if ("text".equals(flavor.getPrimaryType())) {

                        dfs.addAll(convertMimeTypeToDataFlavors(value));

                        store(flavor.mimeType.getBaseType(), key, getTextTypeToNative());

                    }

                    for (DataFlavor df : dfs) {

                        store(df, key, getFlavorToNative());

                        store(key, df, getNativeToFlavor());

                    }

                }

            }

        } catch (IOException e) {

            throw new InternalError("Error reading default flavor mapping", e);

        }

    }

    // Copied from java.util.Properties

    private static String loadConvert(String theString) {

        char aChar;

        int len = theString.length();

        StringBuilder outBuffer = new StringBuilder(len);

        for (int x = 0; x < len; ) {

            aChar = theString.charAt(x++);

            if (aChar == '\\') {

                aChar = theString.charAt(x++);

                if (aChar == 'u') {

                    // Read the xxxx

                    int value = 0;

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

                        aChar = theString.charAt(x++);

                        switch (aChar) {

                            case '0': case '1': case '2': case '3': case '4':

                            case '5': case '6': case '7': case '8': case '9': {

                                value = (value << 4) + aChar - '0';

                                break;

                            }

                            case 'a': case 'b': case 'c':

                            case 'd': case 'e': case 'f': {

                                value = (value << 4) + 10 + aChar - 'a';

                                break;

                            }

                            case 'A': case 'B': case 'C':

                            case 'D': case 'E': case 'F': {

                                value = (value << 4) + 10 + aChar - 'A';

                                break;

                            }

                            default: {

                                throw new IllegalArgumentException(

                                        "Malformed \\uxxxx encoding.");

                            }

                        }

                    }

                    outBuffer.append((char)value);

                } else {

                    if (aChar == 't') {

                        aChar = '\t';

                    } else if (aChar == 'r') {

                        aChar = '\r';

                    } else if (aChar == 'n') {

                        aChar = '\n';

                    } else if (aChar == 'f') {

                        aChar = '\f';

                    }

                    outBuffer.append(aChar);

                }

            } else {

                outBuffer.append(aChar);

            }

        }

        return outBuffer.toString();

    }

    /**

     * Stores the listed object under the specified hash key in map. Unlike a

     * standard map, the listed object will not replace any object already at

     * the appropriate Map location, but rather will be appended to a List

     * stored in that location.

     */

    private <H, L> void store(H hashed, L listed, Map<H, LinkedHashSet<L>> map) {

        LinkedHashSet<L> list = map.get(hashed);

        if (list == null) {

            list = new LinkedHashSet<>(1);

            map.put(hashed, list);

        }

        if (!list.contains(listed)) {

            list.add(listed);

        }

    }

    /**

     * Semantically equivalent to 'nativeToFlavor.get(nat)'. This method

     * handles the case where 'nat' is not found in 'nativeToFlavor'. In that

     * case, a new DataFlavor is synthesized, stored, and returned, if and

     * only if the specified native is encoded as a Java MIME type.

     */

    private LinkedHashSet<DataFlavor> nativeToFlavorLookup(String nat) {

        LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(nat);

        if (nat != null && !disabledMappingGenerationKeys.contains(nat)) {

            DesktopDatatransferService desktopService = DataFlavorUtil.getDesktopService();

            if (desktopService.isDesktopPresent()) {

                LinkedHashSet<DataFlavor> platformFlavors =

                        desktopService.getPlatformMappingsForNative(nat);

                if (!platformFlavors.isEmpty()) {

                    if (flavors != null) {

                        // Prepending the platform-specific mappings ensures

                        // that the flavors added with

                        // addFlavorForUnencodedNative() are at the end of

                        // list.

                        platformFlavors.addAll(flavors);

                    }

                    flavors = platformFlavors;

                }

            }

        }

        if (flavors == null && isJavaMIMEType(nat)) {

            String decoded = decodeJavaMIMEType(nat);

            DataFlavor flavor = null;

            try {

                flavor = new DataFlavor(decoded);

            } catch (Exception e) {

                System.err.println("Exception \"" + e.getClass().getName() +

                                   ": " + e.getMessage()  +

                                   "\"while constructing DataFlavor for: " +

                                   decoded);

            }

            if (flavor != null) {

                flavors = new LinkedHashSet<>(1);

                getNativeToFlavor().put(nat, flavors);

                flavors.add(flavor);

                flavorsForNativeCache.remove(nat);

                LinkedHashSet<String> natives = getFlavorToNative().get(flavor);

                if (natives == null) {

                    natives = new LinkedHashSet<>(1);

                    getFlavorToNative().put(flavor, natives);

                }

                natives.add(nat);

                nativesForFlavorCache.remove(flavor);

            }

        }

        return (flavors != null) ? flavors : new LinkedHashSet<>(0);

    }

    /**

     * Semantically equivalent to 'flavorToNative.get(flav)'. This method

     * handles the case where 'flav' is not found in 'flavorToNative' depending

     * on the value of passes 'synthesize' parameter. If 'synthesize' is

     * SYNTHESIZE_IF_NOT_FOUND a native is synthesized, stored, and returned by

     * encoding the DataFlavor's MIME type. Otherwise an empty List is returned

     * and 'flavorToNative' remains unaffected.

     */

    private LinkedHashSet<String> flavorToNativeLookup(final DataFlavor flav,

                                                       final boolean synthesize) {

        LinkedHashSet<String> natives = getFlavorToNative().get(flav);

        if (flav != null && !disabledMappingGenerationKeys.contains(flav)) {

            DesktopDatatransferService desktopService = DataFlavorUtil.getDesktopService();

            if (desktopService.isDesktopPresent()) {

                LinkedHashSet<String> platformNatives =

                        desktopService.getPlatformMappingsForFlavor(flav);

                if (!platformNatives.isEmpty()) {

                    if (natives != null) {

                        // Prepend the platform-specific mappings to ensure

                        // that the natives added with

                        // addUnencodedNativeForFlavor() are at the end of

                        // list.

                        platformNatives.addAll(natives);

                    }

                    natives = platformNatives;

                }

            }

        }

        if (natives == null) {

            if (synthesize) {

                String encoded = encodeDataFlavor(flav);

                natives = new LinkedHashSet<>(1);

                getFlavorToNative().put(flav, natives);

                natives.add(encoded);

                LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(encoded);

                if (flavors == null) {

                    flavors = new LinkedHashSet<>(1);

                    getNativeToFlavor().put(encoded, flavors);

                }

                flavors.add(flav);

                nativesForFlavorCache.remove(flav);

                flavorsForNativeCache.remove(encoded);

            } else {

                natives = new LinkedHashSet<>(0);

            }

        }

        return new LinkedHashSet<>(natives);

    }

    /**

     * Returns a <code>List</code> of <code>String</code> natives to which the

     * specified <code>DataFlavor</code> can be translated by the data transfer

     * subsystem. The <code>List</code> will be sorted from best native to

     * worst. That is, the first native will best reflect data in the specified

     * flavor to the underlying native platform.

     * <p>

     * If the specified <code>DataFlavor</code> is previously unknown to the

     * data transfer subsystem and the data transfer subsystem is unable to

     * translate this <code>DataFlavor</code> to any existing native, then

     * invoking this method will establish a

     * mapping in both directions between the specified <code>DataFlavor</code>

     * and an encoded version of its MIME type as its native.

     *

     * @param flav the <code>DataFlavor</code> whose corresponding natives

     *        should be returned. If <code>null</code> is specified, all

     *        natives currently known to the data transfer subsystem are

     *        returned in a non-deterministic order.

     * @return a <code>java.util.List</code> of <code>java.lang.String</code>

     *         objects which are platform-specific representations of platform-

     *         specific data formats

     *

     * @see #encodeDataFlavor

     * @since 1.4

     */

    @Override

    public synchronized List<String> getNativesForFlavor(DataFlavor flav) {

        LinkedHashSet<String> retval = nativesForFlavorCache.check(flav);

        if (retval != null) {