EDIT

// $Id$

/**

* Copyright (C) 2017 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.ui.dialog.selection;

import java.text.Collator;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.ListenerList;

import org.eclipse.core.runtime.Status;

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

import org.eclipse.jface.action.LegacyActionTools;

import org.eclipse.jface.dialogs.Dialog;

import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider.IStyledLabelProvider;

import org.eclipse.jface.viewers.DoubleClickEvent;

import org.eclipse.jface.viewers.IColorProvider;

import org.eclipse.jface.viewers.IDoubleClickListener;

import org.eclipse.jface.viewers.IFontProvider;

import org.eclipse.jface.viewers.ILabelProvider;

import org.eclipse.jface.viewers.ILabelProviderListener;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.viewers.LabelProviderChangedEvent;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.StyledCellLabelProvider;

import org.eclipse.jface.viewers.StyledString;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerCell;

import org.eclipse.swt.SWT;

import org.eclipse.swt.accessibility.AccessibleAdapter;

import org.eclipse.swt.accessibility.AccessibleEvent;

import org.eclipse.swt.events.ModifyEvent;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.events.TraverseEvent;

import org.eclipse.swt.events.TraverseListener;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

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

import org.eclipse.swt.widgets.Event;

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 org.eclipse.ui.IWorkbenchPreferenceConstants;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.dialogs.FilteredItemsSelectionDialog;

import org.eclipse.ui.internal.IWorkbenchGraphicConstants;

import org.eclipse.ui.internal.WorkbenchImages;

import org.eclipse.ui.internal.WorkbenchMessages;

import org.eclipse.ui.internal.WorkbenchPlugin;

import eu.etaxonomy.cdm.model.common.ICdmBase;

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

import eu.etaxonomy.taxeditor.l10n.Messages;

import eu.etaxonomy.taxeditor.ui.dialog.selection.CdmFilteredItemsSelectionDialog.ItemsListSeparator;

/**

 * @author k.luther

 * @date 15.11.2017

 *

 */

public abstract class SearchDialog<T extends ICdmBase> extends Dialog{// implements IConversationEnabled{

        private TableViewer list;

        private Text searchField;

        private String title;

        protected Button newButton1;

        protected Button newButton2;

        protected Button filterButton;

        protected Button btnCheckButton;

        private StructuredSelection currentSelection;

        // message to show user

        private String message = ""; //$NON-NLS-1$

        protected final ContentProvider contentProvider;

        ItemsListLabelProvider itemsListLabelProvider;

        private final RefreshCacheJob refreshCacheJob;

        protected Object preferenceID;

        protected final int new_id = 4;

        protected final int new_id2 = 5;

        protected final int space_id = 6;

        // Need to keep our own list of listeners

        private final ListenerList listeners = new ListenerList();

        private static final String EMPTY_STRING = ""; //$NON-NLS-1$

        private GridData gd_1;

        protected boolean useIdentifier;

        public SearchDialog(Shell parent, boolean multi) {

            super(parent);

            contentProvider = new ContentProvider();

            refreshCacheJob = new RefreshCacheJob();

        }

        @Override

        protected Control createDialogArea(Composite parent) {

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

            GridData gd = new GridData(GridData.FILL_BOTH);

            container.setLayoutData(gd);

            GridLayout layout = new GridLayout();

            layout.numColumns = 1;

            layout.marginWidth = 0;

            layout.marginHeight = 0;

            container.setLayout(layout);

            final Label headerLabel = createHeader(container);

            Composite searchAndFilter = new Composite(container, container.getStyle());

            searchAndFilter.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL));

            GridLayout searchAndFilterLayout = new GridLayout();

            searchAndFilterLayout.numColumns = 2;

            searchAndFilter.setLayout(searchAndFilterLayout);

            searchField = new Text(searchAndFilter, SWT.SINGLE | SWT.BORDER | SWT.SEARCH | SWT.ICON_CANCEL);

            searchField.getAccessible().addAccessibleListener(new AccessibleAdapter() {

                @Override

                public void getName(AccessibleEvent e) {

                    e.result = LegacyActionTools.removeMnemonics(headerLabel

                            .getText());

                }

            });

            searchField.addModifyListener(new ModifyListener() {

                @Override

                public void modifyText(ModifyEvent e) {

                    search();

//                    fillContentProvider(null);

                }

            });

            gd_1 = new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL);

            searchField.setLayoutData(gd_1);

            createFilterButton(searchAndFilter);

            addIdentifierCheckButton(searchAndFilter);

            setList(new TableViewer(container,  SWT.SINGLE

                    | SWT.BORDER | SWT.V_SCROLL | SWT.VIRTUAL));

            getList().setContentProvider(contentProvider);

            getList().setLabelProvider(getItemsListLabelProvider());

            getList().setInput(new Object[0]);

            getList().setItemCount(contentProvider.getNumberOfElements());

            getList().addSelectionChangedListener(new ISelectionChangedListener() {

                @Override

                public void selectionChanged(SelectionChangedEvent event) {

                    StructuredSelection selection = (StructuredSelection) event

                            .getSelection();

                    currentSelection = selection;

                }

            });

            getList().addDoubleClickListener(new IDoubleClickListener() {

                @Override

                public void doubleClick(DoubleClickEvent event) {

                    okPressed();

                }

            });

//            createExtendedContentArea(container);

            new Label(container, SWT.NONE);

            return container;

        }

        protected void addIdentifierCheckButton(Composite searchAndFilter) {

           //as default do nothing

        }

        abstract void createFilterButton(Composite searchAndFilter) ;

        protected abstract void search();

        /**

         * Sets the title for this dialog.

         *

         * @param title

         *            the title

         */

        public void setTitle(String title) {

            this.title = title;

        }

        /**

         * Create a new header which is labelled by headerLabel.

         *

         * @param parent

         * @return Label the label of the header

         */

        private Label createHeader(Composite parent) {

            Composite header = new Composite(parent, SWT.NONE);

            GridData gd_header = new GridData(SWT.CENTER, SWT.CENTER, false, false, 2, 1);

            gd_header.horizontalIndent = 5;

            gd_header.widthHint = 575;

            header.setLayoutData(gd_header);

            GridLayout layout = new GridLayout();

            layout.marginLeft = 5;

            layout.horizontalSpacing = 0;

            layout.verticalSpacing = 1;

            layout.marginWidth = 0;

            layout.marginHeight = 0;

            header.setLayout(layout);

            new Label(header, SWT.NONE);

            Label headerLabel = new Label(header, SWT.NONE);

            headerLabel.setText((getMessage() != null && getMessage().trim()

                    .length() > 0) ? getMessage()

                    : Messages.SearchDialog_patternLabel);

            headerLabel.addTraverseListener(new TraverseListener() {

                @Override

                public void keyTraversed(TraverseEvent e) {

                    if (e.detail == SWT.TRAVERSE_MNEMONIC && e.doit) {

                        e.detail = SWT.TRAVERSE_NONE;

                        searchField.setFocus();

                    }

                }

            });

            GridData gd_headerLabel = new GridData(GridData.FILL_HORIZONTAL);

            gd_headerLabel.horizontalAlignment = SWT.LEFT;

            gd_headerLabel.grabExcessHorizontalSpace = false;

            gd_headerLabel.verticalAlignment = SWT.BOTTOM;

            gd_headerLabel.minimumHeight = 10;

            headerLabel.setLayoutData(gd_headerLabel);

            return headerLabel;

        }

        protected String getMessage() {

            return message;

        }

        protected void setMessage(String message){

            this.message = message;

        }

        public Text getSearchField() {

            return searchField;

        }

        public void setSearchField(Text searchField) {

            this.searchField = searchField;

        }

        private ItemsListLabelProvider getItemsListLabelProvider() {

            if (itemsListLabelProvider == null) {

                itemsListLabelProvider = new ItemsListLabelProvider(

                        new LabelProvider());

            }

            return itemsListLabelProvider;

        }

        public TableViewer getList() {

            return list;

        }

        public void setList(TableViewer list) {

            this.list = list;

            Table table = list.getTable();

            GridData gd_table = new GridData(SWT.CENTER, SWT.CENTER, true, true, 2, 1);

            gd_table.heightHint = 231;

            gd_table.widthHint = 543;

            table.setLayoutData(gd_table);

        }

        public Button getNewButton1() {

            return newButton1;

        }

        public void setNewButton1(Button newButton1) {

            this.newButton1 = newButton1;

        }

        public Button getNewButton2() {

            return newButton2;

        }

        public void setNewButton2(Button newButton2) {

            this.newButton2 = newButton2;

        }

        public Button getFilterButton() {

            return filterButton;

        }

        public void setFilterButton(Button filterButton) {

            this.filterButton = filterButton;

        }

        /**

         * Sets a new label provider for items in the list. If the label provider

         * also implements {@link

         * org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider

         * .IStyledLabelProvider}, the style text labels provided by it will be used

         * provided that the corresponding preference is set.

         *

         * @see IWorkbenchPreferenceConstants#USE_COLORED_LABELS

         *

         * @param listLabelProvider

         *      the label provider for items in the list

         */

        public void setListLabelProvider(ILabelProvider listLabelProvider) {

            getItemsListLabelProvider().setProvider(listLabelProvider);

        }

        protected Comparator getItemsComparator() {

            return new Comparator<UuidAndTitleCache>() {

                @Override

                public int compare(UuidAndTitleCache entity1,

                        UuidAndTitleCache entity2) {

                    Collator collator = Collator.getInstance();

                    if (entity1.getUuid().equals(entity2.getUuid())){

                        return 0;

                    }

                    int result = collator.compare(entity1.getTitleCache(), entity2.getTitleCache());

                    if (result == 0){

                        result = entity1.getUuid().compareTo(entity2.getUuid());

                    }

                    return result;

                }

            };

        }

        class ContentProvider implements

                IStructuredContentProvider {

            private List items;

            /**

             * Creates new instance of <code>ContentProvider</code>.

             */

            public ContentProvider() {

                this.items = Collections.synchronizedList(new ArrayList(2048));

            }

            /**

             * Removes all content items and resets progress message.

             */

            public void reset() {

                this.items.clear();

            }

            public void add(Object item) {

                this.items.add(item);

            }

            /**

             * Refresh dialog.

             */

            public void refresh() {

                scheduleRefresh();

            }

            /**

             * Schedule refresh job.

             */

            public void scheduleRefresh() {

                refreshCacheJob.cancelAll();

                refreshCacheJob.schedule();

            }

            /*

             * (non-Javadoc)

             *

             * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)

             */

            @Override

            public Object[] getElements(Object inputElement) {

                return items.toArray();

            }

            public int getNumberOfElements() {

               return items.size();

            }

            /*

             * (non-Javadoc)

             *

             * @see org.eclipse.jface.viewers.IContentProvider#dispose()

             */

            @Override

            public void dispose() {

            }

            /*

             * (non-Javadoc)

             *

             * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,

             *      java.lang.Object, java.lang.Object)

             */

            @Override

            public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

            }

        }

        public boolean isUseIdentifier() {

            return useIdentifier;

        }

        public StructuredSelection getCurrentSelection() {

            return currentSelection;

        }

        /**

         * Fills the content provider with matching items.

         *

         * @param progressMonitor

         *            must be used to report search progress. The state of this

         *            progress monitor reflects the state of the filtering process.

         * @throws CoreException

         */

        protected abstract void fillContentProvider(IProgressMonitor progressMonitor) ;

        /**

         * Refreshes the dialog - has to be called in UI thread.

         */

        public void refresh() {

            if (getList() != null && !getList().getTable().isDisposed()) {

                List lastRefreshSelection = ((StructuredSelection) getList()

                        .getSelection()).toList();

                getList().getTable().deselectAll();

                getList().setItemCount(contentProvider.getNumberOfElements());

                getList().refresh();

                if (getList().getTable().getItemCount() > 0) {

                    // preserve previous selection

                    if ( lastRefreshSelection != null

                            && lastRefreshSelection.size() > 0) {

                        getList().setSelection(new StructuredSelection(

                                lastRefreshSelection));

                    } else {

                        getList().getTable().setSelection(0);

                        getList().getTable().notifyListeners(SWT.Selection, new Event());

                    }

                } else {

                    getList().setSelection(StructuredSelection.EMPTY);

                }

            }

        }

        /**

         * A job responsible for computing filtered items list presented using

         * <code>RefreshJob</code>.

         *

         * @see FilteredItemsSelectionDialog.RefreshJob

         *

         */

        private class RefreshCacheJob extends Job {

            public RefreshCacheJob() {

                super(

                        WorkbenchMessages.FilteredItemsSelectionDialog_cacheRefreshJob);

                setSystem(true);

            }

            /**

             * Stops the job and all sub-jobs.

             */

            public void cancelAll() {

                cancel();

            }

            /*

             * (non-Javadoc)

             *

             * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)

             */

            @Override

            protected IStatus run(IProgressMonitor monitor) {

                if (monitor.isCanceled()) {

                    return new Status(IStatus.CANCEL, WorkbenchPlugin.PI_WORKBENCH,

                            IStatus.CANCEL, EMPTY_STRING, null);

                }

                if (SearchDialog.this != null) {

                    SearchDialog.this.fillContentProvider(monitor);

                }

                return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, IStatus.OK,

                        EMPTY_STRING, null);

            }

            /*

             * (non-Javadoc)

             *

             * @see org.eclipse.core.runtime.jobs.Job#canceling()

             */

            @Override

            protected void canceling() {

                super.canceling();

            }

        }

        private class ItemsListLabelProvider extends StyledCellLabelProvider

        implements ILabelProviderListener {

            private ILabelProvider provider;

    /**

     * Creates a new instance of the class.

     *

     * @param provider

     *            the label provider for all items, not <code>null</code>

     * @param selectionDecorator

     *            the decorator for selected items, can be <code>null</code>

     */

    public ItemsListLabelProvider(ILabelProvider provider) {

        Assert.isNotNull(provider);

        this.provider = provider;

        this.provider.addListener(this);

    }

    /**

     * Sets new label provider.

     *

     * @param newProvider

     *            new label provider for items in the list, not

     *            <code>null</code>

     */

    public void setProvider(ILabelProvider newProvider) {

        Assert.isNotNull(newProvider);

        provider.removeListener(this);

        provider.dispose();

        provider = newProvider;

        if (provider != null) {

            provider.addListener(this);

        }

    }

    private boolean isSelected(Object element) {

        if (element != null && getCurrentSelection() != null) {

            if (element.equals(getCurrentSelection())) {

                return true;

            }

        }

        return false;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)

     */

    private String getText(Object element) {

        if (element instanceof ItemsListSeparator) {

            return getSeparatorLabel(((ItemsListSeparator) element)

                    .getName());

        }

        String str = provider.getText(element);

        return str;

    }

    private StyledString getStyledText(Object element,

            IStyledLabelProvider provider) {

        StyledString string = provider.getStyledText(element);

        return string;

    }

    @Override

    public void update(ViewerCell cell) {

        Object element = cell.getElement();

        if (!(element instanceof ItemsListSeparator)

                && provider instanceof IStyledLabelProvider) {

            IStyledLabelProvider styledLabelProvider = (IStyledLabelProvider) provider;

            StyledString styledString = getStyledText(element,

                    styledLabelProvider);

            cell.setText(styledString.getString());

            cell.setStyleRanges(styledString.getStyleRanges());

            cell.setImage(styledLabelProvider.getImage(element));

        } else {

            cell.setText(getText(element));

        }

        cell.setFont(getFont(element));

        cell.setForeground(getForeground(element));

        cell.setBackground(getBackground(element));

        super.update(cell);

    }

    private String getSeparatorLabel(String separatorLabel) {

        Rectangle rect = getList().getTable().getBounds();

        int borderWidth = getList().getTable().computeTrim(0, 0, 0, 0).width;

        int imageWidth = WorkbenchImages.getImage(

                IWorkbenchGraphicConstants.IMG_OBJ_SEPARATOR).getBounds().width;

        int width = rect.width - borderWidth - imageWidth;

        GC gc = new GC(getList().getTable());

        gc.setFont(getList().getTable().getFont());

        int fSeparatorWidth = gc.getAdvanceWidth('-');

        int fMessageLength = gc.textExtent(separatorLabel).x;

        gc.dispose();

        StringBuffer dashes = new StringBuffer();

        int chars = (((width - fMessageLength) / fSeparatorWidth) / 2) - 2;

        for (int i = 0; i < chars; i++) {

            dashes.append('-');

        }

        StringBuffer result = new StringBuffer();

        result.append(dashes);

        result.append(" " + separatorLabel + " "); //$NON-NLS-1$//$NON-NLS-2$

        result.append(dashes);

        return result.toString().trim();

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.jface.viewers.IBaseLabelProvider#addListener(org.eclipse.jface.viewers.ILabelProviderListener)

     */

    @Override

    public void addListener(ILabelProviderListener listener) {

        listeners.add(listener);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.jface.viewers.IBaseLabelProvider#dispose()

     */

    @Override

    public void dispose() {

        provider.removeListener(this);

        provider.dispose();

        super.dispose();

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.jface.viewers.IBaseLabelProvider#isLabelProperty(java.lang.Object,

     *      java.lang.String)

     */

    @Override

    public boolean isLabelProperty(Object element, String property) {

        if (provider.isLabelProperty(element, property)) {

            return true;

        }

        return false;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.jface.viewers.IBaseLabelProvider#removeListener(org.eclipse.jface.viewers.ILabelProviderListener)

     */

    @Override

    public void removeListener(ILabelProviderListener listener) {

        listeners.remove(listener);

    }

    private Color getBackground(Object element) {

        if (element instanceof ItemsListSeparator) {

            return null;

        }

        if (provider instanceof IColorProvider) {

            return ((IColorProvider) provider).getBackground(element);

        }

        return null;

    }

    private Color getForeground(Object element) {

        if (element instanceof ItemsListSeparator) {

            return Display.getCurrent().getSystemColor(

                    SWT.COLOR_WIDGET_NORMAL_SHADOW);

        }

        if (provider instanceof IColorProvider) {

            return ((IColorProvider) provider).getForeground(element);

        }

        return null;

    }

    private Font getFont(Object element) {

        if (element instanceof ItemsListSeparator) {

            return null;

        }

        if (provider instanceof IFontProvider) {

            return ((IFontProvider) provider).getFont(element);

        }

        return null;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.jface.viewers.ILabelProviderListener#labelProviderChanged(org.eclipse.jface.viewers.LabelProviderChangedEvent)

     */

    @Override

    public void labelProviderChanged(LabelProviderChangedEvent event) {

        Object[] l = listeners.getListeners();

        for (int i = 0; i < listeners.size(); i++) {

            ((ILabelProviderListener) l[i]).labelProviderChanged(event);

        }

    }

}

    @Override

    protected Point getInitialSize() {

        return new Point(593, 399);

    }

}