/*
 * Copyright (c) 2010 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: barseghian $'
 * '$Date: 2011-02-12 02:25:44 +0000 (Sat, 12 Feb 2011) $' 
 * '$Revision: 27102 $'
 * 
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the above
 * copyright notice and the following two paragraphs appear in all copies
 * of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 * ENHANCEMENTS, OR MODIFICATIONS.
 *
 */


package org.kepler.reporting.gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.Toolkit;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.net.URL;

import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.TransferHandler;
import javax.swing.border.Border;

import org.kepler.reporting.rio.Item;


public class DragAndDropPanel extends JPanel implements Transferable{

        private Border ovalBorderselected = new OvalBorder(3, 3, Color.blue, Color.blue);
        protected Border ovalBorder = new OvalBorder(3, 3, Color.gray, Color.black);
        
        private static final int DRAG_AND_DROP_PANEL_WIDTH = 25000;
        public static final int DRAG_AND_DROP_PANEL_HEIGHT = 40;

        private Item associatedItem;
        private JRadioButton propertiesButton;
        private Component associatedComponent;
        
        private boolean selected;
        private static Toolkit toolkit = Toolkit.getDefaultToolkit();   
        private static URL dragcursorURL = getImageURL("movecursor", "gif");
        private static Image dragcursorImage = toolkit.getImage(dragcursorURL);
        private static Point dragcursorHotSpot = new Point(5,5);
        private static Cursor dragCursor = toolkit.createCustomCursor(dragcursorImage, dragcursorHotSpot, "DragCursor");        

        private ReportDesignerPanel _parentReportDesignerPanel;


        public DragAndDropPanel(ReportDesignerPanel reportDesignerPanel) {
                
                _parentReportDesignerPanel = reportDesignerPanel;

                this.addMouseListener(new DraggableMouseListener());

                this.setLayout(new BorderLayout());

                setFocusable(true);
                
                // Add the handler to negotiate between the drop target and this
                // draggable panel
                this.setTransferHandler(new DragAndDropTransferHandler());

                this.setBorder(ovalBorder);
                
                this.setOpaque(true);  // changed this

                Dimension dimension = new Dimension(DRAG_AND_DROP_PANEL_WIDTH,DRAG_AND_DROP_PANEL_HEIGHT);
                this.setPreferredSize(dimension);
                this.setMinimumSize(dimension);
                
                this.setToolTipText("Select, Drag & Drop to arrange report items");
        }

        //XXX i don't think this is ever called...?
        public Dimension setDimensions() {
                Dimension dim = new Dimension(500 * 25, 50);
                return dim;
        }

        //FIXME hardcode to images dir. search for others.
        public static URL getImageURL(String iconname, String extension) {
                String ImageLocation = "images/" + iconname + "." + extension;
                URL imageURL = ItemsOfInterestPanel.class.getResource(ImageLocation);
                return imageURL;
        }

        /**
         * 
         * <p>
         * One of three methods defined by the Transferable interface.
         * </p>
         * 
         * <p>
         * If multiple DataFlavor's are supported, can choose what Object to return.
         * </p>
         * 
         * <p>
         * In this case, we only support one: the actual JPanel.
         * </p>
         * 
         * <p>
         * Note we could easily support more than one. For example, if supports text
         * and drops to a JTextField, could return the label's text or any arbitrary
         * text.
         * </p>
         * 
         * @param flavor
         * 
         * @return
         */
        public Object getTransferData(DataFlavor flavor) {

                // Returning the data from the Transferable object.

                // Here, the actual panel is transfered.

                DataFlavor thisFlavor = null;

                try {
                        thisFlavor = ReportDesignerPanel.getDragAndDropPanelDataFlavor();
                } catch (Exception ex) {

                        System.err.println("Problem lazy loading: " + ex.getMessage());
                        ex.printStackTrace(System.err);
                        return null;
                }

                // For now, assume wants this class... see loadDnD
                if (thisFlavor != null && flavor.equals(thisFlavor)) {
                        return DragAndDropPanel.this;
                }
                
                return null;
        }

        /**
         * 
         * <p>
         * One of three methods defined by the Transferable interface.
         * </p>
         * 
         * <p>
         * Returns supported DataFlavor. Again, we're only supporting this actual
         * Object within the JVM.
         * </p>
         * 
         * <p>
         * For more information, see the JavaDoc for DataFlavor.
         * </p>
         * 
         * @return
         */
        public DataFlavor[] getTransferDataFlavors() {

                DataFlavor[] flavors = { null };

                // We Query for acceptable DataFlavors to determine what is available.

                // DragAndDropPanel class currently only supports DragAndDropPanel
                // DataFlavor.

                try {
                        // flavors[0] =
                        // DragAndDropPanelsDemo.getDragAndDropPanelDataFlavor();
                } catch (Exception ex) {
                        System.err.println("Problem lazy loading: " + ex.getMessage());
                        ex.printStackTrace(System.err);
                        return null;
                }

                return flavors;

        }

        /**
         * 
         * <p>
         * One of three methods defined by the Transferable interface.
         * </p>
         * 
         * <p>
         * Determines whether this object supports the DataFlavor.
         * 
         * In this case, only one is supported: for this object itself.
         * </p>
         * 
         * @param flavor
         * 
         * @return True if DataFlavor is supported, otherwise false.
         */
        public boolean isDataFlavorSupported(DataFlavor flavor) {

                DataFlavor[] flavors = { null };

                try {
                        flavors[0] = ReportDesignerPanel.getDragAndDropPanelDataFlavor();
                } catch (Exception ex) {
                        // System.err.println("Problem lazy loading: " + ex.getMessage());
                        // ex.printStackTrace(System.err);
                        return false;
                }

                for (DataFlavor f : flavors) {
                        if (f.equals(flavor)) {
                                return true;
                        }
                }

                return false;
        }
        

        class DraggableMouseListener extends MouseAdapter {

                @Override()
                public void mousePressed(MouseEvent e) {
                
                        JComponent c = (JComponent) e.getSource();

                        //c.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
                        
                        c.setCursor(dragCursor);

                        TransferHandler handler = c.getTransferHandler();
                        handler.exportAsDrag(c, e, TransferHandler.COPY);
                        
                        DragAndDropPanel clickedDnDPanel = (DragAndDropPanel) e.getSource();
                        DragAndDropPanel prevPanel = _parentReportDesignerPanel.getPrevPanel();

                        Item thecurrentitem = clickedDnDPanel.getAssociatedItem();
                        Item theprevitem = prevPanel.getAssociatedItem();

                        if (!thecurrentitem.equals(theprevitem)) {
                                
                                prevPanel.deselectPanel();
                                theprevitem.setSelected(false);
                                
                                _parentReportDesignerPanel.setCurrPanel(clickedDnDPanel);
                                clickedDnDPanel.selectPanel();
                                thecurrentitem.setSelected(true);
                                _parentReportDesignerPanel.setPrevPanel(clickedDnDPanel);

                        }

                        // System.out.println("The current item is: " + thecurrentitem);
                        // System.out.println("The prev item is: " + theprevitem);
                        
                        requestFocusInWindow();
                }

                public void mouseReleased(MouseEvent e) {
                        DragAndDropPanel releasedDnDPanel = (DragAndDropPanel) e.getSource();
                        _parentReportDesignerPanel.setPrevPanel(releasedDnDPanel);
                        
                }
                
                public void mouseEntered(MouseEvent e) {
                        DragAndDropPanel enteredDnDPanel = (DragAndDropPanel) e.getSource();
                        enteredDnDPanel.setCursor(dragCursor);
                }
                
                
                public void mouseExited(MouseEvent e) {
                        DragAndDropPanel exitedDnDPanel = (DragAndDropPanel) e.getSource();
                        exitedDnDPanel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
                }

        }

        /**
         * setAssociatedItem - important method that associates a report Item with a
         * specific DragAndDropPanel.
         * @param associatedItem
         */
        public void setAssociatedItem(Item associatedItem) {
                this.associatedItem = associatedItem;
        }

        public Item getAssociatedItem() {
                return associatedItem;
        }
        
        public void setPropertiesButton(JRadioButton propertiesButton) {
                this.propertiesButton = propertiesButton;
        }

        public void setAssociatedComponent(Component associatedComponent) {
                this.associatedComponent = associatedComponent;
        }

        public Component getAssociatedComponent() {
                return associatedComponent;
        }

        /**
         * 
         * selects the drag and drop panel
         * 
         * in the default manner by the source which originated it.
         */
        public void selectPanel() {
                
                setSelected(true);
                setBorder(ovalBorderselected);
                setOpaque(false);
                setBackground(new Color(6, 128, 255, 129).darker()); 
                
                propertiesButton.doClick();
        }
        
        public void setSelected(boolean s){
                selected = s;
        }

        public void deselectPanel() {
                setSelected(false);
                setBorder(ovalBorder);
                setBackground(Color.white);
        }

        public boolean isSelected() {
                return selected;
        }
        
        
        // @Override
            protected void paintComponent(Graphics g) {
                 
                 Color color1 = getBackground( );
                 Color color2 = color1.brighter();
                 
                Graphics2D g2d = (Graphics2D)g;
                
                int w = getWidth( );
                int h = getHeight( );
                 
                // Paint a gradient from top to bottom
                GradientPaint gp = new GradientPaint(
                    0, 0, color1,
                    0, h, color2 );

                g2d.setPaint( gp );
                //g2d.fillRect( 0, 0, w, h );
                
                g2d.fillRoundRect(0, 0, w, h, 20, 20);
                //case ROUNDRECT:
          // g.drawRoundRect(x, y, w, h, 20, 20);
          //  break;

                // Paint a gradient for the button
                GradientPaint background = new GradientPaint(0f, 0f, (new Color(6, 128, 255, 129)),
                        0f, (float)getHeight(), new Color(6, 128, 255, 129));
                g2d.setPaint(background);
                g2d.fillRoundRect(0, 0, getWidth(), 5*getHeight()/5, 20, 20);
                
                g2d.setColor(new Color(6, 128, 255, 129));
                
                // Paint a gradient
                background = new GradientPaint(0f, (float)4*getHeight()/8, 
                                new Color(128, 255, 128, 56),
                        0f, (float)getHeight(), new Color(6, 128, 255, 129));
                g2d.setPaint(background);
                g2d.fillRoundRect(0, 4*getHeight()/5, getWidth(), getHeight()/5, 20, 20);
                
                // Enable anti-aliasing to get smooth outlines
                g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                        RenderingHints.VALUE_ANTIALIAS_ON);
            }
        
        
}