EDIT

/**

* Copyright (C) 2017 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.vaadin.mvp;

import java.util.Arrays;

import com.vaadin.data.Validator.InvalidValueException;

import com.vaadin.data.fieldgroup.FieldGroup.CommitEvent;

import com.vaadin.data.fieldgroup.FieldGroup.CommitException;

import com.vaadin.data.fieldgroup.FieldGroup.CommitHandler;

import com.vaadin.server.AbstractErrorMessage.ContentMode;

import com.vaadin.server.ErrorMessage.ErrorLevel;

import com.vaadin.ui.Alignment;

import com.vaadin.ui.Button;

import com.vaadin.ui.CheckBox;

import com.vaadin.ui.Component;

import com.vaadin.ui.GridLayout.OutOfBoundsException;

import com.vaadin.ui.GridLayout.OverlapsException;

import com.vaadin.ui.Notification.Type;

import com.vaadin.ui.PopupDateField;

import com.vaadin.ui.TextField;

import com.vaadin.ui.VerticalLayout;

import com.vaadin.ui.themes.ValoTheme;

import eu.etaxonomy.cdm.vaadin.event.AbstractEditorAction.EditorActionContext;

import eu.etaxonomy.vaadin.mvp.event.EditorSaveEvent;

import eu.etaxonomy.vaadin.ui.view.DoneWithPopupEvent.Reason;

/**

 * Optional with a delete button which can be enabled with {@link #withDeleteButton(boolean)}

 *

 * @since Apr 5, 2017

 *

 */

    private VerticalLayout mainLayout;

    private Layout fieldLayout;

    private HorizontalLayout buttonLayout;

    private Button save;

    private Button cancel;

    private CssLayout toolBarButtonGroup = new CssLayout();

    Set<String> statusMessages = new HashSet<>();

    private boolean isContextUpdated;

    private List<Component> advancedModeComponents = new ArrayList<>();

    private Button advancedModeButton;

        mainLayout = new VerticalLayout();

        // popup window may have problems with automatic resizing of its

        // content.

        mainLayout.setSizeFull();

        fieldGroup = new BeanFieldGroup<>(dtoType);

        fieldGroup.addCommitHandler(new SaveHandler());

        toolBar.setWidth(100, Unit.PERCENTAGE);

        toolBarButtonGroup.addStyleName(ValoTheme.LAYOUT_COMPONENT_GROUP);

        toolBarButtonGroup.setWidthUndefined();

        toolBar.addComponent(toolBarButtonGroup);

        toolBar.setVisible(false);

        fieldLayout.setWidthUndefined();

        if(fieldLayout instanceof AbstractOrderedLayout){

            ((AbstractOrderedLayout)fieldLayout).setSpacing(true);

        }

            ((MarginHandler)fieldLayout).setMargin(new MarginInfo(false, true, true, true));

        }

        buttonLayout = new HorizontalLayout();

        buttonLayout.setStyleName(ValoTheme.WINDOW_BOTTOM_TOOLBAR);

        buttonLayout.setWidth(100, Unit.PERCENTAGE);

        buttonLayout.setSpacing(true);

        save = new Button("Save", FontAwesome.SAVE);

        save.setStyleName(ValoTheme.BUTTON_PRIMARY);

        delete.addClickListener(e -> delete());

        buttonLayout.addComponents(delete, save, cancel);

        buttonLayout.setExpandRatio(save, 1);

        buttonLayout.setComponentAlignment(cancel, Alignment.TOP_RIGHT);

        mainLayout.addComponents(toolBar, fieldLayout, statusMessageLabel, buttonLayout);

        mainLayout.setComponentAlignment(statusMessageLabel, Alignment.BOTTOM_RIGHT);

        updateToolBarVisibility();

    protected VerticalLayout getMainLayout() {

        return mainLayout;

    }

        return fieldLayout;

    }

    /**

     * @return

     */

    private GridLayout gridLayout() {

        if(_gridLayoutCache == null){

            if(fieldLayout instanceof GridLayout){

                _gridLayoutCache = (GridLayout)fieldLayout;

            } else {

                throw new RuntimeException("The fieldlayout of this editor is not a GridLayout");

            }

        }

        return _gridLayoutCache;

    }

    public void setReadOnly(boolean readOnly) {

        super.setReadOnly(readOnly);

        save.setVisible(!readOnly);

    }

    /**

     * @param readOnly

     * @param layout

     */

    protected void recursiveReadonly(boolean readOnly, AbstractComponentContainer layout) {

        for(Component c : layout){

            c.setReadOnly(readOnly);

            if(c instanceof AbstractComponentContainer){

        }

     * @return

     * @return

     */

    protected AbstractLayout getToolBar() {

        return toolBar;

    }

    /**

     * @return

     * @return

     */

    protected void toolBarAdd(Component c) {

        toolBar.addComponent(c, toolBar.getComponentIndex(toolBarButtonGroup) - 1);

        updateToolBarVisibility();

    }

    /**

     * @return

     * @return

     */

    protected void toolBarButtonGroupAdd(Component c) {

        toolBarButtonGroup.addComponent(c);

        updateToolBarVisibility();

    }

    /**

     * @return

     * @return

     */

    protected void toolBarButtonGroupRemove(Component c) {

        toolBarButtonGroup.removeComponent(c);

        updateToolBarVisibility();

    }

    /**

     *

     */

    private void updateToolBarVisibility() {

            mainLayout.setMargin(new MarginInfo(true, false, false, false));

        } else {

            mainLayout.setMargin(false);

        }

    }

    /**

     * The top tool-bar is initially invisible.

     *

     * @param visible

     */

    protected void setToolBarVisible(boolean visible){

        toolBar.setVisible(true);

    }

     * @return the isAdvancedMode

     */

    public boolean isAdvancedMode() {

        return isAdvancedMode;

    }

    /**

     * @param isAdvancedMode the isAdvancedMode to set

     */

    public void setAdvancedMode(boolean isAdvancedMode) {

        this.isAdvancedMode = isAdvancedMode;

        advancedModeComponents.forEach(c -> c.setVisible(isAdvancedMode));

    }

    public void setAdvancedModeEnabled(boolean activate){

        if(activate && advancedModeButton == null){

            advancedModeButton = new Button(FontAwesome.WRENCH); // FontAwesome.FLASK

            advancedModeButton.setIconAlternateText("Advanced mode");

            advancedModeButton.addStyleName(ValoTheme.BUTTON_TINY);

            toolBarButtonGroupAdd(advancedModeButton);

            advancedModeButton.addClickListener(e -> {

                setAdvancedMode(!isAdvancedMode);

                }

            );

        } else if(advancedModeButton != null) {

            toolBarButtonGroupRemove(advancedModeButton);

            advancedModeButton = null;

        }

    }

    public void registerAdvancedModeComponents(Component ... c){

        advancedModeComponents.addAll(Arrays.asList(c));

    }

    private class SaveHandler implements CommitHandler {

        @Override

        public void preCommit(CommitEvent commitEvent) throws CommitException {

        @Override

        public void postCommit(CommitEvent commitEvent) throws CommitException {

            try {

                    logger.trace("postCommit() publishing EditorSaveEvent for " + getBean().toString());

                }

                    logger.trace("postCommit() publishing DoneWithPopupEvent");

                }

            }

        }

    }

    protected void addCommitHandler(CommitHandler commitHandler) {

        fieldGroup.addCommitHandler(commitHandler);

    }

     * Cancel editing and discard all modifications.

     */

    @Override

    public void cancel() {

     * @return

     */

    private void delete() {

        viewEventBus.publish(EventScope.UI, this, new DoneWithPopupEvent(this, Reason.DELETE));

     * Save the changes made in the editor.

     */

    private void save() {

            fieldGroup.commit();

        } catch (CommitException e) {

                FieldGroupInvalidValueException invalidValueException = (FieldGroupInvalidValueException)e.getCause();

                updateFieldNotifications(invalidValueException.getInvalidFields());

                Notification.show("The entered data in " + invalidValueException.getInvalidFields().size() + " fields is incomplete or invalid.");

                PermissionDeniedException permissionDeniedException = (PermissionDeniedException)e.getCause().getCause();

                Notification.show("Permission denied", permissionDeniedException.getMessage(), Type.ERROR_MESSAGE);

//                Logger.getLogger(this.getClass()).error("Error saving", e);

//                Notification.show("Error saving", Type.ERROR_MESSAGE);

                throw new RuntimeException("Error saving", e);

    }

     * @param invalidFields

     */

    private void updateFieldNotifications(Map<Field<?>, InvalidValueException> invalidFields) {

        for(Field<?> f : invalidFields.keySet()){

            if(f instanceof AbstractField){

                String message = invalidFields.get(f).getHtmlMessage();

                ((AbstractField)f).setComponentError(new UserError(message, ContentMode.HTML, ErrorLevel.ERROR));

            }

        }

    }

            int column2, int row2)

            throws OverlapsException, OutOfBoundsException {

    protected TextField addTextField(String caption, String propertyId, int column, int row)

            throws OverlapsException, OutOfBoundsException {

            int column2, int row2)

            throws OverlapsException, OutOfBoundsException {

        SwitchableTextField field = new SwitchableTextField(caption);

        field.bindTo(fieldGroup, textPropertyId, switchPropertyId);

        addComponent(field, column1, row1, column2, row2);

        return field;

    }

    protected SwitchableTextField addSwitchableTextField(String caption, String textPropertyId, String switchPropertyId, int column, int row)

            throws OverlapsException, OutOfBoundsException {

        SwitchableTextField field = new SwitchableTextField(caption);

        field.bindTo(fieldGroup, textPropertyId, switchPropertyId);

        addComponent(field, column, row);

        return field;

    }

        return addField(new PopupDateField(caption), propertyId);

    }

    protected CheckBox addCheckBox(String caption, String propertyId) {

        return addField(new CheckBox(caption), propertyId);

    }

        return addField(new CheckBox(caption), propertyId, column, row);

    }

        fieldGroup.bind(field, propertyId);

            ((NestedFieldGroup)field).registerParentFieldGroup(fieldGroup);

        }

        return field;

    }

    /**

     * Can only be used if the <code>fieldlayout</code> is a GridLayout.

     *

     * @param field

     *            the field to be added, not <code>null</code>.

     * @param propertyId

     * @param column

     *            the column index, starting from 0.

     * @param row

     *            the row index, starting from 0.

     * @throws OverlapsException

     *             if the new component overlaps with any of the components

     *             already in the grid.

     * @throws OutOfBoundsException

     *             if the cell is outside the grid area.

     */

    protected <T extends Field> T addField(T field, String propertyId, int column, int row)

            throws OverlapsException, OutOfBoundsException {

        fieldGroup.bind(field, propertyId);

            ((NestedFieldGroup)field).registerParentFieldGroup(fieldGroup);

        }

        return field;

    }

    /**

     * Can only be used if the <code>fieldlayout</code> is a GridLayout.

     *

     * @param field

     * @param propertyId

     * @param column1

     * @param row1

     * @param column2

     * @param row2

     * @return

     * @throws OverlapsException

     * @throws OutOfBoundsException

     */

    protected <T extends Field> T addField(T field, String propertyId, int column1, int row1,

            int column2, int row2)

            throws OverlapsException, OutOfBoundsException {

            fieldGroup.bind(field, propertyId);

                ((NestedFieldGroup)field).registerParentFieldGroup(fieldGroup);

            }

    }

        return fieldGroup.getField(propertyId);

    }

        PropertyIdPath propertyIdPath = null;

        Object propertyId = fieldGroup.getPropertyId(field);

        if(propertyId == null){

            // not found in the editor field group. Maybe the field is bound to a nested fieldgroup?

            // 1. find the NestedFieldGroup implementations from the field up to the editor

            logger.setLevel(Level.DEBUG);

            PropertyIdPath nestedPropertyIds = new PropertyIdPath();

            Field parentField = field;

            HasComponents parentComponent = parentField.getParent();

            logger.debug("field: " + parentField.getClass().getSimpleName());

            while(parentComponent != null){

                logger.debug("parentComponent: " + parentComponent.getClass().getSimpleName());

                if(NestedFieldGroup.class.isAssignableFrom(parentComponent.getClass()) && AbstractField.class.isAssignableFrom(parentComponent.getClass())){

                    Object propId = ((NestedFieldGroup)parentComponent).getFieldGroup().getPropertyId(parentField);

                    if(propId != null){

                        logger.debug("propId: " + propId.toString());

                        nestedPropertyIds.addParent(propId);

                    }

                    logger.debug("parentField: " + parentField.getClass().getSimpleName());

                    parentField = (Field)parentComponent;

                } else if(parentComponent == this) {

                    // we reached the editor itself

                    Object propId = fieldGroup.getPropertyId(parentField);

                    if(propId != null){

                        logger.debug("propId: " + propId.toString());

                        nestedPropertyIds.addParent(propId);

                    }

                    propertyIdPath = nestedPropertyIds;

                    break;

                }

                parentComponent = parentComponent.getParent();

            }

            // 2. check the NestedFieldGroup binding the field is direct or indirect child component of the editor

//            NO lONGER NEEDED

//            parentComponent = parentField.getParent(); // get component containing the last parent field found

//            while(true){

//                if(parentComponent == getFieldLayout()){

//                    propertyIdPath = nestedPropertyIds;

//                    break;

//                }

//                parentComponent = parentComponent.getParent();

//            }

        } else {

            propertyIdPath = new PropertyIdPath(propertyId);

        }

        return propertyIdPath;

    }

        fieldLayout.addComponent(component);

        fieldGroup.bind(field, propertyId);

    }

     * @param component

     */

    public void applyDefaultComponentStyles(Component component) {

    protected abstract String getDefaultComponentStyles();

    /**

     * Can only be used if the <code>fieldlayout</code> is a GridLayout.

     * <p>

     * Adds the component to the grid in cells column1,row1 (NortWest corner of

     * the area.) End coordinates (SouthEast corner of the area) are the same as

     * column1,row1. The coordinates are zero-based. Component width and height

     * is 1.

     *

     * @param component

     *            the component to be added, not <code>null</code>.

     * @param column

     *            the column index, starting from 0.

     * @param row

     *            the row index, starting from 0.

     * @throws OverlapsException

     *             if the new component overlaps with any of the components

     *             already in the grid.

     * @throws OutOfBoundsException

     *             if the cell is outside the grid area.

     */

    public void addComponent(Component component, int column, int row)

            throws OverlapsException, OutOfBoundsException {

        applyDefaultComponentStyles(component);

        gridLayout().addComponent(component, column, row, column, row);

    }

    /**

     * Can only be used if the <code>fieldlayout</code> is a GridLayout.

     * <p>

     * Adds a component to the grid in the specified area. The area is defined

     * by specifying the upper left corner (column1, row1) and the lower right

     * corner (column2, row2) of the area. The coordinates are zero-based.

     * </p>

     *

     * <p>

     * If the area overlaps with any of the existing components already present

     * in the grid, the operation will fail and an {@link OverlapsException} is

     * thrown.

     * </p>

     *

     * @param component

     *            the component to be added, not <code>null</code>.

     * @param column1

     *            the column of the upper left corner of the area <code>c</code>

     *            is supposed to occupy. The leftmost column has index 0.

     * @param row1

     *            the row of the upper left corner of the area <code>c</code> is

     *            supposed to occupy. The topmost row has index 0.

     * @param column2

     *            the column of the lower right corner of the area

     *            <code>c</code> is supposed to occupy.

     * @param row2

     *            the row of the lower right corner of the area <code>c</code>

     *            is supposed to occupy.

     * @throws OverlapsException

     *             if the new component overlaps with any of the components

     *             already in the grid.

     * @throws OutOfBoundsException

     *             if the cells are outside the grid area.

     */

    public void addComponent(Component component, int column1, int row1,

            int column2, int row2)

            throws OverlapsException, OutOfBoundsException {

        applyDefaultComponentStyles(component);

        gridLayout().addComponent(component, column1, row1, column2, row2);

    }

        save.setEnabled(enabled);

    }

        if(withDelete){

            buttonLayout.setExpandRatio(save, 0);

            buttonLayout.setExpandRatio(delete, 1);

        } else {

            buttonLayout.setExpandRatio(save, 1);

            buttonLayout.setExpandRatio(delete, 0);

        }

        delete.setVisible(withDelete);

    }

        boolean returnVal = statusMessages.add(message);

        updateStatusLabel();

        return returnVal;

    }

    public boolean removeStatusMessage(String message){

        boolean returnVal = statusMessages.remove(message);

        updateStatusLabel();

        return returnVal;

    }

    /**

     *

     */

    private void updateStatusLabel() {

        String text = "";

        for(String s : statusMessages){

            text += s + " ";

        }

        statusMessageLabel.setValue(text);