EDIT

/**

* Copyright (C) 2019 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.view.search.facet;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.TreeMap;

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.KeyListener;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Group;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

/**

 * @author pplitzner

 * @since Jan 22, 2019

 *

 */

public abstract class SearchController<S extends SearchResult<T>, T> implements KeyListener, SelectionListener{

    private SearchComposite composite;

    private List<S> searchResults = new ArrayList<>();

    private Set<Facet> appliedFacets = new HashSet<>();

    private List<CheckBoxSearchResultComposite<T, S>> searchResultComposites = new ArrayList<>();

    public SearchController(SearchComposite composite) {

        this.composite = composite;

        composite.getTxtSearch().addKeyListener(this);

        composite.getBtnSearchButton().addSelectionListener(this);

    }

    protected abstract List<S> searchResults(String searchString);

    protected abstract CheckBoxSearchResultComposite<T, S> createResultComposite(S result, Composite parent);

    protected abstract Comparator<S> getResultComparator(String searchString);

    protected abstract List<S> getSelectedResults();

    private void search(String searchString){

        searchResults.clear();

        searchResultComposites.clear();

        searchResults = searchResults(searchString);

        if(searchResults.size()>500){

            MessagingUtils.warningDialog("Specify your search", this, "The following search has too many results. Please enter a more specific search query.");

            return;

        }

        Collections.sort(searchResults, getResultComparator(searchString));

        Set<Facet> facets = createResults(searchResults);

        createFilterButtons(facets);

        composite.refresh();

    }

    private void createFilterButtons(Set<Facet> facets) {

        Map<String, List<Facet>> categoryToFacetsMap = new TreeMap<>();//(String o1, String o2)->o1.compareTo(o2));

        for (Facet facet : facets) {

            String category = facet.getCategory();

            if(category==null){

                category = "None";

            }

            List<Facet> categoryFacets = categoryToFacetsMap.get(category);

            if(categoryFacets==null){

                categoryFacets = new ArrayList<>();

            }

            categoryFacets.add(facet);

            categoryToFacetsMap.put(category, categoryFacets);

        }

        for (Entry<String, List<Facet>> entry: categoryToFacetsMap.entrySet()) {

            String category = entry.getKey();

            // create group

            Group group = new Group(composite.getFilterListComposite(), SWT.NONE);

            group.setLayout(new GridLayout());

            GridDataFactory.fillDefaults().applyTo(group);

            group.setText(category!=null?category:"None");

            // fill group with facet filters

            List<Facet> categoryFacets = entry.getValue();

            for (Facet facet : categoryFacets) {

                if(facet.getFacet()!=null){

                    FilterComposite filterComposite = new FilterComposite(facet, this, group, SWT.NONE);

                    appliedFacets.add(facet);

                }

            }

        }

    }

    private Set<Facet> createResults(List<S> results) {

        Set<Facet> facets = new HashSet<>();

        searchResultComposites.clear();

        for (S result : results) {

            searchResultComposites.add(createResultComposite(result, composite.getSearchResultComposite()));

            facets.addAll(result.getFacets());

        }

        return facets;

    }

    public void applyFilter(FilterComposite filterComposite) {

        composite.clearResults();

        Facet facet = filterComposite.getFacet();

        if(filterComposite.isFilterActive()){

            appliedFacets.add(facet);

        }

        else{

            appliedFacets.remove(facet);

        }

        searchResultComposites.clear();

        for (S searchResult : searchResults) {

            if(searchResult.hasAnyFacet(appliedFacets)){

                searchResultComposites.add(createResultComposite(searchResult, composite.getSearchResultComposite()));

            }

        }

        composite.refresh();

    }

    private void search(){

        composite.clear();

        search(composite.getTxtSearch().getText());

    }

    public List<S> getSelectedSearchResults(){

        List<S> selectedSearchResults = new ArrayList<>();

        searchResultComposites.stream()

        .filter(resultComposite->resultComposite.getBtnCheck().getSelection())

        .forEach(selected->selectedSearchResults.add(selected.getResult()));

        return selectedSearchResults;

    }

    @Override

    public void keyPressed(KeyEvent e) {

        if(e.keyCode==SWT.CR && e.widget==composite.getTxtSearch()){

            search();

        }

    }

    @Override

    public void keyReleased(KeyEvent e) {

    }

    @Override

    public void widgetSelected(SelectionEvent e) {

        if(e.widget==composite.getBtnSearchButton()){

            search();

        }

    }

    @Override

    public void widgetDefaultSelected(SelectionEvent e) {

    }

}