EDIT

/**

* Copyright (C) 2018 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.view.checklist.e4;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

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.EModelService;

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

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

import org.eclipse.swt.custom.StackLayout;

import org.eclipse.swt.widgets.Composite;

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.taxon.Taxon;

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

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

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

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.IDistributionEditorPart;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.preference.NavigatorOrderEnum;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

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;

/**

 * @author k.luther

 * @since 28.11.2018

 */

public class DistributionEditorPart

        implements IE4SavablePart, IConversationEnabled, IDirtyMarkable,

		        ICdmEntitySessionEnabled<DescriptionBase>, IPartContentHasSupplementalData,

		        IPartContentHasDetails, IDistributionEditorPart {

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

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

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

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

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

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

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

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

            "taxon.descriptions.descriptionElements.media" //$NON-NLS-1$

    });

    private List<TaxonDistributionDTO> taxonList;

    private Collection<UpdateResult> updateResults;

    private Collection<Taxon> rootEntities;

    private ConversationHolder conversation;

    private ICdmEntitySession cdmEntitySession;

    @Inject

    private ESelectionService selService;

    @Inject

    private MDirtyable dirty;

    @Inject

    private MPart thisPart;

    private DistributionEditor editor;

    private StackLayout stackLayout;

    @Inject

    private EModelService modelService;

    @Inject

    private EPartService partService;

    @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);

        }

        else{

            return;

        }

        stackLayout = new StackLayout();

        parent.setLayout(stackLayout);

        editor = new DistributionEditor(parent, this);

        ContextInjectionFactory.inject(editor, context);

    }

    public void init(UuidAndTitleCache nodeDto) {

        List<UUID> uuidList = new ArrayList<>();

        uuidList.add(nodeDto.getUuid());

        this.taxonList = CdmStore.getService(ITaxonNodeService.class).getTaxonDistributionDTO(uuidList, TAXONNODE_PROPERTY_PATH, true);

       // taxonList.stream().filter(taxonDistribution ->  CdmStore.currentAuthentiationHasPermission(taxonDistribution.getTaxonUuid(), RequiredPermissions.TAXONNODE_EDIT));

        if(taxonList!=null){

            editor.loadDistributions(taxonList);

            editor.createTable();

            editor.pack();

            stackLayout.topControl = editor;

            editor.getParent().layout();

        }

    }

    public void init(List<UuidAndTitleCache> uuidAndTitleCaches) {

        List<UUID> nodeUuids = new ArrayList<>();

        uuidAndTitleCaches.forEach(element -> nodeUuids.add(element.getUuid()));

        TaxonNodeSortMode sortMode = TaxonNodeSortMode.RankAndAlphabeticalOrder;

        NavigatorOrderEnum orderValue = NavigatorOrderEnum.RankAndNameOrder;

        try{

            orderValue = PreferencesUtil.getSortNodes();

        }catch(IllegalArgumentException e){

        }

        if (orderValue.equals(NavigatorOrderEnum.NaturalOrder)){

            sortMode = TaxonNodeSortMode.NaturalOrder;

        } else if (orderValue.equals(NavigatorOrderEnum.AlphabeticalOrder)){

            sortMode = TaxonNodeSortMode.AlphabeticalOrder;

        }else {

            sortMode = TaxonNodeSortMode.RankAndAlphabeticalOrder;

        }

        this.taxonList = CdmStore.getService(ITaxonNodeService.class).getTaxonDistributionDTO(nodeUuids, TAXONNODE_PROPERTY_PATH,null, true, sortMode);

        // taxonList.stream().filter(taxonDistribution ->  CdmStore.currentAuthentiationHasPermission(taxonDistribution.getTaxonUuid(), RequiredPermissions.TAXONNODE_EDIT));

        if(taxonList!=null){

            editor.loadDistributions(taxonList);

            editor.createTable();

            editor.pack();

            stackLayout.topControl = editor;

            editor.getParent().layout();

        }

    }

    public ESelectionService getSelectionService() {

        return selService;

    }

    @Focus

    public void setFocus(){

        if(conversation!=null){

            conversation.bind();

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.bind();

        }

        EditorUtil.checkAndCloseFactsAndMediaParts(partService);

    }

    @Override

    public DistributionEditor getEditor() {

        return editor;

    }

    @Override

    public void update(CdmDataChangeMap changeEvents) {

        // TODO Auto-generated method stub

    }

    @PreDestroy

    public void dispose(){

        if (conversation != null) {

            conversation.close();

            conversation = null;

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.dispose();

            cdmEntitySession = null;

        }

        dirty.setDirty(false);

    }

    @Override

    public ICdmEntitySession getCdmEntitySession() {

        return cdmEntitySession;

    }

    @Override

    public List<DescriptionBase> getRootEntities() {

        List<DescriptionBase> rootEntities = new ArrayList<>();

        editor.taxonList.forEach(dto -> rootEntities.addAll(dto.getDescriptionsWrapper().getDescriptions()));

        return rootEntities;

    }

    @Override

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

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public void changed(Object element) {

        if (element != null){

            dirty.setDirty(true);

        }

    }

    @Override

    public void forceDirty() {

        // TODO Auto-generated method stub

    }

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    @Persist

    @Override

    public void save(IProgressMonitor monitor) {

        saveDistributions();

        dirty.setDirty(false);

    }

    protected void saveDistributions() {

        Set<TaxonDistributionDTO> coll = new HashSet<>();

        editor.getDescriptionsToSave().forEach(dto->coll.add(dto));

        Set<TaxonDistributionDTO> removeList = new HashSet<>();

        for (TaxonDistributionDTO dto: coll){

            Taxon taxon = null;

            for(TaxonDescription desc: dto.getDescriptionsWrapper().getDescriptions()){

                if (desc.getTaxon() == null){

                    if (taxon == null){

                        taxon = (Taxon)CdmStore.getService(ITaxonService.class).load(dto.getTaxonUuid());

                    }

                    taxon.addDescription(desc);

                }

                if (taxon != null){

                    MergeResult result = CdmStore.getService(ITaxonService.class).merge(taxon, true);

                }

            }

        }

        coll.removeAll(removeList);

        List<MergeResult<DescriptionBase>> result = CdmStore.getService(IDescriptionService.class).mergeDescriptionElements(coll, true);

        for (MergeResult<DescriptionBase> mergeRes: result ){

            cdmEntitySession.load(mergeRes, true);

            cdmEntitySession.load(editor.getDefaultSource(), true);

        }

        editor.createTaxonDistributionMap();

        conversation.commit();

        this.dirty.setDirty(false);

        editor.getDescriptionsToSave().clear();

    }

    @Override

    public boolean isDirty() {

        return this.dirty.isDirty();

    }

    public void setDirty() {

        this.dirty.setDirty(true);

    }

}