/**
    * This file Copyright (c) 2013-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.dam.app.ui.field.upload;
  
  import info.magnolia.dam.app.ui.field.configuration.PreviewComponentProvider;
  import info.magnolia.dam.app.ui.field.configuration.ThumbnailComponentProvider;
  import info.magnolia.dam.app.ui.field.definition.DamUploadFieldDefinition;
  import info.magnolia.i18nsystem.SimpleTranslator;
  import info.magnolia.objectfactory.ComponentProvider;
  import info.magnolia.ui.api.context.UiContext;
  import info.magnolia.ui.api.overlay.OverlayCloser;
  import info.magnolia.ui.form.field.upload.basic.BasicUploadField;
  import info.magnolia.ui.imageprovider.ImageProvider;
  import info.magnolia.ui.mediaeditor.MediaEditorPresenter;
  import info.magnolia.ui.mediaeditor.MediaEditorPresenterFactory;
  import info.magnolia.ui.mediaeditor.event.MediaEditorCompletedEvent;
  import info.magnolia.ui.vaadin.overlay.MessageStyleTypeEnum;
  
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.InputStream;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.net.MediaType;
  import com.vaadin.server.Resource;
  import com.vaadin.server.StreamResource;
  import com.vaadin.server.StreamResource.StreamSource;
  import com.vaadin.ui.Alignment;
  import com.vaadin.ui.Button;
  import com.vaadin.ui.Button.ClickEvent;
  import com.vaadin.ui.Component;
  import com.vaadin.ui.CssLayout;
  import com.vaadin.ui.Layout;
  import com.vaadin.ui.NativeButton;
  import com.vaadin.v7.ui.HorizontalLayout;
  import com.vaadin.v7.ui.Label;
  
  /**
   * Dam implementation of {@link BasicUploadField}.<br>
   * Override default Layout components of the CompletedLayout:
   * <ul>
   * <li>createCompletedActionLayout (Contains the available actions based on the MediaType)</li>
   * <li>createThumbnailComponent() (Display a preview Image or an Icon)</li>
   * <li>getFileDetailSize() (Add file size/duration informations )</li>
   * </ul>
   * An Uploaded file is mapped to a mediaType (based on the MimeType). <br>
   * The mediaType define upload configuration like:
   * <ul>
   * <li>{@link info.magnolia.dam.app.ui.field.configuration.ThumbnailComponentProvider} to use in order to display the preview Image</li>
   * <li>should this media have an edit button and in case, which mediaEtior to call</li>
   * <li>should this media have an open preview action and in case, which {@link info.magnolia.dam.app.ui.field.configuration.PreviewComponentProvider} to use</li>
   * </ul>
   * <b>Check {@link info.magnolia.dam.app.ui.field.configuration.EditAssetAppConfiguration} for additional informations regarding MediaEditor configuration</b>
   *
   * @param <D> {@link AssetUploadReceiver} implemented class.
   */
  public class DamUploadField<D extends AssetUploadReceiver> extends BasicUploadField<D> {
      private static final long serialVersionUID = 1L;
      private static final Logger log = LoggerFactory.getLogger(DamUploadField.class);
  
      private final SimpleTranslator i18n;
  
      // Used to open the MediaEditor
      private MediaEditorPresenterFactory mediaEditorFactory;
     private ComponentProvider componentProvider;
     private String lightboxCaption;
     private String editFileCaption;
 
     public DamUploadField(ImageProvider imageProvider, UiContext uiContext, MediaEditorPresenterFactory mediaEditorFactory, ComponentProvider componentProvider, DamUploadFieldDefinition definition, SimpleTranslator i18n) {
         super(imageProvider, uiContext, definition, i18n);
         // Propagate definition.
         populateFromDefinition(definition);
 
         this.mediaEditorFactory = mediaEditorFactory;
         this.componentProvider = componentProvider;
         this.i18n = i18n;
     }
 
     /**
      * Add File Info.
      */
     @Override
     protected Component getFileDetailSize() {
         Label label = new Label();
         label.setCaption(i18n.translate(fileDetailSizeCaption));
         StringBuilder sb = new StringBuilder();
         if (getValue().isImage()) {
             sb.append(getValue().getWidth() + " x " + getValue().getHeight() + ", ");
         }
         sb.append(FileUtils.byteCountToDisplaySize(getValue().getFileSize()));
         if (getValue().getDuration() > 0) {
             sb.append("(x:x min)");
         }
 
         label.setValue(sb.toString());
         return label;
     }
 
     /**
      * Override of CompletedLayout section.<br>
      * Used the configuration in order to define the action to perform and Thumbnail component to display.
      */
     @Override
     protected Layout createCompletedActionLayout() {
         if (isReadOnly()) {
             return new HorizontalLayout();
         }
         // Action Button (Upload new or delete). Default is always Upload
         HorizontalLayout actionLayout = new HorizontalLayout();
         actionLayout.setSizeUndefined();
         actionLayout.addStyleName("buttons");
         actionLayout.setSpacing(true);
         // Add an Edit Button if the MediaFile has configured it.
         if (getValue() != null && !getValue().isEmpty() && getValue().getEditAssetAppConfiguration().hasEditConfig()) {
             Button edit = createEditButton();
             actionLayout.addComponent(edit);
         }
         // Add Upload Button
         getUpload().setButtonCaption(getCaption(selectAnotherCaption, null));
         actionLayout.addComponent(getUpload());
         // Add a Remove Button if a file is present.
         if (getValue() != null && !getValue().isEmpty()) {
             Button delete = createDeleteButton();
             actionLayout.addComponent(delete);
             actionLayout.setComponentAlignment(delete, Alignment.MIDDLE_LEFT);
         }
         return actionLayout;
     }
 
     /**
      * Create Edit button.<br>
      * Delegate the call to the media Editor to openMediaEditor {@link MediaEditorPresenter#start(InputStream)}.
      */
     private Button createEditButton() {
         Button editButton = new Button(getCaption(editFileCaption, null), createEditButtonListener());
         editButton.setDisableOnClick(true);
         editButton.addStyleName("edit");
         return editButton;
     }
 
     private Button.ClickListener createEditButtonListener() {
         return new Button.ClickListener() {
             private static final long serialVersionUID = 1L;
 
             @Override
             public void buttonClick(ClickEvent event) {
                 // Launch MediaEditor for this item.
                 try {
                     openMediaEditor();
                 } catch (FileNotFoundException fnfe) {
                     log.warn("could not open MediaEditor");
                     uiContext.openAlert(MessageStyleTypeEnum.ERROR, "ERROR", i18n.translate("dam.assets.uploadField.alert.couldNotOpenMediaEditor")
                                     + " "
                                     + getValue().getEditAssetAppConfiguration().getEditConfig().getMediaEditorId(),
                             "ok", null);
                 } finally {
                     event.getButton().setEnabled(true);
                 }
             }
         };
     }
 
     /**
      * Open a mediaEditor populated with the binary of this file.
      * Media Editor Id is configured in the related MediaFile definition.
      *
      * @throws FileNotFoundException
      */
     private void openMediaEditor() throws FileNotFoundException {
         // Check
         String presenterById;
         if (getValue().getEditAssetAppConfiguration() == null || !getValue().getEditAssetAppConfiguration().hasEditConfig()) {
             log.warn("No Media Editor defined for the following mimeType {} ", getValue().getMimeType());
             return;
         } else {
             presenterById = "ui-mediaeditor:" + getValue().getEditAssetAppConfiguration().getEditConfig().getMediaEditorId();
             log.debug("Will open the following mediaEditor Presenter {}", presenterById);
         }
 
         final NativeButton mediaEditorPlaceholder = new NativeButton(i18n.translate("dam.assets.uploadField.button.mediaEditorPlaceholder"));
         mediaEditorPlaceholder.addStyleName("btn-form btn-form-commit");
 
         MediaEditorPresenter mediaEditorPresenter = mediaEditorFactory.getPresenterById(presenterById);
         final InputStream inputStream = new FileInputStream(getValue().getFile());
         final OverlayCloser overlayCloser = uiContext.openOverlay(mediaEditorPresenter.start(inputStream));
         mediaEditorPresenter.addCompletionHandler(new MediaEditorCompletedEvent.Handler() {
             @Override
             public void onSubmit(MediaEditorCompletedEvent event) {
                 getValue().updateContent(event.getStream());
                 // Update the display to show changes to media.
                 updateDisplay();
                 overlayCloser.close();
                 closeInputStream(inputStream);
                 getPropertyDataSource().setValue(getValue());
             }
 
             @Override
             public void onCancel(MediaEditorCompletedEvent event) {
                 overlayCloser.close();
                 closeInputStream(inputStream);
             }
 
             private void closeInputStream(InputStream inputStream) {
                 try {
                     if (inputStream != null) {
                         inputStream.close();
                     }
                 } catch (Exception e) {
                     log.warn("Could not close the InputStream ", e);
                 }
             }
         });
     }
 
     /**
      * Create a preview image with a button if configured:
      * <ul>
      * <li>in lower-left to open the media in a lightbox</li>
      * <li>a button in the lower-right to open the MediaEditor.</li>
      * </ul>
      */
     @Override
     protected Component createThumbnailComponent() {
 
         CssLayout previewLayout = new CssLayout();
         previewLayout.addStyleName("file-preview-area");
         previewLayout.setWidth("150px");
         previewLayout.setHeight("150px");
         // Create the preview Component (Icon / Image thumbnail/...)
         Component image = createPreviewComponent();
         if (image != null) {
             image.addStyleName("preview-image");
             previewLayout.addComponent(image);
         }
 
         // Add buttons to the preview layout (Add Edit) IF CONFIGURED
         if (getValue().getEditAssetAppConfiguration().hasEditConfig() && !isReadOnly()) {
             Button editButton = new Button();
             editButton.addStyleName("edit-button");
             editButton.setHtmlContentAllowed(true);
             editButton.setCaption("<span class=\"" + getValue().getEditAssetAppConfiguration().getEditConfig().getIconStyleName() + "\"></span>");
             editButton.setDescription(getCaption(editFileCaption, null));
             previewLayout.addComponent(editButton);
 
             // Button handlers
             editButton.setDisableOnClick(true);
             editButton.addClickListener(createEditButtonListener());
         }
 
         // Add buttons to the preview layout (Add LightBox) IF CONFIGURED
         if (getValue().getEditAssetAppConfiguration().hasPreviewConfig()) {
             Button lightboxButton = new Button();
             lightboxButton.addStyleName("lightbox-button");
             lightboxButton.setHtmlContentAllowed(true);
             lightboxButton.setCaption("<span class=\"" + getValue().getEditAssetAppConfiguration().getPreviewConfig().getIconStyleName() + "\"></span>");
             lightboxButton.setDescription(i18n.translate(lightboxCaption));
             previewLayout.addComponent(lightboxButton);
 
             lightboxButton.addClickListener(new Button.ClickListener() {
                 private static final long serialVersionUID = 1L;
 
                 @Override
                 public void buttonClick(ClickEvent event) {
                     // Launch Lightbox component
                     Class<? extends PreviewComponentProvider> previewActionClass = getValue().getEditAssetAppConfiguration().getPreviewConfig().getPreviewComponentProviderClass();
                     if (previewActionClass != null) {
                         PreviewComponentProvider implementation = componentProvider.newInstance(previewActionClass);
                         implementation.open(getResource());
                     } else {
                         log.warn("No Preview Defined is defined ");
                     }
                 }
             });
         }
         return previewLayout;
     }
 
     /**
      * Override of CompletedLayout section.<br>
      * Change the Thumbnail section of the Completed Layout.<br>
      * Thumbnail is only available for Images and Video.
      */
     private Component createPreviewComponent() {
         Class<? extends ThumbnailComponentProvider> thumbnailProviderClass = getValue().getEditAssetAppConfiguration().getThumbnailComponentProviderClass();
         if (thumbnailProviderClass != null) {
             ThumbnailComponentProvider implementation = componentProvider.newInstance(thumbnailProviderClass);
             return implementation.createThumbnailComponent(null, getValue().getFile(), getValue().getMimeType());
         } else {
             log.warn("No ThumbnailComponentProvider is defined ");
             return null;
         }
     }
 
     /**
      * Create a resource from the File.
      */
     private Resource getResource() {
         final StreamSource source = new StreamResource.StreamSource() {
             private static final long serialVersionUID = 1L;
 
             @Override
             public InputStream getStream() {
                 try {
                     return new FileInputStream(getValue().getFile());
                 } catch (FileNotFoundException fnfe) {
                     log.warn("could not found File", fnfe);
                     return null;
                 }
             }
         };
 
         return new StreamResource(source, "") {
             @Override
             public String getMIMEType() {
                 return getValue().getMimeType();
             }
         };
     }
 
     protected void populateFromDefinition(DamUploadFieldDefinition definition) {
         super.populateFromDefinition(definition);
         this.setLightboxCaption(definition.getLightboxCaption());
         this.setEditFileCaption(definition.getEditFileCaption());
     }
 
     /**
      * Caption section.
      */
     @Override
     protected void setCaptionExtension(String mimeType) {
         if (StringUtils.isNotBlank(mimeType)) {
             captionExtension = MediaType.parse(mimeType).type();
         } else if (StringUtils.isNotBlank(getValue().getMimeType())) {
             captionExtension = MediaType.parse(getValue().getMimeType()).type();
         }
     }
 
     public void setLightboxCaption(String lightboxCaption) {
         this.lightboxCaption = lightboxCaption;
     }
 
     public void setEditFileCaption(String editFileCaption) {
         this.editFileCaption = editFileCaption;
     }
 }