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

import java.util.Map;

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

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.api.service.dto.SpecimenRowWrapperDTO;

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

import eu.etaxonomy.cdm.common.CdmUtils;

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

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.description.TaxonDescription;

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.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) {

                String error = "";

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

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

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

                    for (SpecimenNodeWrapper wrapper : wrappers) {

                        SpecimenDescription specimenDescription = CdmStore.getService(IDescriptiveDataSetService.class)

                                .findSpecimenDescription(matrix.getDescriptiveDataSet().getUuid(),

                                        wrapper.getUuidAndTitleCache().getUuid(), true);

                        SpecimenRowWrapperDTO rowWrapper = CdmStore.getService(IDescriptiveDataSetService.class)

                                .createSpecimenRowWrapper(specimenDescription, matrix.getDescriptiveDataSet());

                        if(rowWrapper==null){

                            error += specimenDescription;

                            continue;

                        }

                        //add specimen description

                        matrix.getDescriptions().add(rowWrapper);

                        matrix.getDescriptiveDataSet().addDescription(specimenDescription);

                        matrix.getCdmEntitiySession().load(specimenDescription, true);

                        matrix.setDirty();

                        matrix.getSpecimenCache().remove(wrapper);

                    }

                    if(CdmUtils.isNotBlank(error)){

                        MessagingUtils.warningDialog("Errors during row creation", this,

                                String.format("Could not create rows for the following description:\n\n%s", error));

                    }

                }

            }

        });

        /**

         * 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.getDescription());

                    matrix.setDirty();

                });

            }

        });

        /**

         * Aggregate button

         */

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

        btnAggregate.setText("Aggregate");

        btnAggregate.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                List<TaxonNode> taxonSubtreeFilter = CdmStore.getService(IDescriptiveDataSetService.class).loadFilteredTaxonNodes(matrix.getDescriptiveDataSet(), null);

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

                }

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

                matrix.getDescriptiveDataSet().getDescriptions().forEach(desc->descriptionUuids.add(desc.getUuid()));

                UpdateResult result = CdmStore.getService(IDescriptiveDataSetService.class).aggregateDescription(taxonUuid, descriptionUuids, matrix.getDescriptiveDataSet().getLabel(), matrix.getDescriptiveDataSet().getUuid());

                TaxonDescription taxonDescription = (TaxonDescription) result.getCdmEntity();

                TaxonRowWrapperDTO taxonRowWrapper = CdmStore.getService(IDescriptiveDataSetService.class).createTaxonRowWrapper(taxonDescription.getUuid(), matrix.getDescriptiveDataSet().getUuid());

                matrix.getDescriptions().add(taxonRowWrapper);

                aggregateCategorcialHistogram(matrix.getFeatureToHistogramMap());

                aggregateQuantitativeSummary(matrix.getFeatureToQuantDataStatisticsMap());

            }

        });

    }

    @SuppressWarnings("unchecked")

    private void aggregateCategorcialHistogram(Map<Feature, CategoricalDataHistogram> featureToHistogramMap) {

        featureToHistogramMap.clear();

        matrix.getDescriptions().stream()

        .filter(desc->desc instanceof SpecimenRowWrapperDTO)

                .forEach(o -> ((SpecimenRowWrapperDTO) o).getDescription().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()));

                        }));

    }

    @SuppressWarnings("unchecked")

    private void aggregateQuantitativeSummary(Map<Feature, QuantitativeDataStatistics> featureToQuantDataStatisticsMap) {

        featureToQuantDataStatisticsMap.clear();

        matrix.getDescriptions().stream()

        .filter(desc->desc instanceof SpecimenRowWrapperDTO)

        .forEach(o -> ((SpecimenRowWrapperDTO) o).getDescription().getElements().stream()

                .filter(descriptionElement -> descriptionElement instanceof QuantitativeData)

                .forEach(quantData -> {

                    Feature feature = ((QuantitativeData) quantData).getFeature();

                    QuantitativeDataStatistics dataStatistics = featureToQuantDataStatisticsMap.get(feature);

                    if(dataStatistics==null){

                        dataStatistics = new QuantitativeDataStatistics();

                    }

                    featureToQuantDataStatisticsMap.put(feature, dataStatistics);

                    dataStatistics.addQuantitativeData((QuantitativeData) quantData);

                }));

    }

}