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.taxeditor.editor.descriptiveDataSet.matrix;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import java.util.stream.Collectors;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.e4.core.contexts.ContextInjectionFactory;

import org.eclipse.e4.core.contexts.IEclipseContext;

import org.eclipse.e4.ui.di.Focus;

import org.eclipse.e4.ui.di.Persist;

import org.eclipse.e4.ui.model.application.ui.MDirtyable;

import org.eclipse.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.e4.ui.workbench.modeling.ESelectionService;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.nebula.widgets.nattable.NatTable;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.StackLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Label;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;

import eu.etaxonomy.cdm.api.service.DeleteResult;

import eu.etaxonomy.cdm.api.service.IDescriptionService;

import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService;

import eu.etaxonomy.cdm.api.service.config.RemoveDescriptionsFromDescriptiveDataSetConfigurator;

import eu.etaxonomy.cdm.api.service.dto.DescriptionBaseDto;

import eu.etaxonomy.cdm.api.service.dto.RowWrapperDTO;

import eu.etaxonomy.cdm.api.service.dto.SpecimenRowWrapperDTO;

import eu.etaxonomy.cdm.model.description.DescriptionBase;

import eu.etaxonomy.cdm.model.description.DescriptiveDataSet;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.persistence.dto.MergeResult;

import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;

import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;

import eu.etaxonomy.taxeditor.editor.l10n.Messages;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;

/**

 * Character matrix editor for editing specimen/taxon descriptions in a table

 * @author pplitzner

 * @since Nov 26, 2017

 *

 */

public class CharacterMatrixPart implements IE4SavablePart, IConversationEnabled, IDirtyMarkable,

ICdmEntitySessionEnabled, IPartContentHasSupplementalData, IPartContentHasDetails{

    private static final List<String> WS_PROPERTY_PATH = Arrays.asList(new String[] {

            "descriptions", //$NON-NLS-1$

            "descriptions.describedSpecimenOrObservation", //$NON-NLS-1$

            "descriptions.describedSpecimenOrObservation.gatheringEvent", //$NON-NLS-1$

            "descriptions.describedSpecimenOrObservation.gatheringEvent.actor", //$NON-NLS-1$

            "descriptions.descriptionElements", //$NON-NLS-1$

            "descriptions.descriptionElements.stateData", //$NON-NLS-1$

            "descriptions.descriptionElements.stateData.state", //$NON-NLS-1$

            "descriptions.descriptionElements.inDescription", //$NON-NLS-1$

            "descriptions.descriptionElements.inDescription.descriptionElements", //$NON-NLS-1$

            "descriptions.descriptionElements.feature", //$NON-NLS-1$

            "representations", //$NON-NLS-1$

            "descriptiveSystem", //$NON-NLS-1$

            "taxonSubtreeFilter", //$NON-NLS-1$

            "taxonSubtreeFilter.parent", //$NON-NLS-1$

            "taxonSubtreeFilter.classification", //$NON-NLS-1$

            "taxonSubtreeFilter.taxon", //$NON-NLS-1$

            "taxonSubtreeFilter.taxon.name", //$NON-NLS-1$

            "taxonSubtreeFilter.taxon.name.rank", //$NON-NLS-1$

            "geoFilter", //$NON-NLS-1$

            "minRank", //$NON-NLS-1$

            "maxRank", //$NON-NLS-1$

    });

    private DescriptiveDataSet descriptiveDataSet;

    private ConversationHolder conversation;

    private ICdmEntitySession cdmEntitySession;

    @Inject

    private ESelectionService selService;

    @Inject

    private MDirtyable dirty;

    @Inject

    private MPart thisPart;

    private CharacterMatrix matrix;

    private StackLayout stackLayout;

    private Label label;

    @PostConstruct

    public void create(Composite parent, IEclipseContext context) {

        if(CdmStore.isActive() && conversation==null){

            conversation = CdmStore.createConversation();

        }

        if(cdmEntitySession == null){

            cdmEntitySession = CdmStore.getCurrentSessionManager().newSession(this, true);

            cdmEntitySession.bind();

        }

        else{

            return;

        }

        stackLayout = new StackLayout();

        parent.setLayout(stackLayout);

        matrix = new CharacterMatrix(parent, this);

        label = new Label(parent, SWT.NONE);

        label.setText(Messages.CharacterMatrixPart_LOADING_MATRIX);

        stackLayout.topControl = label;

        ContextInjectionFactory.inject(matrix, context);

    }

    public void init(UUID descriptiveDataSetUuid, boolean treeView) {

        this.descriptiveDataSet = CdmStore.getService(IDescriptiveDataSetService.class).load(descriptiveDataSetUuid, WS_PROPERTY_PATH);

        if(descriptiveDataSet!=null){

            if(descriptiveDataSet.getDescriptiveSystem()==null

                    || descriptiveDataSet.getDescriptiveSystem().getTermType()==null

                    || !descriptiveDataSet.getDescriptiveSystem().getTermType().equals(TermType.Character)){

                MessagingUtils.informationDialog(Messages.CharacterMatrixPart_COULD_NOT_OPEN, Messages.CharacterMatrixPart_COULD_NOT_OPEN_MESSAGE);

                loadingFailed();

                return;

            }

            try {

                matrix.initDescriptiveDataSet();

            } catch (IllegalArgumentException e) {

                MessagingUtils.errorDialog("Error during initilization", this, "Could not load matrix", TaxeditorEditorPlugin.PLUGIN_ID, e, false);

                loadingFailed();

                return;

            }

            matrix.createTable(treeView, true, true);

            thisPart.setLabel(descriptiveDataSet.getLabel());

            matrix.loadDescriptions( true, true);

        }

    }

    public IStructuredSelection getSelection(){

        return matrix.getSelection();

    }

    public void setDirty() {

        this.dirty.setDirty(true);

    }

    public DescriptiveDataSet getDescriptiveDataSet() {

        return descriptiveDataSet;

    }

    public void setDescriptiveDataSet(DescriptiveDataSet dataSet) {

        this.descriptiveDataSet = dataSet;

    }

    public NatTable getNatTable() {

        return matrix.getNatTable();

    }

    public ESelectionService getSelectionService() {

        return selService;

    }

    public CharacterMatrix getMatrix() {

        return matrix;

    }

    @Persist

    @Override

    public void save(IProgressMonitor monitor) {

        // save edited descriptions

        List<DescriptionBaseDto> descriptions = matrix.getRowsToMerge().values().stream()

        .map(row->row.getDescription())

        .collect(Collectors.toList());

        matrix.addSpecimensToDescriptiveDataSet();

        //newly added descriptions should not be saved again.

//        descriptions.removeAll(matrix.getRowsToSave().values());

        matrix.getRowsToMerge().clear();

        if (matrix.getDescriptionsToDelete() != null && !matrix.getDescriptionsToDelete().isEmpty()){

            DeleteResult result = new DeleteResult();

            for (RemoveDescriptionsFromDescriptiveDataSetConfigurator config: matrix.getDescriptionsToDelete().keySet()){

               result.includeResult(CdmStore.getService(IDescriptiveDataSetService.class).removeDescriptions(matrix.getDescriptionsToDelete().get(config), matrix.getDescriptiveDataSet().getUuid(), config));

            }

            matrix.getDescriptionsToDelete().clear();

        }

        List<MergeResult<DescriptionBase>> results = CdmStore.getService(IDescriptionService.class).mergeDescriptions(descriptions, matrix.getDescriptiveDataSet().getUuid(), true);

        conversation.commit();

        HashMap<UUID, DescriptionBase> descriptionResults = new HashMap<>();

        for (MergeResult result: results){

            if (result.getMergedEntity() != null){

                descriptionResults.put(result.getMergedEntity().getUuid(), (DescriptionBase)result.getMergedEntity());

            }

        }

        List<Object> updateRows = matrix.getDescriptions().stream().filter(row->descriptionResults.keySet().contains(((RowWrapperDTO)row).getDescription().getDescription().getUuid())).collect(Collectors.toList());

        for (Object updateRow: updateRows){

            if (updateRow instanceof SpecimenRowWrapperDTO){

                SpecimenRowWrapperDTO dto = (SpecimenRowWrapperDTO)updateRow;

                dto.getDescription().setDescription(descriptionResults.get(((SpecimenRowWrapperDTO) updateRow).getDescription().getDescription().getUuid()));

            }

        }

//        matrix.loadDescriptions(getDescriptiveDataSet().getUuid(), false);

        dirty.setDirty(false);

    }

    @Override

    public boolean isDirty() {

        return dirty.isDirty();

    }

    @Focus

    public void setFocus(){

        if(conversation!=null){

            conversation.bind();

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.bind();

        }

    }

    @PreDestroy

    public void dispose(){

        if (conversation != null) {

            conversation.close();

            conversation = null;

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.dispose();

            cdmEntitySession = null;

        }

        dirty.setDirty(false);

    }

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    @Override

    public void changed(Object element) {

        setDirty();

        matrix.getNatTable().refresh();

    }

    @Override

    public void forceDirty() {

        setDirty();

    }

    @Override

    public ICdmEntitySession getCdmEntitySession() {

        return cdmEntitySession;

    }

    @Override

    public Collection<DescriptiveDataSet> getRootEntities() {

        return Collections.singleton(this.descriptiveDataSet);

    }

    @Override

    public Map<Object, List<String>> getPropertyPathsMap() {

        Map<Object, List<String>> propertyMap = new HashMap<>();

        propertyMap.put(SpecimenOrObservationBase.class,WS_PROPERTY_PATH);

        return propertyMap;

    }

    private void loadingFailed() {

        label.setText(Messages.CharacterMatrixPart_LOADING_MATRIX_FAILED);

    }

    void loadingDone() {

        stackLayout.topControl = matrix;

        matrix.getParent().layout();

    }

}