/**
 * Copyright 2010 The Kuali Foundation Licensed under the
 * Educational Community License, Version 2.0 (the "License"); you may
 * not use this file except in compliance with the License. You may
 * obtain a copy of the License at
 *
 * http://www.osedu.org/licenses/ECL-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an "AS IS"
 * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

package org.kuali.student.common.ui.client.widgets;

import java.util.Arrays;
import java.util.List;

import com.google.gwt.dom.client.Element;
import com.google.gwt.dom.client.NativeEvent;
import com.google.gwt.dom.client.NodeList;
import com.google.gwt.dom.client.Style.Overflow;
import com.google.gwt.dom.client.Style.Unit;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.event.logical.shared.ResizeEvent;
import com.google.gwt.event.logical.shared.ResizeHandler;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.user.client.Command;
import com.google.gwt.user.client.DeferredCommand;
import com.google.gwt.user.client.Event.NativePreviewEvent;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Anchor;
import com.google.gwt.user.client.ui.DialogBox;
import com.google.gwt.user.client.ui.DockLayoutPanel;
import com.google.gwt.user.client.ui.FlowPanel;
import com.google.gwt.user.client.ui.ScrollPanel;
import com.google.gwt.user.client.ui.SimplePanel;
import com.google.gwt.user.client.ui.Widget;

/**
 * A KSLightBox is a dialog box that lays out its contents as follows using a
 * {@link DockLayoutPanel}:<br/>
 * <br />
 * ------------------<br/>
 * HEADER (either static caption / header widget that is not part of the scrollable area)<br/>
 * ------------------<br/>
 * CONTENT (part of the scrollable area that will fill available space)<br/>
 * ------------------<br/>
 * BUTTONS (static button area that is not part of the scrollable area)<br/>
 * ------------------<br/>
 * <br/>
 * 
 * The size of the dock panel will determine the size of the lightbox. Thus only the dock
 * panel size will need to be set.<br/>
 * The size of the dock panel is usually determined dynamically when the lightbox is
 * displayed, but you can also statically set it with one of the 'setSize' methods.<br/>
 * If you however set the size statically, the lightbox won't resize.<br/>
 * If you're making use of the <b>static sizes, the non-caption header and displaying the
 * buttons</b>, don't set the height of the dialog smaller than about 155px. Otherwise
 * there's too little space left for the content and the content (even if its just one line 
 * of text) will be displayed in a scroll panel.
 * 
 */
public class KSLightBox extends DialogBox {

    private static final List<String> FOCUSABLE_TAGS = Arrays.asList("INPUT", "SELECT", "BUTTON", "TEXTAREA");

    /**
     * An enum that specifies predefined width and height values (in pixels) for the
     * lightbox.
     */
    public enum Size {
        SMALL(400, 155), MEDIUM(550, 340), LARGE(600, 400);

        private int width;

        private int height;

        Size(int width, int height) {
            this.width = width;
            this.height = height;
        }

        public int getWidth() {
            return width;
        }

        public int getHeight() {
            return height;
        }
    }

    private enum LightBoxStyle {
        LIGHT_BOX {
            public String toString() {
                return "ks-lightbox";
            }
        },
        MAIN_PANEL {
            public String toString() {
                return "ks-lightbox-mainPanel";
            }
        },
        TITLE_PANEL {
            public String toString() {
                return "ks-lightbox-titlePanel";
            }
        },
        SCROLL_PANEL {
            public String toString() {
                return "ks-lightbox-scrollPanel";
            }
        },
        BUTTON_PANEL {
            public String toString() {
                return "ks-lightbox-buttonPanel";
            }
        },
        CLOSE_LINK {
            public String toString() {
                return "ks-lightbox-closeLink";
            }
        },
        CLOSE_LINK_WITH_CAPTION {
            public String toString() {
                return "ks-lightbox-closeLink-with-Caption";
            }
        }
    }

    //Resizing variables
    private int maxWidth = 800;
    private int maxHeight = 0;
    private int minWidth = 400;
    private int minHeight = 200;
    private int permWidth = -1;
    private int permHeight = -1;

    //DockLayoutPanel sizes
    private static final int BUTTON_HEIGHT = 40;//'px' units (specified in mainPanel's constructor)
    private static final int NON_CAPTION_HEIGHT = 40;//'px' units (specified in mainPanel's constructor)

    private DockLayoutPanel mainPanel = new DockLayoutPanel(Unit.PX);
    private FlowPanel closeLinkPanel = new FlowPanel();
    private SimplePanel titlePanel = new SimplePanel();
    private ScrollPanel scrollPanel = new ScrollPanel();
    private SimplePanel contentPanel = new SimplePanel();
    private FlowPanel buttonPanel = new FlowPanel();
    private Anchor closeLink = new Anchor();

    private KSDialogResizeHandler resizeHandler = new KSDialogResizeHandler();
    private HandlerRegistration resizeHandlerRegistrater;

    public KSLightBox() {
        getCaption().asWidget().setVisible(false);
        init();
    }

    public KSLightBox(boolean addCloseLink) {
        getCaption().asWidget().setVisible(false);
        init();
        closeLink.setVisible(addCloseLink);
    }

    public KSLightBox(String title) {
        init();
        setText(title);
    }

    public KSLightBox(String title, Size size) {
        init();
        setText(title);
        setSize(size);
    }

    private void init() {
        mainPanel.setStyleName(LightBoxStyle.MAIN_PANEL.toString());
        titlePanel.setStyleName(LightBoxStyle.TITLE_PANEL.toString());
        closeLink.setStyleName(LightBoxStyle.CLOSE_LINK.toString());
        scrollPanel.setStyleName(LightBoxStyle.SCROLL_PANEL.toString());
        buttonPanel.setStyleName(LightBoxStyle.BUTTON_PANEL.toString());

        setGlassEnabled(true);
        super.setWidget(mainPanel);
        mainPanel.addNorth(closeLinkPanel, 1);
        mainPanel.addNorth(titlePanel, 0);
        mainPanel.addSouth(buttonPanel, BUTTON_HEIGHT);
        mainPanel.add(scrollPanel);
        closeLinkPanel.add(closeLink);
        //parent element sets overflow to hidden to allow background and other css styling on the titlePanel
        Element titlePanelContainer = mainPanel.getWidgetContainerElement(titlePanel);
        titlePanelContainer.getStyle().setOverflow(Overflow.VISIBLE);
        //parent element sets overflow to hidden, must reset overflow to visible to show the 'closeLink'
        Element closeLinkPanelContainer = mainPanel.getWidgetContainerElement(closeLinkPanel);
        closeLinkPanelContainer.getStyle().setOverflow(Overflow.VISIBLE);
        scrollPanel.add(contentPanel);

        installResizeHandler();
        //super.
        closeLink.addClickHandler(new ClickHandler() {

            @Override
            public void onClick(ClickEvent event) {
                hide();
            }
        });
        super.setStyleName(LightBoxStyle.LIGHT_BOX.toString());

    }

    public void setCloseLinkVisible(boolean visible) {
        closeLink.setVisible(visible);
    }

    public void removeCloseLink() {
        closeLink.setVisible(false);
    }

    public HandlerRegistration addCloseLinkClickHandler(ClickHandler clickHandler) {
        return closeLink.addClickHandler(clickHandler);
    }

    /**
     * Sets the header that will be displayed at the top of the lightbox.<br/>
     * Please note: This header will not be displayed in the caption, but in the actual
     * lightbox content area.
     * @param widget The header widget.
     */
    public void setNonCaptionHeader(Widget widget) {
        titlePanel.setWidget(widget);
        mainPanel.setWidgetSize(titlePanel, NON_CAPTION_HEIGHT);
        mainPanel.forceLayout();
    }

    @Override
    public void setText(String text) {
        super.setText(text);
        getCaption().asWidget().setVisible(true);
        //Style needed to reposition the 'closeLink'
        closeLink.addStyleName(LightBoxStyle.CLOSE_LINK_WITH_CAPTION.toString());
    }
    
    /**
     * Removes all the buttons at the bottom of the lightbox.
     */
    public void clearButtons() {
        buttonPanel.clear();
    }

    /**
     * Adds a button to the bottom of the lightbox.
     */
    public void addButton(Widget button) {
        button.addStyleName("ks-button-spacing");
        buttonPanel.add(button);
    }

    /**
     * Adds a {@link org.kuali.student.common.ui.client.widgets.field.layout.button.ButtonGroup} to the button panel at the bottom of the lightbox. 
     * @param group
     */
    @SuppressWarnings("rawtypes")
    public void addButtonGroup(org.kuali.student.common.ui.client.widgets.field.layout.button.ButtonGroup group) {
        buttonPanel.add(group);
    }
    
    /**
     * Adds a {@link org.kuali.student.common.ui.client.widgets.buttongroups.ButtonGroup} to the button panel at the bottom of the lightbox.
     * @param group
     */
    @SuppressWarnings("rawtypes")
    public void addButtonGroup(org.kuali.student.common.ui.client.widgets.buttongroups.ButtonGroup group) {
        buttonPanel.add(group);
        
    }

    public void showButtons(boolean show) {
        buttonPanel.setVisible(show);
        if (show) {
            mainPanel.setWidgetSize(buttonPanel, BUTTON_HEIGHT);
        } else {
            mainPanel.setWidgetSize(buttonPanel, 0);
        }
        mainPanel.forceLayout();
    }

    /**
     * Set the maximum width in pixels that this dialog will grow to.<br />
     * Please note: If the lightbox's size was set explicitly, this call will have no
     * effect.
     * 
     * @param width The dialog's maximum width in pixels.
     */
    public void setMaxWidth(int width) {
        this.maxWidth = width;
    }

    /**
     * Set the maximum height in pixels that this dialog will grow to.<br />
     * Please note: If the lightbox's size was set explicitly, this call will have no
     * effect.
     * 
     * @param height The dialog's maximum height in pixels.
     */
    public void setMaxHeight(int height) {
        this.maxHeight = height;
    }

    /**
     * Set the width and height of the lightbox in pixels.<br/>
     * Please note: These values will not be affected by resizing. Thus the lightbox will
     * remain the specified size, irrespective of resizing.
     * 
     * @param width The specified width in pixels.
     * @param height The specified height in pixels.
     */
    public void setSize(int width, int height) {
        mainPanel.setSize(width + "px", width + "px");
        this.permHeight = height;
        this.permWidth = width;
    }

    /**
     * Set the width and height of the lightbox in pixels using the {@link Size} enum.
     * 
     * @param size A predefined dialog size.
     */
    public void setSize(Size size) {
        setSize(size.getWidth(), size.getHeight());
    }

    @Override
    public void setWidget(Widget content) {
        contentPanel.setWidget(content);
    }

    @Override
    public Widget getWidget() {
        return contentPanel.getWidget();
    }

    @Override
    public void hide() {
        super.hide();
        uninstallResizeHandler();
    }

    @Override
    public void show() {
        resizeDialog();
        installResizeHandler();
        super.show();
        super.center();
        grabFocus();
    }

    private void resizeDialog() {

        int width = maxWidth;
        int height = maxHeight;

        //Width calculation
        if (permWidth != -1) {
            width = permWidth;
        } else {
            if (Window.getClientWidth() < 850) {
                width = Window.getClientWidth() - 160;
            }
            if (width > maxWidth) {
                width = maxWidth;
            }
            if (width < minWidth) {
                width = minWidth;
            }
        }

        //Height calculation
        if (permHeight != -1) {
            height = permHeight;
        } else {
            height = Window.getClientHeight() - 160;

            if (height > maxHeight && maxHeight != 0) {
                height = maxHeight;
            }
            if (height < minHeight) {
                height = minHeight;
            }
        }

        if (width > 0 && height > 0) {
            mainPanel.setSize(width + "px", height + "px");
        }

    }

    private void grabFocus() {
        Widget mainContent = contentPanel.getWidget();
        NodeList<Element> nodeList = mainContent.getElement().getElementsByTagName("*");
        for (int i = 0; i < nodeList.getLength(); i++) {
            Element e = nodeList.getItem(i);
            if (FOCUSABLE_TAGS.contains(e.getTagName().toUpperCase())) {
                e.focus();
                return;
            }
        }

    }

    @Override
    protected void onPreviewNativeEvent(NativePreviewEvent preview) {
        super.onPreviewNativeEvent(preview);
        NativeEvent evt = preview.getNativeEvent();
        if (evt.getType().equals("keydown")) {
            switch (evt.getKeyCode()) {
                case KeyCodes.KEY_ESCAPE:
                    hide();
                    break;
            }
        }
    }

    public void uninstallResizeHandler() {
        if (resizeHandlerRegistrater != null) {
            resizeHandlerRegistrater.removeHandler();
            resizeHandlerRegistrater = null;

        }
    }

    public void installResizeHandler() {
        if (resizeHandlerRegistrater == null) {
            resizeHandlerRegistrater = Window.addResizeHandler(resizeHandler);
        }
    }

    class KSDialogResizeHandler implements ResizeHandler {
        @SuppressWarnings("deprecation")
        @Override
        public void onResize(ResizeEvent event) {
            DeferredCommand.addCommand(new Command() {

                @Override
                public void execute() {
                    resizeDialog();
                    int left = (Window.getClientWidth() - getOffsetWidth()) >> 1;
                    int top = (Window.getClientHeight() - getOffsetHeight()) >> 1;
                    setPopupPosition(Math.max(Window.getScrollLeft() + left, 0), Math.max(
                            Window.getScrollTop() + top, 0));
                }
            });
        }
    }

    

}