/*

 * Copyright (c) 2011, 2012, 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.lwawt;

import java.awt.*;

import java.awt.dnd.DropTarget;

import java.awt.dnd.peer.DropTargetPeer;

import java.awt.event.*;

import java.awt.image.ColorModel;

import java.awt.image.ImageObserver;

import java.awt.image.ImageProducer;

import java.awt.image.VolatileImage;

import java.awt.peer.ComponentPeer;

import java.awt.peer.ContainerPeer;

import java.awt.peer.KeyboardFocusManagerPeer;

import java.util.concurrent.atomic.AtomicBoolean;

import java.lang.reflect.Field;

import java.security.AccessController;

import java.security.PrivilegedAction;

import sun.awt.*;

import sun.awt.event.IgnorePaintEvent;

import sun.awt.image.SunVolatileImage;

import sun.awt.image.ToolkitImage;

import sun.java2d.SunGraphics2D;

import sun.java2d.opengl.OGLRenderQueue;

import sun.java2d.pipe.Region;

import sun.util.logging.PlatformLogger;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import javax.swing.RepaintManager;

import sun.lwawt.macosx.CDropTarget;

import com.sun.java.swing.SwingUtilities3;

public abstract class LWComponentPeer<T extends Component, D extends JComponent>

    implements ComponentPeer, DropTargetPeer

{

    private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.lwawt.focus.LWComponentPeer");

    // State lock is to be used for modifications to this

    // peer's fields (e.g. bounds, background, font, etc.)

    // It should be the last lock in the lock chain

    private final Object stateLock =

            new StringBuilder("LWComponentPeer.stateLock");

    // The lock to operate with the peers hierarchy. AWT tree

    // lock is not used as there are many peers related ops

    // to be done on the toolkit thread, and we don't want to

    // depend on a public lock on this thread

    private static final Object peerTreeLock =

            new StringBuilder("LWComponentPeer.peerTreeLock");

    private final T target;

    // Container peer. It may not be the peer of the target's direct

    // parent, for example, in the case of hw/lw mixing. However,

    // let's skip this scenario for the time being. We also assume

    // the container peer is not null, which might also be false if

    // addNotify() is called for a component outside of the hierarchy.

    // The exception is LWWindowPeers: their parents are always null

    private LWContainerPeer containerPeer;

    // Handy reference to the top-level window peer. Window peer is

    // borrowed from the containerPeer in constructor, and should also

    // be updated when the component is reparented to another container

    private LWWindowPeer windowPeer;

    private final AtomicBoolean disposed = new AtomicBoolean(false);

    // Bounds are relative to parent peer

    private final Rectangle bounds = new Rectangle();

    private Region region;

    // Component state. Should be accessed under the state lock

    private boolean visible = false;

    private boolean enabled = true;

    private Color background;

    private Color foreground;

    private Font font;

    /**

     * Paint area to coalesce all the paint events and store the target dirty

     * area.

     */

    private final RepaintArea targetPaintArea;

    //   private volatile boolean paintPending;

    private volatile boolean isLayouting;

    private final D delegate;

    private Container delegateContainer;

    private Component delegateDropTarget;

    private final Object dropTargetLock = new Object();

    private int fNumDropTargets = 0;

    private CDropTarget fDropTarget = null;

    private final PlatformComponent platformComponent;

    /**

     * Character with reasonable value between the minimum width and maximum.

     */

    static final char WIDE_CHAR = '0';

    /**

     * The back buffer provide user with a BufferStrategy.

     */

    private Image backBuffer;

    private final class DelegateContainer extends Container {

        {

            enableEvents(0xFFFFFFFF);

        }

        DelegateContainer() {

            super();

        }

        @Override

        public boolean isLightweight() {

            return false;

        }

        @Override

        public Point getLocation() {

            return getLocationOnScreen();

        }

        @Override

        public Point getLocationOnScreen() {

            return LWComponentPeer.this.getLocationOnScreen();

        }

        @Override

        public int getX() {

            return getLocation().x;

        }

        @Override

        public int getY() {

            return getLocation().y;

        }

    }

    public LWComponentPeer(T target, PlatformComponent platformComponent) {

        targetPaintArea = new LWRepaintArea();

        this.target = target;

        this.platformComponent = platformComponent;

        initializeContainerPeer();

        // Container peer is always null for LWWindowPeers, so

        // windowPeer is always null for them as well. On the other

        // hand, LWWindowPeer shouldn't use windowPeer at all

        if (containerPeer != null) {

            windowPeer = containerPeer.getWindowPeerOrSelf();

        }

        // don't bother about z-order here as updateZOrder()

        // will be called from addNotify() later anyway

        if (containerPeer != null) {

            containerPeer.addChildPeer(this);

        }

        // the delegate must be created after the target is set

        AWTEventListener toolkitListener = null;

        synchronized (Toolkit.getDefaultToolkit()) {

            try {

                toolkitListener = getToolkitAWTEventListener();

                setToolkitAWTEventListener(null);

                synchronized (getDelegateLock()) {

                    delegate = createDelegate();

                    if (delegate != null) {

                        delegate.setVisible(false);

                        delegateContainer = new DelegateContainer();

                        delegateContainer.add(delegate);

                        delegateContainer.addNotify();

                        delegate.addNotify();

                        resetColorsAndFont(delegate);

                        delegate.setOpaque(true);

                    } else {

                        return;

                    }

                }

            } finally {

                setToolkitAWTEventListener(toolkitListener);

            }

            // todo swing: later on we will probably have one global RM

            SwingUtilities3.setDelegateRepaintManager(delegate, new RepaintManager() {

                @Override

                public void addDirtyRegion(final JComponent c, final int x, final int y, final int w, final int h) {

                    repaintPeer(SwingUtilities.convertRectangle(

                            c, new Rectangle(x, y, w, h), getDelegate()));

                }

            });

        }

    }

    /**

     * This method must be called under Toolkit.getDefaultToolkit() lock

     * and followed by setToolkitAWTEventListener()

     */

    protected final AWTEventListener getToolkitAWTEventListener() {

        return AccessController.doPrivileged(new PrivilegedAction<AWTEventListener>() {

            public AWTEventListener run() {

                Toolkit toolkit = Toolkit.getDefaultToolkit();

                try {

                    Field field = Toolkit.class.getDeclaredField("eventListener");

                    field.setAccessible(true);

                    return (AWTEventListener) field.get(toolkit);

                } catch (Exception e) {

                    throw new InternalError(e.toString());

                }

            }

        });

    }

    protected final void setToolkitAWTEventListener(final AWTEventListener listener) {

        AccessController.doPrivileged(new PrivilegedAction<Void>() {

            public Void run() {

                Toolkit toolkit = Toolkit.getDefaultToolkit();

                try {

                    Field field = Toolkit.class.getDeclaredField("eventListener");

                    field.setAccessible(true);

                    field.set(toolkit, listener);

                } catch (Exception e) {

                    throw new InternalError(e.toString());

                }

                return null;

            }

        });

    }

    /**

     * This method is called under getDelegateLock().

     * Overridden in subclasses.

     */

    protected D createDelegate() {

        return null;

    }

    protected final D getDelegate() {

        return delegate;

    }

    protected Component getDelegateFocusOwner() {

        return getDelegate();

    }

    /**

     * Initializes this peer. The call to initialize() is not placed to

     * LWComponentPeer ctor to let the subclass ctor to finish completely first.

     * Instead, it's the LWToolkit object who is responsible for initialization.

     * Note that we call setVisible() at the end of initialization.

     */

    public final void initialize() {

        platformComponent.initialize(getPlatformWindow());

        initializeImpl();

        setVisible(target.isVisible());

    }

    /**

     * Fetching general properties from the target. Should be overridden in

     * subclasses to initialize specific peers properties.

     */

    void initializeImpl() {

        setBackground(target.getBackground());

        setForeground(target.getForeground());

        setFont(target.getFont());

        setBounds(target.getBounds());

        setEnabled(target.isEnabled());

    }

    private static void resetColorsAndFont(final Container c) {

        c.setBackground(null);

        c.setForeground(null);

        c.setFont(null);

        for (int i = 0; i < c.getComponentCount(); i++) {

            resetColorsAndFont((Container) c.getComponent(i));

        }

    }

    final Object getStateLock() {

        return stateLock;

    }

    /**

     * Synchronize all operations with the Swing delegates under AWT tree lock,

     * using a new separate lock to synchronize access to delegates may lead

     * deadlocks. Think of it as a 'virtual EDT'.

     *

     * @return DelegateLock

     */

    final Object getDelegateLock() {

        return getTarget().getTreeLock();

    }

    protected static final Object getPeerTreeLock() {

        return peerTreeLock;

    }

        return target;

    }

    // Just a helper method

    // Returns the window peer or null if this is a window peer

    protected final LWWindowPeer getWindowPeer() {

        return windowPeer;

    }

    // Returns the window peer or 'this' if this is a window peer

    protected LWWindowPeer getWindowPeerOrSelf() {

        return getWindowPeer();

    }

    // Just a helper method

    protected final LWContainerPeer getContainerPeer() {

        return containerPeer;

    }

    // Just a helper method

    // Overridden in LWWindowPeer to skip containerPeer initialization

    protected void initializeContainerPeer() {

        Container parent = LWToolkit.getNativeContainer(target);

        if (parent != null) {

            containerPeer = (LWContainerPeer) LWToolkit.targetToPeer(parent);

        }

    }

    public PlatformWindow getPlatformWindow() {

        LWWindowPeer windowPeer = getWindowPeer();

        return windowPeer.getPlatformWindow();

    }

    protected AppContext getAppContext() {

        return SunToolkit.targetToAppContext(getTarget());

    }

    // ---- PEER METHODS ---- //

    @Override

    public Toolkit getToolkit() {

        return LWToolkit.getLWToolkit();

    }

    // Just a helper method

    public LWToolkit getLWToolkit() {

        return LWToolkit.getLWToolkit();

    }

    @Override

    public final void dispose() {

        if (disposed.compareAndSet(false, true)) {

            disposeImpl();

        }

    }

    protected void disposeImpl() {

        destroyBuffers();

        LWContainerPeer cp = getContainerPeer();

        if (cp != null) {

            cp.removeChildPeer(this);

        }

        platformComponent.dispose();

        LWToolkit.targetDisposedPeer(getTarget(), this);

    }

    public final boolean isDisposed() {

        return disposed.get();

    }

    /*

     * GraphicsConfiguration is borrowed from the parent peer. The

     * return value must not be null.

     *

     * Overridden in LWWindowPeer.

     */

    @Override

    public GraphicsConfiguration getGraphicsConfiguration() {

        // Don't check windowPeer for null as it can only happen

        // for windows, but this method is overridden in

        // LWWindowPeer and doesn't call super()

        return getWindowPeer().getGraphicsConfiguration();

    }

    // Just a helper method

    public final LWGraphicsConfig getLWGC() {

        return (LWGraphicsConfig) getGraphicsConfiguration();

    }

    /*

     * Overridden in LWWindowPeer to replace its surface

     * data and back buffer.

     */

    @Override

    public boolean updateGraphicsData(GraphicsConfiguration gc) {

        // TODO: not implemented

//        throw new RuntimeException("Has not been implemented yet.");

        return false;

    }

    @Override

    public Graphics getGraphics() {

        final Graphics g = getOnscreenGraphics();

        if (g != null) {

            synchronized (getPeerTreeLock()){

                applyConstrain(g);

            }

        }

        return g;

    }

    /*

     * Peer Graphics is borrowed from the parent peer, while

     * foreground and background colors and font are specific to

     * this peer.

     */

    public final Graphics getOnscreenGraphics() {

        final LWWindowPeer wp = getWindowPeerOrSelf();

        return wp.getOnscreenGraphics(getForeground(), getBackground(),

                                      getFont());

    }

    private void applyConstrain(final Graphics g) {

        final SunGraphics2D sg2d = (SunGraphics2D) g;

        final Rectangle constr = localToWindow(getSize());

        // translate and set rectangle constrain.

        sg2d.constrain(constr.x, constr.y, constr.width, constr.height);

        // set region constrain.

        //sg2d.constrain(getVisibleRegion());

        SG2DConstraint(sg2d, getVisibleRegion());

    }

    //TODO Move this method to SG2D?

    void SG2DConstraint(final SunGraphics2D sg2d, Region r) {

        sg2d.constrainX = sg2d.transX;

        sg2d.constrainY = sg2d.transY;

        Region c = sg2d.constrainClip;

        if ((sg2d.constrainX | sg2d.constrainY) != 0) {

            r = r.getTranslatedRegion(sg2d.constrainX, sg2d.constrainY);

        }

        if (c == null) {

            c = r;

        } else {

            c = c.getIntersection(r);

            if (c == sg2d.constrainClip) {

                // Common case to ignore

                return;

            }

        }

        sg2d.constrainClip = c;

        //validateCompClip() forced call.

        sg2d.setDevClip(r.getLoX(), r.getLoY(), r.getWidth(), r.getHeight());

    }

    public Region getVisibleRegion() {

        return computeVisibleRect(this, getRegion());

    }

    static final Region computeVisibleRect(LWComponentPeer c, Region region) {

        final LWContainerPeer p = c.getContainerPeer();

        if (p != null) {

            final Rectangle r = c.getBounds();

            region = region.getTranslatedRegion(r.x, r.y);

            region = region.getIntersection(p.getRegion());

            region = region.getIntersection(p.getContentSize());

            region = p.cutChildren(region, c);

            region = computeVisibleRect(p, region);

            region = region.getTranslatedRegion(-r.x, -r.y);

        }

        return region;

    }

    @Override

    public ColorModel getColorModel() {

        // Is it a correct implementation?

        return getGraphicsConfiguration().getColorModel();

    }