/**
    * This file Copyright (c) 2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.admincentral;
  
  import info.magnolia.i18nsystem.SimpleTranslator;
  import info.magnolia.ui.AlertBuilder;
  import info.magnolia.ui.DialogBuilder;
  import info.magnolia.ui.api.context.UiContext;
  import info.magnolia.ui.api.ioc.AdmincentralScoped;
  import info.magnolia.ui.api.message.Message;
  import info.magnolia.ui.api.message.MessageType;
  import info.magnolia.ui.api.overlay.AlertCallback;
  import info.magnolia.ui.api.overlay.ConfirmationCallback;
  import info.magnolia.ui.api.overlay.MessageStyleType;
  import info.magnolia.ui.api.overlay.NotificationCallback;
  import info.magnolia.ui.api.overlay.OverlayCloser;
  import info.magnolia.ui.api.overlay.OverlayLayer;
  import info.magnolia.ui.api.shell.ConfirmationHandler;
  import info.magnolia.ui.api.shell.Shell;
  import info.magnolia.ui.api.view.View;
  import info.magnolia.ui.dialog.DialogView;
  import info.magnolia.ui.framework.message.MessagesManager;
  import info.magnolia.ui.vaadin.overlay.MessageStyleTypeEnum;
  
  import javax.inject.Inject;
  
  import com.vaadin.server.Page;
  import com.vaadin.ui.Component;
  import com.vaadin.ui.Notification;
  import com.vaadin.ui.UI;
  import com.vaadin.ui.Window;
  
  /**
   * The shell implementation for the Resurface Admincentral.
   *
   * <p>In comparison with the M5 shell, this implementation favors stock Vaadin usage over GWT customizations.
   */
  @AdmincentralScoped
  public class ResurfaceShell implements Shell, UiContext {
  
      private final MessagesManager messagesManager;
  
      private final SimpleTranslator i18n;
  
      @Inject
      public ResurfaceShell(MessagesManager messagesManager, SimpleTranslator i18n) {
          this.messagesManager = messagesManager;
          this.i18n = i18n;
      }
  
      /* MessagesManager delegation */
  
      @Override
      public void askForConfirmation(String message, ConfirmationHandler listener) {
          // TODO consider dropping since it was always void in ShellImpl
          AlertBuilder.confirmDialog("confirm")
                  .withBody(message)
                  .withConfirmationHandler(listener::onConfirm)
                  .withConfirmButtonCaption(i18n.translate("button.confirm"))
                  .withDeclineButtonCaption(i18n.translate("button.decline"))
                  .buildAndOpen();
      }
  
      @Override
      public void showNotification(String message) {
          showMessage(message, MessageType.INFO);
      }
  
     @Override
     public void showError(String message, Exception e) {
         showMessage(message, MessageType.ERROR);
     }
 
     private void showMessage(String messageText, MessageType type) {
         final Message message = new Message();
         message.setMessage(messageText);
         message.setType(type);
         messagesManager.sendLocalMessage(message);
     }
 
     /* Location control */
 
     @Override
     public String getFragment() {
         return Page.getCurrent().getUriFragment();
     }
 
     @Override
     public void setFragment(String fragment) {
         Page.getCurrent().setUriFragment(fragment);
     }
 
     /* Arbitrary overlays */
 
     @Override
     @Deprecated
     public OverlayCloser openOverlayOnView(View view, View parent, ModalityDomain modalityLocation, ModalityLevel modalityLevel) {
         return openOverlay(view, modalityLevel);
     }
 
     @Override
     @Deprecated
     public OverlayCloser openOverlay(View view) {
         return openOverlay(view, ModalityLevel.STRONG);
     }
 
     @Override
     @Deprecated
     public OverlayCloser openOverlay(View view, ModalityLevel modalityLevel) {
         final Component component = view.asVaadinComponent();
         final Window window;
         if (component instanceof Window) {
             window = (Window) component;
         } else if (view instanceof DialogView) {
             final DialogView dialogView = (DialogView) view;
             final Component contentComponent = dialogView.asVaadinComponent();
             final Component actionAreaComponent = dialogView.getActionAreaView().asVaadinComponent();
 
             // re-wrap the view into a dialog (mostly for compatibility reasons)
             contentComponent.setParent(null);
             actionAreaComponent.setParent(null);
 
             window = new Window(dialogView.getTitle());
             window.addCloseListener(listener -> dialogView.close());
 
             window.setContent(DialogBuilder.dialog()
                     .withContent(contentComponent)
                     .withFooter(actionAreaComponent)
                     .withTitle(dialogView.getTitle())
                     .build());
         } else {
             window = new Window();
             window.setCaption(component.getCaption());
             window.setContent(component);
         }
 
         window.addStyleNames("dialog", modalityLevel.name().toLowerCase());
         window.setDraggable(false);
         window.setResizable(false);
         window.setModal(ModalityLevel.STRONG == modalityLevel);
 
         UI.getCurrent().addWindow(window);
 
         return window::close;
     }
 
     /* Notifications and alerts */
 
     @Override
     public void openNotification(MessageStyleType messageType, boolean doesTimeout, String title) {
         Notification notification = Notification.show(title, notificationTypeOf(messageType));
         if (doesTimeout) {
             notification.setDelayMsec(3600);
         }
     }
 
     @Override
     public void openNotification(MessageStyleType messageType, boolean doesTimeout, View viewToShow) {
         throw new UnsupportedOperationException();
     }
 
     @Override
     public void openNotification(MessageStyleType messageType, boolean doesTimeout, String title, String linkText, NotificationCallback cb) {
         throw new UnsupportedOperationException();
     }
 
     @Override
     public void openAlert(MessageStyleType messageType, String title, String body, String okButton, AlertCallback callback) {
         Window window = AlertBuilder.alert(title)
                 .withLevel(notificationTypeOf(messageType))
                 .withBody(body)
                 .withConfirmationHandler(callback::onOk)
                 .withOkButtonCaption(okButton)
                 .buildAndOpen();
         // TODO switch or add styling to stock Vaadin notification types
         window.addStyleName(messageType.getCssClass());
     }
 
     @Override
     public void openAlert(MessageStyleType messageType, String title, View content, String okButton, AlertCallback callback) {
         Window window = AlertBuilder.alert(title)
                 .withLevel(notificationTypeOf(messageType))
                 .withContent(content.asVaadinComponent())
                 .withConfirmationHandler(callback::onOk)
                 .withOkButtonCaption(okButton)
                 .buildAndOpen();
         // TODO switch or add styling to stock Vaadin notification types
         window.addStyleName(messageType.getCssClass());
     }
 
     @Override
     public void openConfirmation(MessageStyleType messageType, String title, String body, String confirmButton, String cancelButton, boolean cancelIsDefault, ConfirmationCallback callback) {
         Window confirmDialog = AlertBuilder.confirmDialog(title)
                 .withLevel(notificationTypeOf(messageType))
                 .withBody(body)
                 .withConfirmationHandler(callback::onSuccess)
                 .withConfirmButtonCaption(confirmButton)
                 .withDeclineButtonCaption(cancelButton)
                 .buildAndOpen();
         // TODO switch or add styling to stock Vaadin notification types
         confirmDialog.addStyleName(messageType.getCssClass());
     }
 
     @Override
     public void openConfirmation(MessageStyleType messageType, String title, View content, String confirmButton, String cancelButton, boolean cancelIsDefault, ConfirmationCallback callback) {
         Window confirmDialog = AlertBuilder.confirmDialog(title)
                 .withLevel(notificationTypeOf(messageType))
                 .withContent(content.asVaadinComponent())
                 .withConfirmationHandler(callback::onSuccess)
                 .withConfirmButtonCaption(confirmButton)
                 .withDeclineButtonCaption(cancelButton)
                 .buildAndOpen();
         // TODO switch or add styling to stock Vaadin notification types
         confirmDialog.addStyleName(messageType.getCssClass());
     }
 
     @Override
     public OverlayLayer getOverlayDelegate() {
         return this;
     }
 
     /**
      * Helper method to convert Magnolia message levels into equivalent Vaadin notification types.
      *
      * @param messageStyleType the Magnolia {@link MessageStyleType}, usually a member of the {@link MessageStyleTypeEnum}
      * @return the corresponding Vaadin {@link Notification.Type}
      */
     private static Notification.Type notificationTypeOf(MessageStyleType messageStyleType) {
         if (messageStyleType instanceof MessageStyleTypeEnum) {
             switch ((MessageStyleTypeEnum) messageStyleType) {
             case INFO:
                 return Notification.Type.HUMANIZED_MESSAGE;
             case WARNING:
                 return Notification.Type.WARNING_MESSAGE;
             case ERROR:
                 return Notification.Type.ERROR_MESSAGE;
             }
         }
         return Notification.Type.HUMANIZED_MESSAGE;
     }
 }