/*

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

import java.awt.event.ComponentEvent;

import java.awt.event.InvocationEvent;

import java.awt.event.WindowEvent;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import sun.awt.IconInfo;

import sun.util.logging.PlatformLogger;

import sun.awt.AWTAccessor;

import sun.awt.SunToolkit;

abstract class XDecoratedPeer extends XWindowPeer {

    private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XDecoratedPeer");

    private static final PlatformLogger insLog = PlatformLogger.getLogger("sun.awt.X11.insets.XDecoratedPeer");

    private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.X11.focus.XDecoratedPeer");

    private static final PlatformLogger iconLog = PlatformLogger.getLogger("sun.awt.X11.icon.XDecoratedPeer");

    // Set to true when we get the first ConfigureNotify after being

    // reparented - indicates that WM has adopted the top-level.

    boolean configure_seen;

    boolean insets_corrected;

    XIconWindow iconWindow;

    volatile WindowDimensions dimensions;

    XContentWindow content;

    volatile Insets currentInsets;

    XFocusProxyWindow focusProxy;

    static final Map<Class<?>,Insets> lastKnownInsets =

                                   Collections.synchronizedMap(new HashMap<>());

    XDecoratedPeer(Window target) {

        super(target);

    }

    XDecoratedPeer(XCreateWindowParams params) {

        super(params);

    }

    public long getShell() {

        return window;

    }

    public long getContentWindow() {

        return (content == null) ? window : content.getWindow();

    }

    void preInit(XCreateWindowParams params) {

        super.preInit(params);

        winAttr.initialFocus = true;

        currentInsets = new Insets(0,0,0,0);

        if (XWM.getWMID() == XWM.UNITY_COMPIZ_WM) {

            currentInsets = lastKnownInsets.get(getClass());

        }

        applyGuessedInsets();

        Rectangle bounds = (Rectangle)params.get(BOUNDS);

        dimensions = new WindowDimensions(bounds, getRealInsets(), false);

        params.put(BOUNDS, dimensions.getClientRect());

        if (insLog.isLoggable(PlatformLogger.Level.FINE)) {

            insLog.fine("Initial dimensions {0}", dimensions);

        }

        // Deny default processing of these events on the shell - proxy will take care of

        // them instead

        Long eventMask = (Long)params.get(EVENT_MASK);

        params.add(EVENT_MASK, Long.valueOf(eventMask.longValue() & ~(XConstants.FocusChangeMask | XConstants.KeyPressMask | XConstants.KeyReleaseMask)));

    }

    void postInit(XCreateWindowParams params) {

        // The size hints must be set BEFORE mapping the window (see 6895647)

        updateSizeHints(dimensions);

        // The super method maps the window if it's visible on the shared level

        super.postInit(params);

        // The lines that follow need to be in a postInit, so they

        // happen after the X window is created.

        setResizable(winAttr.initialResizability);

        XWM.requestWMExtents(getWindow());

        content = XContentWindow.createContent(this);

        if (warningWindow != null) {

            warningWindow.toFront();

        }

        focusProxy = createFocusProxy();

    }

    void setIconHints(java.util.List<IconInfo> icons) {

        if (!XWM.getWM().setNetWMIcon(this, icons)) {

            if (icons.size() > 0) {

                if (iconWindow == null) {

                    iconWindow = new XIconWindow(this);

                }

                iconWindow.setIconImages(icons);

            }

        }

    }

    public void updateMinimumSize() {

        super.updateMinimumSize();

        XToolkit.awtLock();

        try {

            updateMinSizeHints();

        } finally {

            XToolkit.awtUnlock();

        }

    }

    private void updateMinSizeHints() {

        if (isResizable()) {

            Dimension minimumSize = getTargetMinimumSize();

            if (minimumSize != null) {

                Insets insets = getRealInsets();

                int minWidth = minimumSize.width - insets.left - insets.right;

                int minHeight = minimumSize.height - insets.top - insets.bottom;

                if (minWidth < 0) minWidth = 0;

                if (minHeight < 0) minHeight = 0;

                setSizeHints(XUtilConstants.PMinSize | (isLocationByPlatform()?0:(XUtilConstants.PPosition | XUtilConstants.USPosition)),

                             getX(), getY(), minWidth, minHeight);

                if (isVisible()) {

                    Rectangle bounds = getShellBounds();

                    int nw = (bounds.width < minWidth) ? minWidth : bounds.width;

                    int nh = (bounds.height < minHeight) ? minHeight : bounds.height;

                    if (nw != bounds.width || nh != bounds.height) {

                        setShellSize(new Rectangle(0, 0, nw, nh));

                    }

                }

            } else {

                boolean isMinSizeSet = isMinSizeSet();

                XWM.removeSizeHints(this, XUtilConstants.PMinSize);

                /* Some WMs need remap to redecorate the window */

                if (isMinSizeSet && isShowing() && XWM.needRemap(this)) {

                    /*

                     * Do the re/mapping at the Xlib level.  Since we essentially

                     * work around a WM bug we don't want this hack to be exposed

                     * to Intrinsics (i.e. don't mess with grabs, callbacks etc).

                     */

                    xSetVisible(false);

                    XToolkit.XSync();

                    xSetVisible(true);

                }

            }

        }

    }

    XFocusProxyWindow createFocusProxy() {

        return new XFocusProxyWindow(this);

    }

    protected XAtomList getWMProtocols() {

        XAtomList protocols = super.getWMProtocols();

        protocols.add(wm_delete_window);

        protocols.add(wm_take_focus);

        return protocols;

    }

    public Graphics getGraphics() {

        AWTAccessor.ComponentAccessor compAccessor = AWTAccessor.getComponentAccessor();

        return getGraphics(content.surfaceData,

                           compAccessor.getForeground(target),

                           compAccessor.getBackground(target),

                           compAccessor.getFont(target));

    }

    public void setTitle(String title) {

        if (log.isLoggable(PlatformLogger.Level.FINE)) {

            log.fine("Title is " + title);

        }

        XToolkit.awtLock();

        try {

            winAttr.title = title;

            updateWMName();

        } finally {

            XToolkit.awtUnlock();

        }

    }

    protected String getWMName() {

            return " ";

        } else {

            return winAttr.title;

        }

    }

    void updateWMName() {

        XToolkit.awtLock();

        try {

            super.updateWMName();

            String name = getWMName();

                name = "Java";

            }

            XAtom iconNameAtom = XAtom.get(XAtom.XA_WM_ICON_NAME);

            iconNameAtom.setProperty(getWindow(), name);

            XAtom netIconNameAtom = XAtom.get("_NET_WM_ICON_NAME");

            netIconNameAtom.setPropertyUTF8(getWindow(), name);

        } finally {

            XToolkit.awtUnlock();

        }

    }

    // NOTE: This method may be called by privileged threads.

    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!

    public void handleIconify() {

        postEvent(new WindowEvent((Window)target, WindowEvent.WINDOW_ICONIFIED));

    }

    // NOTE: This method may be called by privileged threads.

    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!

    public void handleDeiconify() {

        postEvent(new WindowEvent((Window)target, WindowEvent.WINDOW_DEICONIFIED));

    }

    public void handleFocusEvent(XEvent xev) {

        super.handleFocusEvent(xev);

        XFocusChangeEvent xfe = xev.get_xfocus();

        // If we somehow received focus events forward it instead to proxy

        // FIXME: Shouldn't we instead check for inferrior?

        if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {

            focusLog.finer("Received focus event on shell: " + xfe);

        }

//         focusProxy.xRequestFocus();

   }

/***************************************************************************************

 *                             I N S E T S   C O D E

 **************************************************************************************/

    protected boolean isInitialReshape() {

        return false;

    }

    private static Insets difference(Insets i1, Insets i2) {

        return new Insets(i1.top-i2.top, i1.left - i2.left, i1.bottom-i2.bottom, i1.right-i2.right);

    }

    private static boolean isNull(Insets i) {

        return (i == null) || ((i.left | i.top | i.right | i.bottom) == 0);

    }

    private static Insets copy(Insets i) {

        return new Insets(i.top, i.left, i.bottom, i.right);

    }

    private Insets copyAndScaleDown(Insets i) {

        return new Insets(scaleDown(i.top), scaleDown(i.left),

                          scaleDown(i.bottom), scaleDown(i.right));

    }

    // insets which we get from WM (e.g from _NET_FRAME_EXTENTS)

    private Insets wm_set_insets;

    private Insets getWMSetInsets(XAtom changedAtom) {

        if (isEmbedded()) {

            return null;

        }

        if (wm_set_insets != null) {

            return wm_set_insets;

        }

        if (changedAtom == null) {

            wm_set_insets = XWM.getInsetsFromExtents(getWindow());

        } else {

            wm_set_insets = XWM.getInsetsFromProp(getWindow(), changedAtom);

        }

        if (insLog.isLoggable(PlatformLogger.Level.FINER)) {

            insLog.finer("FRAME_EXTENTS: {0}", wm_set_insets);

        }

        if (wm_set_insets != null) {

            wm_set_insets = copyAndScaleDown(wm_set_insets);

        }

        return wm_set_insets;

    }

    private void resetWMSetInsets() {

        if (XWM.getWMID() != XWM.UNITY_COMPIZ_WM) {

            currentInsets = new Insets(0, 0, 0, 0);

            wm_set_insets = null;

        } else {

            insets_corrected = false;

        }

    }

    public void handlePropertyNotify(XEvent xev) {

        super.handlePropertyNotify(xev);

        XPropertyEvent ev = xev.get_xproperty();

        if( !insets_corrected && isReparented() &&

                                         XWM.getWMID() == XWM.UNITY_COMPIZ_WM) {

            int state = XWM.getWM().getState(this);

            if ((state & Frame.MAXIMIZED_BOTH) ==  Frame.MAXIMIZED_BOTH) {

                // Stop ignoring ConfigureNotify because no extents will be sent

                // by WM for initially maximized decorated window.

                // Re-request window bounds to ensure actual dimensions and

                // notify the target with the initial size.

                insets_corrected = true;

                XlibWrapper.XConfigureWindow(XToolkit.getDisplay(),

                                                             getWindow(), 0, 0);

            }

        }

        if (ev.get_atom() == XWM.XA_KDE_NET_WM_FRAME_STRUT.getAtom()

            || ev.get_atom() == XWM.XA_NET_FRAME_EXTENTS.getAtom())

        {

            if (XWM.getWMID() != XWM.UNITY_COMPIZ_WM) {

                getWMSetInsets(XAtom.get(ev.get_atom()));

            } else {

                if (!isReparented()) {

                    return;

                }

                wm_set_insets = null;

                Insets in = getWMSetInsets(XAtom.get(ev.get_atom()));

                if (isNull(in)) {

                    return;

                }

                if (!isEmbedded() && !isTargetUndecorated()) {

                    lastKnownInsets.put(getClass(), in);

                }

                if (!in.equals(dimensions.getInsets())) {

                    if (insets_corrected || isMaximized()) {

                        currentInsets = in;

                        insets_corrected = true;

                        // insets were changed by WM. To handle this situation

                        // re-request window bounds because the current

                        // dimensions may be not actual as well.

                        XlibWrapper.XConfigureWindow(XToolkit.getDisplay(),

                                                             getWindow(), 0, 0);

                    } else {

                        // recalculate dimensions when window is just created

                        // and the initially guessed insets were wrong

                        handleCorrectInsets(in);

                    }

                } else if (!insets_corrected || !dimensions.isClientSizeSet()) {

                    insets_corrected = true;

                    // initial insets were guessed correctly. Re-request

                    // frame bounds because they may be changed by WM if the

                    // initial window position overlapped desktop's toolbars.

                    // This should initiate the final ConfigureNotify upon which

                    // the target will be notified with the final size.

                    XlibWrapper.XConfigureWindow(XToolkit.getDisplay(),

                                                             getWindow(), 0, 0);

                }

            }

        }

    }

    long reparent_serial = 0;

    public void handleReparentNotifyEvent(XEvent xev) {

        XReparentEvent  xe = xev.get_xreparent();

        if (insLog.isLoggable(PlatformLogger.Level.FINE)) {

            insLog.fine(xe.toString());

        }

        reparent_serial = xe.get_serial();

        long root = XlibWrapper.RootWindow(XToolkit.getDisplay(), getScreenNumber());

        if (isEmbedded()) {

            setReparented(true);

            insets_corrected = true;

            return;

        }

        if (getDecorations() == XWindowAttributesData.AWT_DECOR_NONE) {

            setReparented(true);

            insets_corrected = true;

            reshape(dimensions, SET_SIZE, false);

        } else if (xe.get_parent() == root) {

            configure_seen = false;

            insets_corrected = false;

            /*

             * We can be repareted to root for two reasons:

             *   . setVisible(false)

             *   . WM exited

             */

            if (isVisible()) { /* WM exited */

                /* Work around 4775545 */

                XWM.getWM().unshadeKludge(this);

                insLog.fine("- WM exited");

            } else {

                insLog.fine(" - reparent due to hide");

            }

        } else { /* reparented to WM frame, figure out our insets */

            setReparented(true);

            insets_corrected = false;

            if (XWM.getWMID() == XWM.UNITY_COMPIZ_WM) {

                return;

            }

            // Check if we have insets provided by the WM

            Insets correctWM = getWMSetInsets(null);

            if (correctWM != null) {

                if (insLog.isLoggable(PlatformLogger.Level.FINER)) {

                    insLog.finer("wm-provided insets {0}", correctWM);

                }

                // If these insets are equal to our current insets - no actions are necessary

                Insets dimInsets = dimensions.getInsets();

                if (correctWM.equals(dimInsets)) {

                    insLog.finer("Insets are the same as estimated - no additional reshapes necessary");

                    no_reparent_artifacts = true;

                    insets_corrected = true;

                    applyGuessedInsets();

                    return;

                }

            } else {

                correctWM = XWM.getWM().getInsets(this, xe.get_window(), xe.get_parent());

                if (correctWM != null) {

                    correctWM = copyAndScaleDown(correctWM);

                }

                if (insLog.isLoggable(PlatformLogger.Level.FINER)) {

                    if (correctWM != null) {

                        insLog.finer("correctWM {0}", correctWM);

                    } else {

                        insLog.finer("correctWM insets are not available, waiting for configureNotify");

                    }

                }

            }

            if (correctWM != null) {

                handleCorrectInsets(correctWM);

            }

        }

    }

    private void handleCorrectInsets(Insets correctWM) {

        /*

         * Ok, now see if we need adjust window size because

         * initial insets were wrong (most likely they were).

         */

        Insets correction = difference(correctWM, currentInsets);

        if (insLog.isLoggable(PlatformLogger.Level.FINEST)) {

            insLog.finest("Corrention {0}", correction);

        }

        if (!isNull(correction)) {

            currentInsets = copy(correctWM);

            applyGuessedInsets();

            //Fix for 6318109: PIT: Min Size is not honored properly when a

            //smaller size is specified in setSize(), XToolkit

            //update minimum size hints

            updateMinSizeHints();

        }

        if (insLog.isLoggable(PlatformLogger.Level.FINER)) {

            insLog.finer("Dimensions before reparent: " + dimensions);

        }

        WindowDimensions newDimensions = new WindowDimensions(dimensions);

        newDimensions.setInsets(getRealInsets());

        dimensions = newDimensions;

        insets_corrected = true;

        if (isMaximized()) {

            return;

        }

        /*

         * If this window has been sized by a pack() we need

         * to keep the interior geometry intact.  Since pack()

         * computed width and height with wrong insets, we

         * must adjust the target dimensions appropriately.

         */

        if ((getHints().get_flags() & (XUtilConstants.USPosition | XUtilConstants.PPosition)) != 0) {

            reshape(dimensions, SET_BOUNDS, false);

        } else {

            reshape(dimensions, SET_SIZE, false);

        }