/**
    * 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.ui.form.field.upload.basic;
  
  import info.magnolia.i18nsystem.SimpleTranslator;
  import info.magnolia.icons.MagnoliaIcons;
  import info.magnolia.ui.api.context.UiContext;
  import info.magnolia.ui.form.field.definition.BasicUploadFieldDefinition;
  import info.magnolia.ui.form.field.upload.AbstractUploadField;
  import info.magnolia.ui.form.field.upload.UploadProgressIndicator;
  import info.magnolia.ui.form.field.upload.UploadReceiver;
  import info.magnolia.ui.imageprovider.ImageProvider;
  import info.magnolia.ui.theme.ResurfaceTheme;
  import info.magnolia.ui.vaadin.overlay.MessageStyleTypeEnum;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.vaadin.data.HasValue;
  import com.vaadin.server.Resource;
  import com.vaadin.shared.ui.ContentMode;
  import com.vaadin.ui.Button;
  import com.vaadin.ui.Component;
  import com.vaadin.ui.CssLayout;
  import com.vaadin.ui.FormLayout;
  import com.vaadin.ui.Label;
  import com.vaadin.ui.Layout;
  import com.vaadin.ui.TextField;
  
  /**
   * Basic implementation of {@link AbstractUploadField}.<br>
   * Define the Layout components for
   * <ul>
   * <li>EmptyLayout (no File are yet uploaded)
   * <li>InProgressLayout (ProgressBar / Cancel Button...)
   * <li>CompletedLayout (File Detail / Preview ...)
   * </ul>
   * 
   * @param <T> {@link UploadReceiver} implemented class.
   */
  public class ResurfaceBasicUploadField<T extends UploadReceiver> extends AbstractUploadField<T> {
      private static final long serialVersionUID = 1L;
      private static final Logger log = LoggerFactory.getLogger(ResurfaceBasicUploadField.class);
  
      // Root layout
      private final CssLayout layout;
      private final CssLayout uploadZone;
      private UploadProgressIndicator progress;
      protected final ImageProvider imageProvider;
      private boolean editFileName = false;
      private boolean editFileFormat = false;
      protected UiContext uiContext;
  
      private final SimpleTranslator i18n;
      private FormLayout fileInfo;
  
      public ResurfaceBasicUploadField(ImageProvider imageProvider, UiContext uiContext, BasicUploadFieldDefinition definition, SimpleTranslator i18n) {
          super();
          // Propagate definition.
          populateFromDefinition(definition);
  
          this.imageProvider = imageProvider;
          this.uiContext = uiContext;
          this.i18n = i18n;
  
          layout = new CssLayout();
         layout.addStyleName("upload-layout");
 
         uploadZone = new CssLayout();
         uploadZone.setSizeFull();
         layout.addComponent(createDropZone(uploadZone));
 
         setRootLayout(layout);
     }
 
     /**
      * Initialize the root component.
      * Build the initial layout:
      * - Empty Layout if the incoming Item is empty.
      * - Completed Layout with the Item Informations if this Item is not empty.
      */
     @Override
     public void attach() {
         super.attach();
         updateDisplay();
         log.debug("Component was attached ...");
     }
 
     /**
      * Main entry point to create the Empty Layout.
      * This Basic implementation of Empty layout is composed of <br>
      * - An Upload button <br>
      * - A Label inviting to Drag files <br>
      */
     @Override
     protected void buildEmptyLayout() {
         uploadZone.removeAllComponents();
         if (fileInfo != null) {
             layout.removeComponent(fileInfo);
         }
 
         if (isReadOnly()) {
             return;
         }
 
         // Add DropZone Label
         Label uploadText = new Label(getCaption(dropZoneCaption, null), ContentMode.HTML);
         uploadText.addStyleName("upload-text");
         uploadZone.addComponent(uploadText);
 
         // Add Upload Button
         getUpload().setButtonCaption(getCaption(selectNewCaption, null));
         getUpload().addStyleName("upload-button");
         uploadZone.addComponent(getUpload());
 
         // Update Style Name
         uploadZone.removeStyleName("done");
         uploadZone.removeStyleName("in-progress");
         uploadZone.addStyleName("initial");
 
         log.debug("buildEmptyLayout() called ...");
     }
 
     /**
      * Main entry point to create the In Progress Layout.
      * This Basic implementation of In Progress is composed of <br>
      * - A Progress Bar <br>
      * - A Cancel Button <br>
      */
     @Override
     protected void buildInProgressLayout(String uploadedFileMimeType) {
         uploadZone.removeAllComponents();
         if (fileInfo != null) {
             layout.removeComponent(fileInfo);
         }
 
         // Create the process Indigator
         progress = new ResurfaceBasicUploadProgressIndicator(inProgressCaption, inProgressRatioCaption, i18n, (Button.ClickListener) event -> interruptUpload(InterruptionReason.USER));
         progress.setVisible(true);
         progress.setProgress(0);
         uploadZone.addComponent(progress.asVaadinComponent());
 
         // Update Style Name
         uploadZone.removeStyleName("done");
         uploadZone.removeStyleName("initial");
         uploadZone.addStyleName("in-progress");
 
         log.debug("buildInProgressLayout() called ...");
     }
 
     @Override
     protected void refreshInProgressLayout(long readBytes, long contentLength, String fileName) {
         if (progress != null) {
             progress.refreshLayout(readBytes, contentLength, fileName);
         }
     }
 
     /**
      * Main entry point to create the Completed Layout.
      * This Basic implementation of Completed Layout is composed of <br>
      * - An Icon representing the File type <br>
      * - A Detail text information <br>
      * - An Action bar: UploadNew and Delete Actions <br>
      * <b>Override</b><br>
      * getFileInfo() In order to change the Displayed Text <br>
      * createIconStyleName() In order to change the Icon Style displayed.
      */
     @Override
     protected void buildCompletedLayout() {
         if (fileInfo != null) {
             layout.removeComponent(fileInfo);
         }
         createCompletedActionLayout();
 
         layout.addComponent(createFileInfoComponent());
 
         log.debug("buildCompletedLayout() called ...");
     }
 
     /**
      * Build the Completed Action Layout.
      */
     protected Layout createCompletedActionLayout() {
         uploadZone.removeAllComponents();
 
         // Action Button (Upload new or delete). Default is always Upload
         uploadZone.addStyleName("finished-action-layout");
         addControlActions(uploadZone);
 
         // Create Preview
         uploadZone.addComponent(createThumbnailComponent());
 
         // Add Upload Button
         getUpload().setButtonCaption(getCaption(selectAnotherCaption, null));
         getUpload().addStyleName("upload-another");
         uploadZone.addComponent(getUpload());
 
         // Update Style Name
         uploadZone.removeStyleName("in-progress");
         uploadZone.removeStyleName("initial");
         uploadZone.addStyleName("done");
 
         return uploadZone;
     }
 
     protected void addControlActions(final CssLayout uploadZone) {
         // By default, add Remove button if a file is present.
         if (!getValue().isEmpty()) {
             uploadZone.addComponent(createDeleteButton());
         }
     }
 
     /**
      * Create Delete button.
      */
     protected Button createDeleteButton() {
         Button deleteButton = createControlButton(deleteCaption, MagnoliaIcons.TRASH);
 
         deleteButton.addClickListener((Button.ClickListener) event -> {
             resetDataSource();
             updateDisplay();
         });
         return deleteButton;
     }
 
     protected Button createControlButton(String captionkey, Resource icon) {
         Button controlButton = new Button(icon);
         controlButton.addStyleNames(ResurfaceTheme.BUTTON_ICON, "edit-action");
         controlButton.setDescription(i18n.translate(captionkey));
         return controlButton;
     }
 
     /**
      * Add File Name.<br>
      * If editFileName is true, display an Input Text Field. <br>
      * Else display a simple label.
      */
     protected Component getFileName() {
         // Build the file name without the extension
         final boolean hasExtension = StringUtils.isNotBlank(getValue().getExtension());
         final String extension = hasExtension ? "." + getValue().getExtension() : "";
         String fileName = StringUtils.removeEnd(getValue().getFileName(), extension);
 
         if (this.editFileName && !isReadOnly()) {
             TextField textField = new TextField(i18n.translate(fileDetailNameCaption), fileName);
             textField.setCaption(i18n.translate(fileDetailNameCaption));
             textField.addValueChangeListener((HasValue.ValueChangeListener<String>) event -> {
                 Object newFileNameObject = event.getValue();
                 String newFileName = (newFileNameObject != null && StringUtils.isNotBlank(newFileNameObject.toString())) ? newFileNameObject.toString() : UploadReceiver.INVALID_FILE_NAME;
                 getValue().setFileName(newFileName + extension);
                 getPropertyDataSource().setValue(getValue());
             });
             return textField;
         } else {
             Label label = new Label();
             label.setCaption(i18n.translate(fileDetailNameCaption));
             label.setValue(fileName);
             return label;
         }
     }
 
     /**
      * Initialize a Component displaying some File Informations.
      * Override getFileDetail...() in order to display custom info's you may want to display.
      *
      * @return A file Info Component. Generally a {@link FormLayout}.
      */
     private Component createFileInfoComponent() {
         if (fileInfo == null) {
             fileInfo = new FormLayout();
         }
         fileInfo.removeAllComponents();
         fileInfo.setSizeUndefined();
         fileInfo.addStyleName("file-details");
         fileInfo.addComponent(getFileName());
         fileInfo.addComponent(getFileDetailSize());
         fileInfo.addComponent(getFileDetailFileFormat());
         return fileInfo;
     }
 
     /**
      * Add File Info.
      */
     protected Component getFileDetailSize() {
         Label label = new Label();
         label.setCaption(i18n.translate(fileDetailSizeCaption));
         label.setValue(FileUtils.byteCountToDisplaySize(getValue().getFileSize()));
         return label;
     }
 
     /**
      * Add File Format.<br>
      * If editFileFormat is true, display an Input Text Field. <br>
      * Else display a simple label.
      */
     protected Component getFileDetailFileFormat() {
         if (this.editFileFormat && !isReadOnly()) {
             TextField textField = new TextField(i18n.translate(fileDetailFormatCaption), getValue().getExtension());
             textField.setCaption(i18n.translate(fileDetailFormatCaption));
             return textField;
         } else {
             Label label = new Label();
             label.setValue(getValue().getExtension());
             label.setCaption(i18n.translate(fileDetailFormatCaption));
             return label;
         }
     }
 
     /**
      * @return Thumbnail Component.
      */
     protected Component createThumbnailComponent() {
         Label thumbnail = new Label();
         thumbnail.setSizeUndefined();
         thumbnail.addStyleName("file-preview");
         thumbnail.addStyleName(createIconStyleName());
         return thumbnail;
     }
 
     /**
      * Create the Icon related to a File. <br>
      * <b>Override this method in order to change the Displayed Icon .</b>
      *
      * @return
      */
     protected String createIconStyleName() {
         return "icon-" + imageProvider.resolveIconClassName(getValue().getMimeType());
     }
 
     @Override
     protected Component initContent() {
         return getRootLayout();
     }
 
     protected SimpleTranslator getI18n() {
         return i18n;
     }
 
     protected CssLayout getUploadZone() {
         return uploadZone;
     }
 
     /**
      * Configure Field based on the definition.
      */
     protected void populateFromDefinition(BasicUploadFieldDefinition definition) {
         this.setMaxUploadSize(definition.getMaxUploadSize());
         this.setAllowedMimeTypePattern(definition.getAllowedMimeTypePattern());
 
         this.setSelectNewCaption("field.upload.basic.m6.select.new");
         this.setSelectAnotherCaption("field.upload.basic.m6.select.another");
         this.setDropZoneCaption("field.upload.basic.m6.drop.hint");
         this.setInProgressCaption("field.upload.basic.m6.uploading.file");
 
         this.setInProgressRatioCaption(definition.getInProgressRatioCaption());
         this.setFileDetailHeaderCaption(definition.getFileDetailHeaderCaption());
         this.setFileDetailNameCaption(definition.getFileDetailNameCaption());
         this.setFileDetailSizeCaption(definition.getFileDetailSizeCaption());
         this.setFileDetailFormatCaption(definition.getFileDetailFormatCaption());
         this.setFileDetailSourceCaption(definition.getFileDetailSourceCaption());
         this.setSuccessNoteCaption(definition.getSuccessNoteCaption());
         this.setWarningNoteCaption(definition.getWarningNoteCaption());
         this.setErrorNoteCaption(definition.getErrorNoteCaption());
         this.setDeteteCaption(definition.getDeleteCaption());
         this.setEditFileFormat(definition.isEditFileFormat());
         this.setEditFileName(definition.isEditFileName());
         this.setUserInterruption(definition.getUserInterruption());
         this.setTypeInterruption(definition.getTypeInterruption());
         this.setSizeInterruption(definition.getSizeInterruption());
     }
 
     protected String getCaption(String caption, String[] args) {
         if (StringUtils.isEmpty(caption)) {
             return "";
         }
         if (args != null && args.length > 0) {
             return i18n.translate(caption, args);
         } else {
             return i18n.translate(caption);
         }
     }
 
     protected String selectNewCaption;
     protected String selectAnotherCaption;
     protected String deleteCaption;
     protected String dropZoneCaption;
     protected String inProgressCaption;
     protected String inProgressRatioCaption;
     protected String fileDetailHeaderCaption;
     protected String fileDetailNameCaption;
     protected String fileDetailSizeCaption;
     protected String fileDetailFormatCaption;
     protected String fileDetailSourceCaption;
     protected String successNoteCaption;
     protected String warningNoteCaption;
     protected String errorNoteCaption;
     private String sizeInterruption;
     private String typeInterruption;
     private String userInterruption;
 
     public void setSelectNewCaption(String selectNewCaption) {
         this.selectNewCaption = selectNewCaption;
     }
 
     public void setSelectAnotherCaption(String selectAnotherCaption) {
         this.selectAnotherCaption = selectAnotherCaption;
     }
 
     public void setDropZoneCaption(String dropZoneCaption) {
         this.dropZoneCaption = dropZoneCaption;
     }
 
     public void setInProgressCaption(String inProgressCaption) {
         this.inProgressCaption = inProgressCaption;
     }
 
     public void setInProgressRatioCaption(String inProgressRatioCaption) {
         this.inProgressRatioCaption = inProgressRatioCaption;
     }
 
     public void setFileDetailHeaderCaption(String fileDetailHeaderCaption) {
         this.fileDetailHeaderCaption = fileDetailHeaderCaption;
     }
 
     public void setFileDetailNameCaption(String fileDetailNameCaption) {
         this.fileDetailNameCaption = fileDetailNameCaption;
     }
 
     public void setFileDetailSizeCaption(String fileDetailSizeCaption) {
         this.fileDetailSizeCaption = fileDetailSizeCaption;
     }
 
     public void setFileDetailFormatCaption(String fileDetailFormatCaption) {
         this.fileDetailFormatCaption = fileDetailFormatCaption;
     }
 
     public void setFileDetailSourceCaption(String fileDetailSourceCaption) {
         this.fileDetailSourceCaption = fileDetailSourceCaption;
     }
 
     public void setSuccessNoteCaption(String successNoteCaption) {
         this.successNoteCaption = successNoteCaption;
     }
 
     public void setWarningNoteCaption(String warningNoteCaption) {
         this.warningNoteCaption = warningNoteCaption;
     }
 
     public void setErrorNoteCaption(String errorNoteCaption) {
         this.errorNoteCaption = errorNoteCaption;
     }
 
     public void setDeteteCaption(String deleteCaption) {
         this.deleteCaption = deleteCaption;
     }
 
     public void setSizeInterruption(String sizeInterruption) {
         this.sizeInterruption = sizeInterruption;
     }
 
     public void setTypeInterruption(String typeInterruption) {
         this.typeInterruption = typeInterruption;
     }
 
     public void setUserInterruption(String userInterruption) {
         this.userInterruption = userInterruption;
     }
 
     @Override
     protected void displayUploadInterruptNote(InterruptionReason reason) {
         String caption;
         if (reason.equals(InterruptionReason.USER)) {
             caption = userInterruption;
         } else if (reason.equals(InterruptionReason.FILE_SIZE)) {
             caption = sizeInterruption;
         } else {
             caption = typeInterruption;
         }
         uiContext.openNotification(MessageStyleTypeEnum.WARNING, true, getCaption(warningNoteCaption, new String[] { i18n.translate(caption) }));
     }
 
     @Override
     protected void displayUploadFinishedNote(String fileName) {
         uiContext.openNotification(MessageStyleTypeEnum.INFO, true, getCaption(successNoteCaption, new String[] { fileName }));
     }
 
     @Override
     protected void displayUploadFailedNote(String fileName) {
         uiContext.openAlert(MessageStyleTypeEnum.ERROR, "ERROR", getCaption(errorNoteCaption, new String[] { fileName }), i18n.translate("button.ok"), null);
     }
 
     public void setEditFileName(boolean editFileName) {
         this.editFileName = editFileName;
     }
 
     public void setEditFileFormat(boolean editFileFormat) {
         this.editFileFormat = editFileFormat;
     }
 
     @Override
     public boolean isEmpty() {
         return getValue().isEmpty();
     }
 
     @Override
     public void setReadOnly(boolean readOnly) {
         super.setReadOnly(readOnly);
         if (readOnly) {
             // Remove drop zone
             if (getDropZone() != null) {
                 getDropZone().setDropHandler(null);
             }
             if (getUpload() != null) {
                 getUpload().removeStartedListener(this);
                 getUpload().removeFinishedListener(this);
                 getUpload().removeProgressListener(this);
             }
             if (getValue().isEmpty()) {
                 buildEmptyLayout();
             }
         }
 
     }
 }