package com.wdstechnology.ucci.deviceassist.client.view;

import com.google.gwt.animation.client.Animation;
import com.google.gwt.core.client.GWT;
import com.google.gwt.dom.client.Style.Overflow;
import com.google.gwt.resources.client.ClientBundle;
import com.google.gwt.resources.client.ImageResource;
import com.google.gwt.user.client.Command;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.SimplePanel;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.google.gwt.user.client.ui.Widget;
import com.wdstechnology.ucci.deviceassist.client.ui.WidgetMouseHandler;
import com.wdstechnology.ucci.deviceassist.client.util.UIUtils;

public class WDSStackMenuView extends AbstractStackMenuView {

   public interface TransparentImages extends ClientBundle {
      @Source("transparent.gif")
      public ImageResource transparentImage();
   }

   public static final String TOP_LEVEL_STYLE = "StackMenuTopLevel";

   protected enum IconStyle {
      ArrowL1, ArrowL2, Plus, Minus
   }

   protected enum SelectionState {
      NotSelected, Selected
   }

   private VerticalPanel mainPanel = new VerticalPanel();

   private String transparentImageUrl;
   
   private TopMenuCategory currentlyOpen = null;

   private SubMenuItem currentlySelected = null;

   public WDSStackMenuView() {
      TransparentImages images = GWT.create(TransparentImages.class);
      transparentImageUrl = images.transparentImage().getURL();
      
      addStyleName("StackMenu");
      add(mainPanel);
   }

   public SubMenu addStyles(String... styles) {
      UIUtils.addStyles(this, styles);
      return this;
   }

   public void createAction(String title, final Command command, String... styles) {
      Command zCommand = new Command() {
         public void execute() {
            closeCategory();
            command.execute();
         }
      };
      addEntry(new OurSimplePanel(new TopMenuItem(title, zCommand, styles)));
   }

   public SubMenu createCategory(String title, String... styles) {
      TopMenuCategory topMenuCategory = new TopMenuCategory(title, styles);
      addEntry(new OurOverflowHiddenPanel(topMenuCategory));
      return topMenuCategory;
   }

   private void addEntry(Widget widget) {
      mainPanel.add(new OurSimplePanel(widget = new OurSimplePanel(widget, TOP_LEVEL_STYLE)));
      widget.addStyleName((mainPanel.getWidgetCount() == 1) ? "StackMenuFirstTopLevel" : "StackMenuNthTopLevel");
   }

   public void clearMenu() {
      mainPanel.clear();
      currentlyOpen = null;
      currentlySelected = null;
   }

   private void select(SubMenuItem selectedItem) {
      deselect();
      selectedItem.setSelected(true);
      currentlySelected = selectedItem;
   }

   private void deselect() {
      if (currentlySelected != null) {
         currentlySelected.setSelected(false);
         currentlySelected = null;
      }
   }

   private void openCategory(TopMenuCategory category) {
      closeCategory();
      category.open();
      currentlyOpen = category;
   }

   private void closeCategory() {
      if (currentlyOpen != null) {
         currentlyOpen.close();
         currentlyOpen = null;
         deselect();
      }
   }

   private abstract class MenuEntry extends HorizontalPanel implements WidgetMouseHandler.MouseClickedListener {

      protected static final String ICON_STYLE_BASE = "StackMenuIcon";

      protected IconStyle currentIconStyle = null;

      protected OurImage iconImage = new OurImage(transparentImageUrl, ICON_STYLE_BASE);

      protected Element mouseCSSElement;

      protected Element selectionCSSElement;

      protected WidgetMouseHandler mouseHandler;

      protected Command command;

      public MenuEntry(IconStyle iconStyle, final String title, Command command, String... styles) {
         this.command = command;
         UIUtils.addStyles(this, styles);
         add(new OurImage(transparentImageUrl, "StackMenuIndent"));
         add(new OurImage(transparentImageUrl, "StackMenuPreIconSpacer"));
         add(iconImage);
         add(new OurImage(transparentImageUrl, "StackMenuPostIconSpacer"));
         add(new OurLabel(title, "StackMenuText"));

         Element table = getElement();
         Element tbody = (Element) table.getChild(0);
         Element tr = (Element) tbody.getChild(0);

         selectionCSSElement = tbody;
         mouseCSSElement = tr;

         setBackgroundIconImageStyle(iconStyle);

         mouseHandler = new WidgetMouseHandler(mouseCSSElement, this, new WidgetMouseHandler.Logger() {
            public void log(String message) {
               System.out.println(title + ": " + message);
            }
         });
         sinkEvents(WidgetMouseHandler.EVENT_BITS);
      }

      protected void setBackgroundIconImageStyle(IconStyle style) {
         if (currentIconStyle != null) {
            iconImage.removeStyleName(makeStyleName(currentIconStyle));
         }
         currentIconStyle = style;
         iconImage.addStyleName(makeStyleName(style));
      }

      private String makeStyleName(IconStyle style) {
         return ICON_STYLE_BASE + "-" + style;
      }

      @Override
      public void onBrowserEvent(Event event) {
         if (!mouseHandler.onBrowserEvent(event)) {
            super.onBrowserEvent(event);
         }
      }

      public void mouseClicked() {
         if (command != null) {
            command.execute();
         }
      }

      @Override
      protected void setCellHorizontalAlignment(Element td, HorizontalAlignmentConstant align) {
         // Remove ALL TD alignment - leave for CSS
      }

      @Override
      protected void setCellVerticalAlignment(Element td, VerticalAlignmentConstant align) {
         // Remove ALL TD alignment - leave for CSS
      }
   }

   private class TopMenuItem extends MenuEntry {

      public TopMenuItem(String title, Command command, String... styles) {
         super(IconStyle.ArrowL1, title, command, styles);
         addStyleName("L1");
      }
   }

   private class SubMenuItem extends MenuEntry {

      public SubMenuItem(String title, Command command, String... styles) {
         super(IconStyle.ArrowL2, title, command, styles);
         addStyleName("L2");
      }

      @Override
      public void mouseClicked() {
         select(this);
         super.mouseClicked();
      }

      protected void setSelected(boolean selected) {
         selectionCSSElement.removeClassName(makeStyleName(SelectionState.Selected));
         selectionCSSElement.removeClassName(makeStyleName(SelectionState.NotSelected));
         selectionCSSElement
               .addClassName(makeStyleName(selected ? SelectionState.Selected : SelectionState.NotSelected));
      }

      private String makeStyleName(SelectionState style) {
         return ICON_STYLE_BASE + "-" + style;
      }
   }

   private class TopMenuCategoryItem extends MenuEntry {

      public TopMenuCategoryItem(String title, Command command, String... styles) {
         super(IconStyle.Plus, title, command, styles);
         addStyleName("L1");
         setOpenState(false);
      }

      public void setOpenState(boolean open) {
         setBackgroundIconImageStyle(open ? IconStyle.Minus : IconStyle.Plus);
      }
   }

   private class TopMenuCategory extends VerticalPanel implements SubMenu {

      private final TopMenuCategoryItem ourCategoryItem;

      private final VerticalPanel actions = new VerticalPanel();

      public TopMenuCategory(String title, String... styles) {
         add(ourCategoryItem = new TopMenuCategoryItem(title, new Command() {
            public void execute() {
               if (TopMenuCategory.this.equals(currentlyOpen)) {
                  closeCategory();
               } else {
                  openCategory(TopMenuCategory.this);
               }
            }
         }, styles));
      }

      @Override
      protected void onAttach() {
         super.onAttach();
         new Timer() {
            @Override
            public void run() {
               int baseHeight = ourCategoryItem.getOffsetHeight();
               if (baseHeight < 10) {
                  schedule(50);
                  return;
               }
               getParent().setHeight(baseHeight + "px");
               add(actions);
            }
         }.schedule(50);
      }

      public void open() {
         ourCategoryItem.setOpenState(true);
         transitionHider(ourCategoryItem.getOffsetHeight(), getOffsetHeight());
      }

      public void close() {
         ourCategoryItem.setOpenState(false);
         transitionHider(getOffsetHeight(), ourCategoryItem.getOffsetHeight());
      }

      private void transitionHider(int fromHeight, int toHeight) {
         new CategoryAnimation(getParent(), fromHeight, toHeight);
      }

      public SubMenu addStyles(String... styles) {
         UIUtils.addStyles(this, styles);
         return this;
      }

      public void createAction(String title, Command command, String... styles) {
         actions.add(new SubMenuItem(title, command, styles));
      }

      public SubMenu createCategory(String title, String... styles) {
         throw new UnsupportedOperationException("Currently SubMenus do not support SubMenus");
      }

   }

   private static class CategoryAnimation extends Animation {

      private Widget widget;

      private int fromHeight;

      private int toHeight;

      private int overhead;

      private int height;

      private int adjuster;

      public CategoryAnimation(Widget widget, int fromHeight, int toHeight) {
         this.widget = widget;
         this.fromHeight = fromHeight;
         this.toHeight = toHeight;
         if (fromHeight < toHeight) { // Opening
            overhead = fromHeight;
            height = toHeight - fromHeight;
            adjuster = 0;
         } else { // Closing
            overhead = toHeight;
            height = fromHeight - toHeight;
            adjuster = height;
         }
         run(Math.min(700, 7 * height));
      }

      @Override
      protected void onUpdate(double progress) {
         int height = Math.abs(adjuster - ((int) (progress * this.height)));

         widget.setHeight((overhead + height) + "px");
      }

      @Override
      protected void onComplete() {
         super.onComplete();
         widget.setHeight(toHeight + "px");
      }

      @Override
      protected void onStart() {
         super.onStart();
         widget.setHeight(fromHeight + "px");
      }
   }

   private static class OurImage extends Image {
      public OurImage(String imageRef, String style) {
         super(imageRef);
         addStyleName(style);
      }
   }

   private static class OurLabel extends Label {
      public OurLabel(String text, String style) {
         super(text);
         addStyleName(style);
      }
   }

   private static class OurSimplePanel extends SimplePanel {
      public OurSimplePanel(Widget widget) {
         add(widget);
      }

      public OurSimplePanel(Widget widget, String style) {
         this(widget);
         addStyleName(style);
      }
   }

   private static class OurOverflowHiddenPanel extends OurSimplePanel {
      public OurOverflowHiddenPanel(Widget widget) {
         super(widget);

         getElement().getStyle().setOverflow(Overflow.HIDDEN);
      }
   }
}