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

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import java.util.stream.Collectors;

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.jface.window.Window;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.layout.RowLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.model.DescriptionHelper;

import eu.etaxonomy.taxeditor.model.ImageResources;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.ui.dialog.selection.TaxonSelectionDialog;

/**

 * @author pplitzner

 * @since Jul 9, 2018

 *

 */

public class CharacterMatrixBottomToolbar extends Composite{

    private CharacterMatrix matrix;

    public CharacterMatrixBottomToolbar(CharacterMatrix matrix, int style) {

        super(matrix, style);

        this.matrix = matrix;

        init();

    }

    private void init() {

        setLayout(new RowLayout());

        GridDataFactory.fillDefaults().grab(true, false).applyTo(this);

        /**

         * Add description button

         */

        Button btnAddDescription = new Button(this, SWT.PUSH);

        btnAddDescription.setImage(ImageResources.getImage(ImageResources.ADD_ICON_GREEN));

        btnAddDescription.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                SpecimenSelectionDialog dialog = new SpecimenSelectionDialog(matrix.getShell(), matrix);

                if(dialog.open()==Window.OK){

                    Collection<SpecimenNodeWrapper> wrappers = dialog.getSpecimen();

                    for (SpecimenNodeWrapper wrapper : wrappers) {

                        SpecimenOrObservationBase specimen = CdmStore.getService(IOccurrenceService.class).load(wrapper.getUuidAndTitleCache().getUuid());

                        SpecimenDescription description = getDescriptionForDescriptiveDataSet(specimen);

                        //description elements

                        Map<Feature, DescriptionElementBase> featureToElementMap = new HashMap<>();

                        Set<DescriptionElementBase> elements = description.getElements();

                        for (DescriptionElementBase descriptionElementBase : elements) {

                            Feature feature = descriptionElementBase.getFeature();

                            featureToElementMap.put(feature, descriptionElementBase);

                        }

                        RowWrapperDTO rowWrapper = CdmStore.getService(IDescriptiveDataSetService.class).createRowWrapper(description, matrix.getDescriptiveDataSet());

                        matrix.getDescriptions().add(rowWrapper);

                        matrix.getDescriptiveDataSet().addDescription(description);

                        matrix.setDirty();

                        matrix.getSpecimenCache().remove(wrapper);

                    }

                }

            }

        });

        /**

         * Remove description button

         */

        Button btnRemoveDescription = new Button(this, SWT.PUSH);

        btnRemoveDescription.setImage(ImageResources.getImage(ImageResources.ACTIVE_DELETE_ICON));

        btnRemoveDescription.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                int[] fullySelectedRowPositions = matrix.getBodyLayer().getSelectionLayer().getFullySelectedRowPositions();

                List<RowWrapperDTO> toRemove = new ArrayList<>();

                for (int i : fullySelectedRowPositions) {

                    Object rowObject = matrix.getBodyDataProvider().getRowObject(i);

                    if(rowObject instanceof RowWrapperDTO){

                        toRemove.add((RowWrapperDTO) rowObject);

                    }

                }

                toRemove.forEach(rowToRemove->{

                    matrix.getDescriptions().remove(rowToRemove);

                    matrix.getDescriptiveDataSet().removeDescription(rowToRemove.getSpecimenDescription());

                    matrix.setDirty();

                });

            }

        });

        /**

         * Aggregate button

         */

        Button btnAggregate = new Button(this, SWT.PUSH);

        btnAggregate.setText("Aggregate");

        btnAggregate.addSelectionListener(new SelectionAdapter() {

            @SuppressWarnings("unchecked")

            @Override

            public void widgetSelected(SelectionEvent e) {

                Set<TaxonNode> taxonSubtreeFilter = matrix.getDescriptiveDataSet().getTaxonSubtreeFilter();

                List<TaxonNodeDto> nodeDtos = taxonSubtreeFilter.stream()

                        .map(node -> new TaxonNodeDto(node)).collect(Collectors.toList());

                TaxonNodeDto parentDto = CdmStore.getService(ITaxonNodeService.class).findCommonParentDto(nodeDtos);

                UUID taxonUuid = parentDto.getTaxonUuid();

                int response = MessagingUtils.confirmDialog(

                        "Choose location for the aggregated description",

                        String.format("The aggregated description will be stored at "

                                + "the common parent taxon of this data set:\n%s\n\n"

                                + "Do you want to use this taxon?"

                                , parentDto.getTaxonTitleCache()), "Yes", "Choose taxon", "Cancel");

                if(response==2){

                    return;

                }

                else if(response==1){

                    Taxon taxon = TaxonSelectionDialog.selectTaxon(getShell(), null);

                    if(taxon==null){

                        return;

                    }

                    taxonUuid = taxon.getUuid();

                }

                UpdateResult result = CdmStore.getService(IDescriptionService.class).aggregateDescription(taxonUuid, null, matrix.getDescriptiveDataSet().getUuid());

                matrix.addUpdateResult(result);

                matrix.setDirty();

                //aggregate histogram for categorical tooltip

                Map<Feature, CategoricalDataHistogram> featureToHistogramMap = matrix.getFeatureToHistogramMap();

                featureToHistogramMap.clear();

                // matrix.getFeatures().forEach(feature->{

                matrix.getDescriptions()

                        .forEach(o -> ((RowWrapperDTO) o).getSpecimenDescription().getElements().stream()

                                .filter(descriptionElement -> descriptionElement instanceof CategoricalData)

                                .forEach(categoricalData -> {

                                    Feature feature = ((CategoricalData) categoricalData).getFeature();

                                    CategoricalDataHistogram dataHistogram = featureToHistogramMap.get(feature);

                                    if(dataHistogram==null){

                                        dataHistogram = new CategoricalDataHistogram(feature);

                                    }

                                    featureToHistogramMap.put(feature, dataHistogram);

                                    ((CategoricalData) categoricalData).getStateData()

                                            .forEach(stateData -> featureToHistogramMap.get(feature).addState(stateData.getState()));

                                }));

            }

        });

    }

    private SpecimenDescription getDescriptionForDescriptiveDataSet(SpecimenOrObservationBase specimen){

        Set<Feature> wsFeatures = matrix.getDescriptiveDataSet().getDescriptiveSystem().getDistinctFeatures();

        List<DescriptionElementBase> matchingDescriptionElements = new ArrayList<>();

        for (SpecimenDescription specimenDescription : (Set<SpecimenDescription>) specimen.getDescriptions()) {

            specimenDescription = (SpecimenDescription) CdmStore.getService(IDescriptionService.class).load(specimenDescription.getUuid());

            Set<Feature> specimenDescriptionFeatures = new HashSet<>();

            //gather specimen description features and check for match with WS features

            for (DescriptionElementBase specimenDescriptionElement : specimenDescription.getElements()) {

                Feature feature = specimenDescriptionElement.getFeature();

                specimenDescriptionFeatures.add(feature);

                if(wsFeatures.contains(feature)){

                    matchingDescriptionElements.add(specimenDescriptionElement);

                }

            }

            //if description with the exact same features is found return the description

            if(specimenDescriptionFeatures.equals(wsFeatures)){

                return specimenDescription;

            }

        }

        //Create new specimen description if no match was found

        matrix.setDirty();

        SpecimenDescription newDesription = SpecimenDescription.NewInstance(specimen);

        newDesription.setTitleCache(Messages.CharacterMatrix_DESCRIPTIVE_DATA_SET+matrix.getDescriptiveDataSet().getLabel()+": "+newDesription.generateTitle(), true); //$NON-NLS-2$

        //check for equals description element (same feature and same values)

        Map<Feature, List<DescriptionElementBase>> featureToElementMap = new HashMap<>();

        for(DescriptionElementBase element:matchingDescriptionElements){

            List<DescriptionElementBase> list = featureToElementMap.get(element.getFeature());

            if(list==null){

                list = new ArrayList<>();

            }

            list.add(element);

            featureToElementMap.put(element.getFeature(), list);

        }

        Set<DescriptionElementBase> descriptionElementsToClone = new HashSet<>();

        for(Feature feature:featureToElementMap.keySet()){

            List<DescriptionElementBase> elements = featureToElementMap.get(feature);

            //no duplicate description elements found for this feature

            if(elements.size()==1){

                descriptionElementsToClone.add(elements.get(0));

            }

            //duplicates found -> check if all are equal

            else{

                DescriptionElementBase match = null;

                for (DescriptionElementBase descriptionElementBase : elements) {

                    if(match==null){

                        match = descriptionElementBase;

                    }

                    else if(!new DescriptionElementCompareWrapper(match).equals(new DescriptionElementCompareWrapper(descriptionElementBase))){

                        match = null;

                        MessagingUtils.informationDialog(Messages.CharacterMatrix_MULTIPLE_DATA,

                                String.format(Messages.CharacterMatrix_MULTIPLE_DATA_MESSAGE, feature.getLabel()));

                        break;

                    }

                }

                if(match!=null){

                    descriptionElementsToClone.add(match);

                }

            }

        }

        //clone matching descriptionElements

        for (DescriptionElementBase descriptionElementBase : descriptionElementsToClone) {

            DescriptionElementBase clone;

            try {

                clone = descriptionElementBase.clone(newDesription);

                clone.getSources().forEach(source -> source.setOriginalNameString(DescriptionHelper.getLabel(descriptionElementBase)));

            } catch (CloneNotSupportedException e) {

                MessagingUtils.error(CharacterMatrix.class, e);

            }

        }

        //add all remaining description elements to the new description

        for(Feature wsFeature:wsFeatures){

            boolean featureFound = false;

            for(DescriptionElementBase element:newDesription.getElements()){

                if(element.getFeature().equals(wsFeature)){

                    featureFound = true;

                    break;

                }

            }

            if(!featureFound){

                if(wsFeature.isSupportsCategoricalData()){

                    newDesription.addElement(CategoricalData.NewInstance(wsFeature));

                }

                else if(wsFeature.isSupportsQuantitativeData()){

                    newDesription.addElement(QuantitativeData.NewInstance(wsFeature));

                }

            }

        }

        return newDesription;

    }

}