/**
    * 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.ui.form.definition;
  
  import info.magnolia.dynamic.MagnoliaProxy;
  import info.magnolia.ui.api.action.ActionDefinition;
  import info.magnolia.ui.api.action.ConfiguredActionDefinition;
  import info.magnolia.ui.contentapp.action.CloseActionDefinition;
  import info.magnolia.ui.contentapp.action.CommitActionDefinition;
  import info.magnolia.ui.dialog.ConfiguredFormDialogDefinition;
  import info.magnolia.ui.dialog.DialogDefinition;
  import info.magnolia.ui.dialog.action.CancelDialogActionDefinition;
  import info.magnolia.ui.dialog.action.SaveDialogActionDefinition;
  import info.magnolia.ui.field.ConfiguredNamedFieldDefinition;
  import info.magnolia.ui.field.EditorPropertyDefinition;
  import info.magnolia.ui.field.NamedFieldDefinition;
  import info.magnolia.ui.editor.ConfiguredFormDefinition;
  import info.magnolia.ui.editor.FormDefinition;
  import info.magnolia.ui.form.action.CancelFormActionDefinition;
  import info.magnolia.ui.form.action.SaveFormActionDefinition;
  import info.magnolia.ui.form.field.definition.BasicTextCodeFieldDefinition;
  import info.magnolia.ui.form.field.definition.BasicUploadFieldDefinition;
  import info.magnolia.ui.form.field.definition.CheckboxFieldDefinition;
  import info.magnolia.ui.form.field.definition.CodeFieldDefinition;
  import info.magnolia.ui.form.field.definition.CompositeFieldDefinition;
  import info.magnolia.ui.form.field.definition.DateFieldDefinition;
  import info.magnolia.ui.form.field.definition.HiddenFieldDefinition;
  import info.magnolia.ui.form.field.definition.LinkFieldDefinition;
  import info.magnolia.ui.form.field.definition.MultiValueFieldDefinition;
  import info.magnolia.ui.form.field.definition.OptionGroupFieldDefinition;
  import info.magnolia.ui.form.field.definition.RichTextFieldDefinition;
  import info.magnolia.ui.form.field.definition.SelectFieldDefinition;
  import info.magnolia.ui.form.field.definition.StaticFieldDefinition;
  import info.magnolia.ui.form.field.definition.SwitchableFieldDefinition;
  import info.magnolia.ui.form.field.definition.TextFieldDefinition;
  import info.magnolia.ui.form.field.definition.TwinColSelectFieldDefinition;
  import info.magnolia.ui.form.field.definition.migration.CheckboxFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.CodeFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.CompositeFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.DateFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.FieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.FallbackFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.HiddenFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.LinkFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.MultiValueFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.OptionGroupFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.RichTextFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.SelectFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.StaticFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.SwitchableFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.TextFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.TwinColSelectFieldDefinitionConverter;
  import info.magnolia.ui.form.field.definition.migration.BasicUploadFieldDefinitionConverter;
  import info.magnolia.ui.framework.layout.ConfiguredTabDefinition;
  import info.magnolia.ui.framework.layout.TabDefinition;
  import info.magnolia.ui.framework.layout.TabbedLayoutDefinition;
  
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Optional;
  import java.util.Set;
  import java.util.stream.Collectors;
  
  import org.apache.commons.collections4.CollectionUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
 
 import net.sf.cglib.proxy.Enhancer;
 
 /**
  * Functional interface for definition converters.
  *
  * @param <OLD> - old definition class
  * @param <NEW> - new definition class
  *
  * @deprecated since 6.2.1 - for compatibility use only.
  */
 @Deprecated
 @FunctionalInterface
 public interface DefinitionConverter<OLD, NEW> {
 
     Logger log = LoggerFactory.getLogger(DefinitionConverter.class);
 
     NEW convert(OLD definition);
 
     Map<Class<? extends info.magnolia.ui.form.field.definition.FieldDefinition>, FieldDefinitionConverter> FIELD_DEFINITION_CONVERTERS = new HashMap<Class<? extends info.magnolia.ui.form.field.definition.FieldDefinition>, FieldDefinitionConverter>() {{
         put(TextFieldDefinition.class, new TextFieldDefinitionConverter());
         put(StaticFieldDefinition.class, new StaticFieldDefinitionConverter());
         put(HiddenFieldDefinition.class, new HiddenFieldDefinitionConverter());
         put(CodeFieldDefinition.class, new CodeFieldDefinitionConverter());
         put(BasicTextCodeFieldDefinition.class, new CodeFieldDefinitionConverter());
         put(CheckboxFieldDefinition.class, new CheckboxFieldDefinitionConverter());
         put(RichTextFieldDefinition.class, new RichTextFieldDefinitionConverter());
         put(DateFieldDefinition.class, new DateFieldDefinitionConverter());
         put(LinkFieldDefinition.class, new LinkFieldDefinitionConverter());
         put(SelectFieldDefinition.class, new SelectFieldDefinitionConverter());
         put(OptionGroupFieldDefinition.class, new OptionGroupFieldDefinitionConverter());
         put(TwinColSelectFieldDefinition.class, new TwinColSelectFieldDefinitionConverter());
         put(BasicUploadFieldDefinition.class, new BasicUploadFieldDefinitionConverter());
         put(SwitchableFieldDefinition.class, new SwitchableFieldDefinitionConverter());
         put(CompositeFieldDefinition.class, new CompositeFieldDefinitionConverter());
         put(MultiValueFieldDefinition.class, new MultiValueFieldDefinitionConverter());
     }};
 
     DefinitionConverter<info.magnolia.ui.form.field.definition.FieldDefinition, NamedFieldDefinition> NAMED = (oldDefinition) -> {
         ConfiguredNamedFieldDefinition namedDefinition = new ConfiguredNamedFieldDefinition();
         namedDefinition.setName(oldDefinition instanceof BasicUploadFieldDefinition ?
                 ((BasicUploadFieldDefinition) oldDefinition).getBinaryNodeName() :
                 oldDefinition.getName());
         return namedDefinition;
     };
 
     DefinitionConverter<info.magnolia.ui.form.definition.TabDefinition, TabDefinition> TAB = (oldDefinition) -> {
         ConfiguredTabDefinitioninition.html#ConfiguredTabDefinition">ConfiguredTabDefinition newDefinition = new ConfiguredTabDefinition();
         newDefinition.setLabel(oldDefinition.getLabel());
         newDefinition.setName(oldDefinition.getName());
         newDefinition.setFields(oldDefinition.getFields().stream().map(NAMED::convert).collect(Collectors.toList()));
         return newDefinition;
     };
 
     DefinitionConverter<info.magnolia.ui.form.field.definition.FieldDefinition, EditorPropertyDefinition> FIELD = (oldDefinition) -> {
         log.debug("Converting old framework field definition [{}] to new definition.", oldDefinition.getName());
 
         Class oldDefinitionClass = Enhancer.isEnhanced(oldDefinition.getClass()) || MagnoliaProxy.class.isAssignableFrom(oldDefinition.getClass())
                 ? oldDefinition.getClass().getSuperclass() : oldDefinition.getClass();
         FieldDefinitionConverter converter = Optional.of(oldDefinitionClass)
                 .map(FIELD_DEFINITION_CONVERTERS::get)
                 .filter(selectedConverter -> selectedConverter.supports(oldDefinition))
                 .orElseGet(FallbackFieldDefinitionConverter::new);
         return converter.convert(oldDefinition);
     };
 
     DefinitionConverter<info.magnolia.ui.form.definition.FormDefinition, FormDefinition> FORM = (oldDefinition) -> {
         TabbedLayoutDefinition tabbedLayoutDefinition = new TabbedLayoutDefinition();
         tabbedLayoutDefinition.setTabs(oldDefinition.getTabs().stream()
                 .filter(tabDefinition -> CollectionUtils.isNotEmpty(tabDefinition.getFields()))
                 .map(TAB::convert)
                 .collect(Collectors.toList()));
         ConfiguredFormDefinition<?> newDefinition = new ConfiguredFormDefinition<>();
         newDefinition.setName(oldDefinition.getLabel());
         newDefinition.setLayout(tabbedLayoutDefinition);
         //newDefinition.setImplementationClass();
         final Set<String> fieldNames = new HashSet<>();
         List<EditorPropertyDefinition> properties = oldDefinition
                 .getTabs()
                 .stream()
                 .map(info.magnolia.ui.form.definition.TabDefinition::getFields)
                 .flatMap(List::stream)
                 .map(FIELD::convert)
                 .filter(field -> {
                     if (fieldNames.contains(field.getName())) {
                         // old form definitions could have more than one (static) fields of the same name on different tabs
                         log.warn("Removing field with non-unique name: " + field.getName());
                         return false;
                     }
                     fieldNames.add(field.getName());
                     return true;
                 })
                 .collect(Collectors.toList());
 
         newDefinition.setProperties(properties);
         return newDefinition;
     };
 
     DefinitionConverter<ActionDefinition, ActionDefinition> ACTION = (oldDefinition) -> {
         log.debug("Converting old framework action definition [{}] to new definition.", oldDefinition.getName());
         if (oldDefinition instanceof SaveFormActionDefinition || oldDefinition instanceof SaveDialogActionDefinition) {
             return withOldActionDefinitionProperties(new CommitActionDefinition(), oldDefinition);
         } else if (oldDefinition instanceof CancelDialogActionDefinition || oldDefinition instanceof CancelFormActionDefinition) {
             return withOldActionDefinitionProperties(new CloseActionDefinition(), oldDefinition);
         } else {
             final ConfiguredActionDefinition configuredActionDefinition = new ConfiguredActionDefinition();
             configuredActionDefinition.setName("Unsupported action");
             configuredActionDefinition.setDescription("Please migrate to new framework dialog");
             return configuredActionDefinition;
         }
     };
 
     static ActionDefinition withOldActionDefinitionProperties(CloseActionDefinition newDefinition, ActionDefinition oldDefinition) {
         newDefinition.setLabel(oldDefinition.getLabel());
         newDefinition.setIcon(oldDefinition.getIcon());
         newDefinition.setDescription(oldDefinition.getDescription());
         newDefinition.setErrorMessage(oldDefinition.getErrorMessage());
         newDefinition.setFailureMessage(oldDefinition.getFailureMessage());
         newDefinition.setSuccessMessage(oldDefinition.getSuccessMessage());
         return newDefinition;
     }
 
     DefinitionConverter<info.magnolia.ui.dialog.definition.FormDialogDefinition, DialogDefinition> DIALOG = (oldDefinition) -> {
         log.debug("Converting old framework dialog definition [{}] to new definition.",oldDefinition.getId());
         ConfiguredFormDialogDefinition<Object> newDefinition = new ConfiguredFormDialogDefinition<>();
         final FormDefinition<Object> convert = FORM.convert(oldDefinition.getForm());
         String i18nLabel = Optional.ofNullable(oldDefinition.getLabel())
                 .filter(DefinitionConverter::isNotMessageKey)
                 .orElse(oldDefinition.getForm().getLabel());
 
         i18nLabel = Optional.ofNullable(i18nLabel).filter(DefinitionConverter::isNotMessageKey).orElse("");
 
         newDefinition.setLabel(i18nLabel);
         newDefinition.setId(oldDefinition.getId());
         newDefinition.setWide(oldDefinition.isWide());
         newDefinition.setLight(oldDefinition.isLight());
         newDefinition.setForm(convert);
         newDefinition.setActions(oldDefinition.getActions().entrySet().stream()
                 .collect(Collectors.toMap(Map.Entry::getKey, entry -> ACTION.convert(entry.getValue())))
         );
         return newDefinition;
     };
 
     /**
      * @deprecated is a hack and should not be used. See MGNLUI-2207.
      */
     @Deprecated
     static boolean isNotMessageKey(final String text) {
         return text.contains(" ") || !text.contains(".") || text.endsWith(".");
     }
 }