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.stream.Collectors;

import org.apache.commons.lang.StringUtils;

import org.eclipse.jface.dialogs.Dialog;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.ColumnLabelProvider;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.ITableLabelProvider;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerColumn;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerComparator;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.ScrolledComposite;

import org.eclipse.swt.events.FocusEvent;

import org.eclipse.swt.events.FocusListener;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.Text;

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

import eu.etaxonomy.cdm.common.CdmUtils;

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

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

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.ImageResources;

import eu.etaxonomy.taxeditor.preference.Resources;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.StoreUtil;

/**

 * Dialog to choose specimens for the character matrix.<br>

 * Filters specimens that have already been added.

 * @author pplitzner

 * @since Jan 3, 2018

 *

 */

public class SpecimenSelectionDialog extends Dialog {

    private static String TEXT_FILTER_DEFAULT = "Enter text filter";

    private TableViewer list;

    private Collection<SpecimenNodeWrapper> selectedSpecimens = new ArrayList<>();

    private CharacterMatrix matrix;

    private Text txtTextFilter;

    private List<String> treeIndex;

    public SpecimenSelectionDialog(Shell parentShell, CharacterMatrix matrix, List<String> treeIndex) {

        super(parentShell);

        this.matrix = matrix;

        this.treeIndex = treeIndex;

    }

    @Override

    protected Control createDialogArea(Composite parent) {

        Composite composite = (Composite) super.createDialogArea(parent);

        GridLayout gl_composite = new GridLayout();

        gl_composite.numColumns = 2;

        composite.setLayout(gl_composite);

        Composite composite_1 = new Composite(composite, SWT.NONE);

        composite_1.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false, 2, 1));

        composite_1.setLayout(new GridLayout(5, false));

        Label l_textFilter = new Label(composite_1, SWT.NULL);

        GridData data_label = new GridData(SWT.LEFT, SWT.CENTER, false, false, 1, 1);

        l_textFilter.setLayoutData(data_label);

        l_textFilter.setText("Specimen Filter");

        l_textFilter.setAlignment(SWT.RIGHT);

        txtTextFilter = new Text(composite_1, SWT.BORDER);

        txtTextFilter.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1));

        txtTextFilter.setText(TEXT_FILTER_DEFAULT);

        txtTextFilter.addFocusListener(new FocusListener() {

            @Override

            public void focusGained(FocusEvent e) {

                txtTextFilter.setForeground(AbstractUtility.getColor(Resources.SEARCH_VIEW_FOCUS));

                if (TEXT_FILTER_DEFAULT.equals(txtTextFilter.getText())) {

                    StoreUtil.setTextWithoutModifyListeners(txtTextFilter, "");

                }

            }

            @Override

            public void focusLost(FocusEvent e) {

                if (CdmUtils.isBlank(txtTextFilter.getText())){

                    txtTextFilter.setForeground(AbstractUtility.getColor(Resources.SEARCH_VIEW_FOREGROUND));

                    StoreUtil.setTextWithoutModifyListeners(txtTextFilter, TEXT_FILTER_DEFAULT);

                }

            }

        });

        txtTextFilter.addModifyListener(e->applyFilter());

        Button btnRefreshButton = new Button(composite_1, SWT.NONE);

        btnRefreshButton.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));

        btnRefreshButton.setToolTipText(Messages.SpecimenSelectionDialog_REFRESH);

        btnRefreshButton.setImage(ImageResources.getImage(ImageResources.REFRESH));

        btnRefreshButton.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                loadSpecimens();

                refreshInput(matrix.getSpecimenCache());

            }

        });

        Button btnRemoveTaxonFilterButton = new Button(composite_1, SWT.NONE);

        btnRemoveTaxonFilterButton.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));

        btnRemoveTaxonFilterButton.setToolTipText(Messages.SpecimenSelectionDialog_REMOVE_FILTER);

        btnRemoveTaxonFilterButton.setImage(ImageResources.getImage(ImageResources.TRASH_ICON));

        btnRemoveTaxonFilterButton.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                txtTextFilter.setText("");

                refreshInput(matrix.getSpecimenCache());

            }

        });

        Label lblNewLabel = new Label(composite, SWT.NONE);

        lblNewLabel.setImage(ImageResources.getImage(ImageResources.WARNING_ICON));

        Label lblNewLabel_1 = new Label(composite, SWT.NONE);

        lblNewLabel_1.setText(": Specimen not associated with taxon");

        ScrolledComposite scrolledComposite = new ScrolledComposite(composite, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);

        scrolledComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));

        scrolledComposite.setExpandHorizontal(true);

        scrolledComposite.setExpandVertical(true);

        //table

        list = new TableViewer(scrolledComposite, SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);

        Table table = list.getTable();

        //table columns

        TableViewerColumn columnTaxon = new TableViewerColumn(list, SWT.NONE);

        columnTaxon.getColumn().setText("Taxon");

        columnTaxon.getColumn().setWidth(200);

        columnTaxon.getColumn().setResizable(true);

        columnTaxon.getColumn().setMoveable(true);

        TableViewerColumn columnType = new TableViewerColumn(list, SWT.NONE);

        columnType.getColumn().setText("Type");

        columnType.getColumn().setWidth(150);

        columnType.getColumn().setResizable(true);

        columnType.getColumn().setMoveable(true);

        TableViewerColumn columnSpecimen = new TableViewerColumn(list, SWT.NONE);

        columnSpecimen.getColumn().setText("Specimen");

        columnSpecimen.getColumn().setResizable(true);

        columnSpecimen.getColumn().setMoveable(true);

        columnSpecimen.getColumn().setWidth(400);

        table.setHeaderVisible(true);

        table.setLinesVisible(true);

        scrolledComposite.setContent(table);

        scrolledComposite.setMinSize(table.computeSize(SWT.DEFAULT, SWT.DEFAULT));

        list.setContentProvider(new ArrayContentProvider());

        list.setLabelProvider(new SpecimenListLabelProvider());

        ViewerComparator comp = new ViewerComparator() {

            @Override

            public int compare(Viewer viewer, Object o1, Object o2) {

                if(o1 == null){

                     if(o2 == null){

                         return 0;

                     }

                     return -1;

                 }

                 if(o2==null){

                     return 1;

                 }

                 try{

                    return ((SpecimenNodeWrapper)o1).getTaxonNode().getTitleCache().compareTo(((SpecimenNodeWrapper)o2).getTaxonNode().getTitleCache());

                 }

                 catch(NullPointerException e){

                     return 0;

                 }

             }

        };

        list.setComparator(comp);

        //gather specimens

        if(matrix.getSpecimenCache()==null){

            loadSpecimens();

        }

        if(treeIndex !=null){

            filterByTaxonNode(treeIndex, null);

        }else{

            refreshInput(matrix.getSpecimenCache());

        }

        columnSpecimen.getColumn().pack();

        return composite;

    }

    private void refreshInput(Object input){

        list.setInput(input);

    }

    private void applyFilter(){

        List<SpecimenNodeWrapper> result = new ArrayList<>();

        Collection<SpecimenNodeWrapper> specimenCache = matrix.getSpecimenCache();

        String text = txtTextFilter.getText();

        //filter for treeIndex is missing

        if(CdmUtils.isBlank(text)){

            result = new ArrayList<>(specimenCache);

        }

        else{

            if(!txtTextFilter.getForeground().equals(AbstractUtility.getColor(Resources.SEARCH_VIEW_FOREGROUND))

                    &&!CdmUtils.isBlank(text)){

                result.addAll(specimenCache.stream()

                        .filter(wrapper->wrapper.getUuidAndTitleCache().getTitleCache().toLowerCase().contains(text.toLowerCase()))

                        .collect(Collectors.toList()));

                result.addAll(specimenCache.stream()

                        .filter(wrapper->wrapper.getTaxonNode().getTitleCache().toLowerCase().contains(text.toLowerCase()))

                        .collect(Collectors.toList()));

            }

        }

        filterByTaxonNode(treeIndex, result);

    }

    private void loadSpecimens(){

        ArrayList<SpecimenNodeWrapper> specimenList = new ArrayList<>(CdmStore.getService(IDescriptiveDataSetService.class).loadSpecimens(matrix.getDescriptiveDataSet().getUuid()));

//        Collections.sort(specimenList, new Comparator<SpecimenNodeWrapper>() {

//

//            @Override

//            public int compare(SpecimenNodeWrapper o1, SpecimenNodeWrapper o2) {

//                if(o1 == null){

//                    if(o2 == null){

//                        return 0;

//                    }

//                    return -1;

//                }

//                if(o2==null){

//                    return 1;

//                }

//                try{

//                    return o1.getTaxonNode().getTitleCache().compareTo(o2.getTaxonNode().getTitleCache());

//                }

//                catch(NullPointerException e){

//                    return 0;

//                }

//            }

//        });

        matrix.setSpecimenCache(specimenList);

    }

    @Override

    protected void configureShell(Shell newShell) {

        super.configureShell(newShell);

        newShell.setText(Messages.SpecimenSelectionDialog_SELECT_SPECIMENS);

        newShell.setMinimumSize(500, 600);

        newShell.setSize(800, 600);

    }

    @Override

    protected void okPressed() {

        selectedSpecimens.clear();

        selectedSpecimens = ((IStructuredSelection)list.getSelection()).toList();

        super.okPressed();

    }

    @Override

    protected boolean isResizable() {

        return true;

    }

    public Collection<SpecimenNodeWrapper> getSpecimen(){

        return selectedSpecimens;

    }

    private class SpecimenListLabelProvider extends ColumnLabelProvider implements ITableLabelProvider {

        @Override

        public String getToolTipText(Object element) {

            if(element instanceof SpecimenNodeWrapper

                    && ((SpecimenNodeWrapper) element).getTaxonDescriptionUuid()==null){

                return "Does not have and IndividualsAssociation with the taxon";

            }

            return null;

        }

        @Override

        public Image getColumnImage(Object element, int columnIndex) {

            if(element instanceof SpecimenNodeWrapper && columnIndex == 2

                    && ((SpecimenNodeWrapper) element).getTaxonDescriptionUuid()==null){

                return ImageResources.getImage(ImageResources.WARNING_ICON);

            }

            return null;

        }

        @Override

        public String getColumnText(Object element, int columnIndex) {

            if(element instanceof SpecimenNodeWrapper){

                SpecimenNodeWrapper wrapper = (SpecimenNodeWrapper)element;

                switch (columnIndex) {

                case 0:

                    return wrapper.getTaxonNode().getTitleCache();

                case 1:

                    return wrapper.getType().getMessage();

                case 2:

                    return wrapper.getUuidAndTitleCache().getTitleCache();

                default:

                    break;

                }

            }

            return "";

        }

    }

    private void filterByTaxonNode(List<String> treeIndexList, Collection<SpecimenNodeWrapper> specimenCache){

        Collection<SpecimenNodeWrapper> result = new ArrayList<>();

        if (specimenCache == null){

            specimenCache = matrix.getSpecimenCache();

        }

        for (String treeIndex: treeIndexList){

            if (StringUtils.isNotBlank(treeIndex)){

                result.addAll(specimenCache.stream()

                            .filter(wrapper->wrapper.getTaxonNode().getTreeIndex().startsWith(treeIndex))

                            .collect(Collectors.toList()));

            }

        }

        refreshInput(result);

    }

}