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.view.webimport.termimport;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.stream.Collectors;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.e4.ui.di.UISynchronize;

import org.eclipse.jface.util.LocalSelectionTransfer;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.window.Window;

import org.eclipse.swt.SWT;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.DragSourceAdapter;

import org.eclipse.swt.dnd.DragSourceEvent;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.events.FocusEvent;

import org.eclipse.swt.events.FocusListener;

import org.eclipse.swt.events.KeyAdapter;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.taxeditor.l10n.Messages;

import eu.etaxonomy.taxeditor.model.ColorResources;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.preference.Resources;

import eu.etaxonomy.taxeditor.view.webimport.termimport.parser.TermParser;

import eu.etaxonomy.taxeditor.view.webimport.termimport.parser.TerminologyParser;

import eu.etaxonomy.taxeditor.view.webimport.termimport.requests.RequestSearch;

import eu.etaxonomy.taxeditor.view.webimport.termimport.requests.RequestTerminologies;

import eu.etaxonomy.taxeditor.view.webimport.termimport.wrapper.OntologyTermWrapper;

import eu.etaxonomy.taxeditor.view.webimport.termimport.wrapper.TerminologyWrapper;

/**

 * @author pplitzner

 * @since Apr 23, 2018

 *

 */

public class GfBioTerminologyImportPresenter {

    public static final String NO_CONNECTION_TITLE = Messages.GfBioTerminologyImportPresenter_NO_CONNECTION_TITLE;

    public static final String NO_CONNECTION_MESSAGE = Messages.GfBioTerminologyImportPresenter_NO_CONNECTION_MESSAGE;

    private static final String TXT_SEARCH_DEFAULT = Messages.GfBioTerminologyImportPresenter_TEXT_SEARCH_DEFAULT;

    private GfBioTerminologyImportComposite composite;

    private Collection<TerminologyWrapper> selectedOntologies = new ArrayList<>();

    private UISynchronize sync;

    private volatile Collection<TerminologyWrapper> availableOntologies = new HashSet<>();

    public GfBioTerminologyImportPresenter(GfBioTerminologyImportComposite composite, UISynchronize sync) {

        super();

        this.composite = composite;

        this.sync = sync;

        requestAvailableOntologies();

        composite.getBtnSearch().addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

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

                    search();

                }

            }

        });

        //text search

        composite.getTxtSearch().addKeyListener(new KeyAdapter() {

            @Override

            public void keyPressed(KeyEvent e) {

                if(e.keyCode==SWT.CR){

                    search();

                }

            }

        });

        composite.getTxtSearch().setText(TXT_SEARCH_DEFAULT);

        composite.getTxtSearch().setForeground(ColorResources.getColor(Resources.SEARCH_VIEW_FOREGROUND));

        composite.getTxtSearch().addFocusListener(new FocusListener() {

            @Override

            public void focusGained(FocusEvent e) {

                composite.getTxtSearch().setForeground(ColorResources.getColor(Resources.SEARCH_VIEW_FOCUS));

                if (TXT_SEARCH_DEFAULT.equals(composite.getTxtSearch().getText())) {

                    composite.getTxtSearch().setText(""); //$NON-NLS-1$

                }

            }

            @Override

            public void focusLost(FocusEvent e) {

                if (CdmUtils.isBlank(composite.getTxtSearch().getText())) {

                    composite.getTxtSearch().setForeground(ColorResources.getColor(Resources.SEARCH_VIEW_FOREGROUND));

                    composite.getTxtSearch().setText(TXT_SEARCH_DEFAULT);

                }

            }

        });

        composite.getBtnChooseOntology().addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                if(availableOntologies.isEmpty()

                        && MessagingUtils.confirmDialog("No Ontologies available", "There are no ontologies available. They have either not been loaded yet or the terminology service can not be reached.\nDo you want to retry loading the ontologies?")){

                    //re-check if ontologies have been loaded in the meantime

                    if(availableOntologies.isEmpty()){

                        requestAvailableOntologies();

                    }

                    else{

                        openOntologySelectionDialog(composite);

                    }

                }

                else{

                    openOntologySelectionDialog(composite);

                }

            }

            private void openOntologySelectionDialog(GfBioTerminologyImportComposite composite) {

                OntologySelectionDialog dialog = new OntologySelectionDialog(composite.getShell(), selectedOntologies, availableOntologies);

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

                    selectedOntologies = dialog.getSelectedOntologies();

                    composite.getTextOntologies().setText(selectedOntologies.stream()

                            .map(wrapper->wrapper.getAcronym())

                            .collect(Collectors.joining(", ")));

                }

            }

        });

        //vocabulary combo

        composite.getBtnRemoveVocabulary().addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                composite.getTermVocabularyComboViewer().setElement(null);

            }

        });

        composite.getTreeTermHierarchy().setContentProvider(new OntologyTermContentProvider());

        composite.getTreeTermHierarchy().setLabelProvider(new OntologyTermLabelProvider());

        //tree results

        composite.getTreeTermHierarchy().addSelectionChangedListener(e->updateDetails(e.getSelection()));

        composite.getTreeTermHierarchy().setContentProvider(new OntologyTermContentProvider());

        composite.getTreeTermHierarchy().setLabelProvider(new OntologyTermLabelProvider());

        Transfer[] transfers = new Transfer[] {LocalSelectionTransfer.getTransfer(),};

        composite.getTreeTermHierarchy().addDragSupport(DND.DROP_MOVE,

                transfers, new DragSourceAdapter() {

            @Override

            public void dragSetData(DragSourceEvent event) {

                if (LocalSelectionTransfer.getTransfer().isSupportedType(event.dataType)) {

                    IStructuredSelection selection = (IStructuredSelection) composite.getTreeTermHierarchy().getSelection();

                    selection.toList().stream()

                    .filter(item->item instanceof OntologyTermWrapper)

                    .forEach(wrapper->((OntologyTermWrapper)wrapper).setTermVocabulary(composite.getTermVocabularyComboViewer().getSelection()));

                    LocalSelectionTransfer.getTransfer().setSelection(selection);

                }

            }

            @Override

            public void dragStart(DragSourceEvent event) {

                event.doit = !composite.getTreeTermHierarchy().getSelection().isEmpty();

            }

        });

    }

    private void requestAvailableOntologies() {

        Job requestOntologiesJob = new Job("Request available ontologies") {

            @Override

            protected IStatus run(IProgressMonitor monitor) {

                String response = new RequestTerminologies().request();

                availableOntologies = TerminologyParser.parse(response);

                return Status.OK_STATUS;

            }

        };

        requestOntologiesJob.schedule();

    }

    private OntologyTermWrapper getSelectedTerm(IStructuredSelection selection){

        Iterator iterator = selection.iterator();

        if(iterator.hasNext()){

            Object next = iterator.next();

            if(next instanceof OntologyTermWrapper){

                return (OntologyTermWrapper) next;

            }

        }

        return null;

    }

    private void clearDetails(){

        composite.getLblLabel().setText(""); //$NON-NLS-1$

        composite.getLblUri().setText(""); //$NON-NLS-1$

        composite.getLblDescription().setText(""); //$NON-NLS-1$

        composite.getListSynonyms().getList().removeAll();

    }

    private void updateDetails(ISelection s) {

        StructuredSelection selection = (StructuredSelection)s;

        if(selection.isEmpty()){

            clearDetails();

        }

        OntologyTermWrapper wrapper = getSelectedTerm(selection);

        if(wrapper!=null){

            String label = wrapper.getLabel();

            String uri = wrapper.getUri();

            String description = wrapper.getDescription();

            composite.getLblLabel().setText(label!=null?label:""); //$NON-NLS-1$

            composite.getLblUri().setText(uri!=null?uri:""); //$NON-NLS-1$

            composite.getLblDescription().setText(description!=null?description:""); //$NON-NLS-1$

            composite.getListSynonyms().getList().removeAll();

            if(wrapper.getSynonyms()!=null){

                wrapper.getSynonyms().forEach(syn->composite.getListSynonyms().add(syn));

            }

        }

    }

    private void search(){

        //clear result count

        composite.getLblResultCount().setText("Searching...");

        String searchString = composite.getTxtSearch().getText();

        if(searchString.equals(TXT_SEARCH_DEFAULT)){

            return;

        }

        if(selectedOntologies.isEmpty() && !MessagingUtils.confirmDialog("Long running operation", "You have not selected any specific ontology. This search may take a long time.\n\nDo you want to continue?")){

            return;

        }

        Job searchJob = new Job("Search Ontologies") {

            @Override

            protected IStatus run(IProgressMonitor monitor) {

                String response = new RequestSearch(searchString, selectedOntologies).request();

                if(response==null){

                    MessagingUtils.informationDialog(NO_CONNECTION_TITLE, NO_CONNECTION_MESSAGE);

                    return Status.CANCEL_STATUS;

                }

                final List<OntologyTermWrapper> wrapperList = new ArrayList<>();

                wrapperList.addAll(TermParser.parse(response));

                if(wrapperList.isEmpty()){

                    MessagingUtils.informationDialog(Messages.GfBioTerminologyImportPresenter_NO_RESULTS_TITLE, Messages.GfBioTerminologyImportPresenter_NO_RESULTS_MESSAGE);

                }

                //sort list

                Collections.sort(wrapperList, new TermWrapperComparator(searchString));

                sync.syncExec(() -> {

                    composite.getTreeTermHierarchy().setInput(wrapperList);

                    composite.getLblResultCount().setText(Integer.toString(wrapperList.size()));

                });

                return Status.OK_STATUS;

            }

        };

       searchJob.schedule();

    }

    private final class TermWrapperComparator implements Comparator<OntologyTermWrapper> {

        private final String searchString;

        public TermWrapperComparator(String searchString) {

            super();

            this.searchString = searchString;

        }

        @Override

        public int compare(OntologyTermWrapper o1, OntologyTermWrapper o2) {

            //remove wildcards from search string

            String trimmedSearch = searchString.replace("*", "");

            String label1 = o1.getLabel();

            String label2 = o2.getLabel();

            //1. search string at the beginning

            if(label1.startsWith(trimmedSearch)){

                if(!label2.startsWith(trimmedSearch)){

                    return -1;

                }

                else{

                    return label1.compareTo(label2);

                }

            }

            else if(label2.startsWith(trimmedSearch)){

                return 1;

            }

            //2. label that contains search string

            if(label1.contains(trimmedSearch)){

                if(!label2.contains(trimmedSearch)){

                    return -1;

                }

            }

            else if(label2.contains(trimmedSearch)){

                return 1;

            }

            return label1.compareTo(label2);

        }

    }

}