/*

 * Copyright (c) 2003, 2013, 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.awt.X11;

import java.awt.datatransfer.Transferable;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.util.Hashtable;

import java.util.Map;

import sun.awt.AppContext;

import sun.awt.SunToolkit;

import sun.awt.UNIXToolkit;

import sun.awt.datatransfer.DataTransferer;

/**

 * A class which interfaces with the X11 selection service.

 */

public final class XSelection {

    /* Maps atoms to XSelection instances. */

    private static final Hashtable<XAtom, XSelection> table = new Hashtable<XAtom, XSelection>();

    /* Prevents from parallel selection data request processing. */

    private static final Object lock = new Object();

    /* The property in which the owner should place the requested data. */

    private static final XAtom selectionPropertyAtom = XAtom.get("XAWT_SELECTION");

    /* The maximal length of the property data. */

    public static final long MAX_LENGTH = 1000000;

    /*

     * The maximum data size for ChangeProperty request.

     * 100 is for the structure prepended to the request.

     */

    public static final int MAX_PROPERTY_SIZE;

    static {

        XToolkit.awtLock();

        try {

            MAX_PROPERTY_SIZE =

                (int)(XlibWrapper.XMaxRequestSize(XToolkit.getDisplay()) * 4 - 100);

        } finally {

            XToolkit.awtUnlock();

        }

    }

    /* The PropertyNotify event handler for incremental data transfer. */

    private static final XEventDispatcher incrementalTransferHandler =

        new IncrementalTransferHandler();

    /* The context for the current request - protected with awtLock. */

    private static WindowPropertyGetter propertyGetter = null;

    // The orders of the lock acquisition:

    //   XClipboard -> XSelection -> awtLock.

    //   lock -> awtLock.

    /* The X atom for the underlying selection. */

    private final XAtom selectionAtom;

    /*

     * Owner-related variables - protected with synchronized (this).

     */

    /* The contents supplied by the current owner. */

    private Transferable contents = null;

    /* The format-to-flavor map for the current owner. */

    private Map formatMap = null;

    /* The formats supported by the current owner was set. */

    private long[] formats = null;

    /* The AppContext in which the current owner was set. */

    private AppContext appContext = null;

    // The X server time of the last XConvertSelection() call;

    // protected with 'lock' and awtLock.

    private static long lastRequestServerTime;

    /* The time at which the current owner was set. */

    private long ownershipTime = 0;

    // True if we are the owner of this selection.

    private boolean isOwner;

    private OwnershipListener ownershipListener = null;

    private final Object stateLock = new Object();

    static {

        XToolkit.addEventDispatcher(XWindow.getXAWTRootWindow().getWindow(),

                                    new SelectionEventHandler());

    }

    /*

     * Returns the XSelection object for the specified selection atom or

     * <code>null</code> if none exists.

     */

    static XSelection getSelection(XAtom atom) {

        return table.get(atom);

    }

    /**

     * Creates a selection object.

     *

     * @param atom   the selection atom.

     * @param clpbrd the corresponding clipoboard

     * @exception NullPointerException if atom is <code>null</code>.

     */

    public XSelection(XAtom atom) {

        if (atom == null) {

            throw new NullPointerException("Null atom");

        }

        selectionAtom = atom;

        table.put(selectionAtom, this);

    }

    public XAtom getSelectionAtom() {

        return selectionAtom;

    }

    public synchronized boolean setOwner(Transferable contents, Map formatMap,

                                         long[] formats, long time)

    {

        long owner = XWindow.getXAWTRootWindow().getWindow();

        long selection = selectionAtom.getAtom();

        // ICCCM prescribes that CurrentTime should not be used for SetSelectionOwner.

        if (time == XConstants.CurrentTime) {

            time = XToolkit.getCurrentServerTime();

        }

        this.contents = contents;

        this.formatMap = formatMap;

        this.formats = formats;

        this.appContext = AppContext.getAppContext();

        this.ownershipTime = time;

        XToolkit.awtLock();

        try {

            XlibWrapper.XSetSelectionOwner(XToolkit.getDisplay(),

                                           selection, owner, time);

            if (XlibWrapper.XGetSelectionOwner(XToolkit.getDisplay(),

                                               selection) != owner)

            {

                reset();

                return false;

            }

            setOwnerProp(true);

            return true;

        } finally {

            XToolkit.awtUnlock();

        }

    }

    /**

     * Blocks the current thread till SelectionNotify or PropertyNotify (in case of INCR transfer) arrives.

     */

    private static void waitForSelectionNotify(WindowPropertyGetter dataGetter) throws InterruptedException {

        long startTime = System.currentTimeMillis();

        XToolkit.awtLock();

        try {

            do {

                DataTransferer.getInstance().processDataConversionRequests();

                XToolkit.awtLockWait(250);

            } while (propertyGetter == dataGetter && System.currentTimeMillis() < startTime + UNIXToolkit.getDatatransferTimeout());

        } finally {

            XToolkit.awtUnlock();

        }

    }

    /*

     * Returns the list of atoms that represent the targets for which an attempt

     * to convert the current selection will succeed.

     */

    public long[] getTargets(long time) {

        if (XToolkit.isToolkitThread()) {

            throw new Error("UNIMPLEMENTED");

        }

        long[] targets = null;

        synchronized (lock) {

            WindowPropertyGetter targetsGetter =

                new WindowPropertyGetter(XWindow.getXAWTRootWindow().getWindow(),

                                         selectionPropertyAtom, 0, MAX_LENGTH,

                                         true, XConstants.AnyPropertyType);

            try {

                XToolkit.awtLock();

                try {

                    propertyGetter = targetsGetter;

                    lastRequestServerTime = time;

                    XlibWrapper.XConvertSelection(XToolkit.getDisplay(),

                                                  getSelectionAtom().getAtom(),

                                                  XDataTransferer.TARGETS_ATOM.getAtom(),

                                                  selectionPropertyAtom.getAtom(),

                                                  XWindow.getXAWTRootWindow().getWindow(),

                                                  time);

                    // If the owner doesn't respond within the

                    // SELECTION_TIMEOUT, we report conversion failure.

                    try {

                        waitForSelectionNotify(targetsGetter);

                    } catch (InterruptedException ie) {

                        return new long[0];

                    } finally {

                        propertyGetter = null;

                    }

                } finally {

                    XToolkit.awtUnlock();

                }

                targets = getFormats(targetsGetter);

            } finally {

                targetsGetter.dispose();

            }

        }

        return targets;

    }

    static long[] getFormats(WindowPropertyGetter targetsGetter) {

        long[] formats = null;

        if (targetsGetter.isExecuted() && !targetsGetter.isDisposed() &&

                (targetsGetter.getActualType() == XAtom.XA_ATOM ||

                 targetsGetter.getActualType() == XDataTransferer.TARGETS_ATOM.getAtom()) &&

                targetsGetter.getActualFormat() == 32)

        {

            // we accept property with TARGETS type to be compatible with old jdks

            // see 6607163

            int count = targetsGetter.getNumberOfItems();

            if (count > 0) {

                long atoms = targetsGetter.getData();

                formats = new long[count];

                for (int index = 0; index < count; index++) {

                    formats[index] =

                            Native.getLong(atoms+index*XAtom.getAtomSize());

                }

            }

        }

        return formats != null ? formats : new long[0];

    }

    /*

     * Requests the selection data in the specified format and returns

     * the data provided by the owner.

     */

    public byte[] getData(long format, long time) throws IOException {

        if (XToolkit.isToolkitThread()) {

            throw new Error("UNIMPLEMENTED");

        }

        byte[] data = null;

        synchronized (lock) {

            WindowPropertyGetter dataGetter =

                new WindowPropertyGetter(XWindow.getXAWTRootWindow().getWindow(),

                                         selectionPropertyAtom, 0, MAX_LENGTH,

                                         false, // don't delete to handle INCR properly.

                                         XConstants.AnyPropertyType);

            try {

                XToolkit.awtLock();

                try {

                    propertyGetter = dataGetter;

                    lastRequestServerTime = time;

                    XlibWrapper.XConvertSelection(XToolkit.getDisplay(),

                                                  getSelectionAtom().getAtom(),

                                                  format,

                                                  selectionPropertyAtom.getAtom(),

                                                  XWindow.getXAWTRootWindow().getWindow(),

                                                  time);

                    // If the owner doesn't respond within the

                    // SELECTION_TIMEOUT, we report conversion failure.

                    try {

                        waitForSelectionNotify(dataGetter);

                    } catch (InterruptedException ie) {

                        return new byte[0];

                    } finally {

                        propertyGetter = null;

                    }

                } finally {

                    XToolkit.awtUnlock();

                }

                validateDataGetter(dataGetter);

                // Handle incremental transfer.

                if (dataGetter.getActualType() ==

                    XDataTransferer.INCR_ATOM.getAtom()) {

                    if (dataGetter.getActualFormat() != 32) {

                        throw new IOException("Unsupported INCR format: " +

                                              dataGetter.getActualFormat());

                    }

                    int count = dataGetter.getNumberOfItems();

                    if (count <= 0) {

                        throw new IOException("INCR data is missed.");

                    }

                    long ptr = dataGetter.getData();

                    int len = 0;

                    {

                        // Following Xt sources use the last element.

                        long longLength = Native.getLong(ptr, count-1);

                        if (longLength <= 0) {

                            return new byte[0];

                        }

                        if (longLength > Integer.MAX_VALUE) {

                            throw new IOException("Can't handle large data block: "

                                                  + longLength + " bytes");

                        }

                        len = (int)longLength;

                    }

                    dataGetter.dispose();

                    ByteArrayOutputStream dataStream = new ByteArrayOutputStream(len);

                    while (true) {

                        WindowPropertyGetter incrDataGetter =

                            new WindowPropertyGetter(XWindow.getXAWTRootWindow().getWindow(),

                                                     selectionPropertyAtom,

                                                     0, MAX_LENGTH, false,

                                                     XConstants.AnyPropertyType);

                        try {

                            XToolkit.awtLock();

                            XToolkit.addEventDispatcher(XWindow.getXAWTRootWindow().getWindow(),

                                                        incrementalTransferHandler);

                            propertyGetter = incrDataGetter;

                            try {

                                XlibWrapper.XDeleteProperty(XToolkit.getDisplay(),

                                                            XWindow.getXAWTRootWindow().getWindow(),

                                                            selectionPropertyAtom.getAtom());

                                // If the owner doesn't respond within the

                                // SELECTION_TIMEOUT, we terminate incremental

                                // transfer.

                                waitForSelectionNotify(incrDataGetter);

                            } catch (InterruptedException ie) {

                                break;

                            } finally {

                                propertyGetter = null;

                                XToolkit.removeEventDispatcher(XWindow.getXAWTRootWindow().getWindow(),

                                                               incrementalTransferHandler);

                                XToolkit.awtUnlock();

                            }

                            validateDataGetter(incrDataGetter);

                            if (incrDataGetter.getActualFormat() != 8) {

                                throw new IOException("Unsupported data format: " +

                                                      incrDataGetter.getActualFormat());

                            }

                            count = incrDataGetter.getNumberOfItems();

                            if (count == 0) {

                                break;

                            }

                            if (count > 0) {

                                ptr = incrDataGetter.getData();

                                for (int index = 0; index < count; index++) {

                                    dataStream.write(Native.getByte(ptr + index));

                                }

                            }

                            data = dataStream.toByteArray();

                        } finally {

                            incrDataGetter.dispose();

                        }

                    }

                } else {

                    XToolkit.awtLock();

                    try {

                        XlibWrapper.XDeleteProperty(XToolkit.getDisplay(),

                                                    XWindow.getXAWTRootWindow().getWindow(),

                                                    selectionPropertyAtom.getAtom());

                    } finally {

                        XToolkit.awtUnlock();

                    }

                    if (dataGetter.getActualFormat() != 8) {

                        throw new IOException("Unsupported data format: " +

                                              dataGetter.getActualFormat());

                    }

                    int count = dataGetter.getNumberOfItems();

                    if (count > 0) {

                        data = new byte[count];

                        long ptr = dataGetter.getData();

                        for (int index = 0; index < count; index++) {

                            data[index] = Native.getByte(ptr + index);

                        }

                    }

                }

            } finally {

                dataGetter.dispose();

            }

        }

        return data != null ? data : new byte[0];

    }

    void validateDataGetter(WindowPropertyGetter propertyGetter)

            throws IOException

    {

        // The order of checks is important because a property getter

        // has not been executed in case of timeout as well as in case of

        // changed selection owner.

        if (propertyGetter.isDisposed()) {

            throw new IOException("Owner failed to convert data");

        }

        // The owner didn't respond - terminate the transfer.

        if (!propertyGetter.isExecuted()) {

            throw new IOException("Owner timed out");

        }

    }

    // To be MT-safe this method should be called under awtLock.

    boolean isOwner() {

        return isOwner;

    }

    // To be MT-safe this method should be called under awtLock.

    private void setOwnerProp(boolean f) {

        isOwner = f;

        fireOwnershipChanges(isOwner);

    }

    private void lostOwnership() {

        setOwnerProp(false);

    }

    public synchronized void reset() {

        contents = null;

        formatMap = null;

        formats = null;

        appContext = null;

        ownershipTime = 0;

    }

    // Converts the data to the 'format' and if the conversion succeeded stores

    // the data in the 'property' on the 'requestor' window.

    // Returns true if the conversion succeeded.

    private boolean convertAndStore(long requestor, long format, long property) {

        int dataFormat = 8; /* Can choose between 8,16,32. */

        byte[] byteData = null;

        long nativeDataPtr = 0;

        int count = 0;

        try {

            SunToolkit.insertTargetMapping(this, appContext);

            byteData = DataTransferer.getInstance().convertData(this,

                                                                contents,

                                                                format,

                                                                formatMap,

                                                                XToolkit.isToolkitThread());

        } catch (IOException ioe) {

            return false;

        }

        if (byteData == null) {

            return false;

        }

        count = byteData.length;

        try {

            if (count > 0) {

                if (count <= MAX_PROPERTY_SIZE) {

                    nativeDataPtr = Native.toData(byteData);

                } else {

                    // Initiate incremental data transfer.

                    new IncrementalDataProvider(requestor, property, format, 8,

                                                byteData);

                    nativeDataPtr =

                        XlibWrapper.unsafe.allocateMemory(XAtom.getAtomSize());

                    Native.putLong(nativeDataPtr, (long)count);

                    format = XDataTransferer.INCR_ATOM.getAtom();

                    dataFormat = 32;

                    count = 1;

                }