/**
    * This file Copyright (c) 2011-2017 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;
  
  import info.magnolia.cms.security.SecurityUtil;
  import info.magnolia.context.Context;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.ui.form.field.definition.PasswordFieldDefinition;
  
  import javax.inject.Provider;
  
  import org.apache.commons.lang3.StringUtils;
  
  import com.vaadin.ui.Component;
  import com.vaadin.v7.data.Property;
  import com.vaadin.v7.data.Validator.InvalidValueException;
  import com.vaadin.v7.ui.CustomField;
  import com.vaadin.v7.ui.Label;
  import com.vaadin.v7.ui.PasswordField;
  import com.vaadin.v7.ui.VerticalLayout;
  
  /**
   * Password field that is capable of
   * <ul>
   *     <li>Checking if current user password matches the entered one in the current password field (compared using BCrypt).</li>
   *     <li>Verifying whether passwords entered in the password verification fields matches.</li>
   * </ul>
   */
  public class PasswordFields extends CustomField<String> {
  
      private PasswordField passwordField;
      private PasswordField verificationField;
      private PasswordField currentPasswordField;
      private Provider<Context> contextProvider;
      private PasswordFieldDefinition definition;
      private VerticalLayout layout;
  
      public PasswordFields(Provider<Context> contextProvider, PasswordFieldDefinition definition) {
          this.contextProvider = contextProvider;
          this.definition = definition;
  
          passwordField = new PasswordField();
          passwordField.setNullRepresentation("");
          passwordField.setWidth("100%");
          if (this.definition.isVerification()) {
              verificationField = new PasswordField();
              verificationField.setNullRepresentation("");
              verificationField.setWidth("100%");
          }
          if (this.definition.isVerificationCurrentPassword()) {
              currentPasswordField = new PasswordField();
              currentPasswordField.setNullRepresentation("");
              currentPasswordField.setWidth("100%");
          }
  
          getContent();
      }
  
      /**
       * Create a {@link CustomField} based on a {@link VerticalLayout}.
       * The layout is composed by:
       * - {@link PasswordField}.
       * if verification:
       * - {@link Label} (verificationMessage).
       * - {@link PasswordField}.
       * @deprecated since 5.5.2 - use {@link #PasswordFields(Provider, PasswordFieldDefinition)} instead.
       */
      @Deprecated
     public PasswordFields(boolean verification, String verificationMessage, String verificationErrorMessage) {
         this(MgnlContext::getInstance, new PasswordFieldDefinition());
     }
 
     @Override
     protected Component initContent() {
         // Init layout
         layout = new VerticalLayout();
         if (definition.isVerificationCurrentPassword()) {
             layout.addComponent(new Label(definition.getVerificationCurrentPasswordMessage()));
             layout.addComponent(currentPasswordField);
         }
         // add inner label to passwordField only when currentPasswordField or verificationField are used because otherwise field label is enough
         if (definition.isVerification() || definition.isVerificationCurrentPassword()) {
             layout.addComponent(new Label(definition.getPasswordMessage()));
         }
         layout.addComponent(passwordField);
         if (definition.isVerification()) {
             layout.addComponent(new Label(definition.getVerificationMessage()));
             layout.addComponent(verificationField);
         }
         return layout;
     }
 
     public VerticalLayout getVerticalLayout() {
         return this.layout;
     }
 
     /**
      * Check if both fields are equals.
      */
     @Override
     public void validate() throws InvalidValueException {
         super.validate();
         if (StringUtils.isNotBlank(passwordField.getValue())) {
             if (definition.isVerificationCurrentPassword()) {
                 if (StringUtils.isBlank(currentPasswordField.getValue()) || !SecurityUtil.matchBCrypted(currentPasswordField.getValue(), contextProvider.get().getUser().getPassword())) {
                     throw new InvalidValueException(definition.getVerificationCurrentPasswordErrorMessage());
                 }
             }
             if (definition.isVerification()) {
                 if (StringUtils.isBlank(passwordField.getValue()) || StringUtils.isBlank(verificationField.getValue())) {
                     throw new InvalidValueException(definition.getVerificationErrorMessage());
                 }
                 if (!passwordField.getValue().equals(verificationField.getValue())) {
                     throw new InvalidValueException(definition.getVerificationErrorMessage());
                 }
             }
         }
     }
 
     @Override
     public boolean isValid() {
         if (super.isValid()) {
             try {
                 this.validate();
                 return true;
             } catch (InvalidValueException ive) {
                 return false;
             }
         } else {
             return false;
         }
     }
 
     @Override
     public Class<String> getType() {
         return String.class;
     }
 
     @Override
     public String getValue() {
         return passwordField.getValue();
     }
 
     @Override
     public void setValue(String newValue) throws ReadOnlyException {
         passwordField.setValue(newValue);
     }
 
     @Override
     @SuppressWarnings("rawtypes")
     public void setPropertyDataSource(Property newDataSource) {
         newDataSource.setValue("");
         passwordField.setPropertyDataSource(newDataSource);
         if (definition.isVerification() && newDataSource.getValue() != null) {
             verificationField.setValue(String.valueOf(newDataSource.getValue()));
         }
         super.setPropertyDataSource(newDataSource);
     }
 
     @Override
     public Property<?> getPropertyDataSource() {
         return passwordField.getPropertyDataSource();
     }
 
     @Override
     public boolean isEmpty() {
         // this method is used to evaluate if field contains non empty value for validation of required field
         // value must be checked against NullRepresentation
         return getValue() == passwordField.getNullRepresentation();
     }
 }