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.dialogs.IDialogConstants;

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

import org.eclipse.swt.events.KeyEvent;

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.2017d

 */

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, String title) {

        super(parent);

        this.title = title;

        contentProvider = new ContentProvider();

        refreshCacheJob = new RefreshCacheJob();

    }

    @Override

    public void create() {

        super.create();

        refresh();

    }

    @Override

    protected void configureShell(Shell shell) {

        super.configureShell(shell);

        shell.setText(title);

     }

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

        gd_1.horizontalIndent = 7;

        searchField.setLayoutData(gd_1);

        createFilterButton(searchAndFilter);

        addIdentifierCheckButton(searchAndFilter);

//      new Label(searchAndFilter, SWT.NONE);

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

            }

        });

        searchField.addKeyListener(new KeyAdapter() {

            @Override

            public void keyPressed(KeyEvent e) {

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

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

                        getList().getTable().setFocus();

                    }

                }

            }

        });

//      createExtendedContentArea(container);

        new Label(container, SWT.NONE);

        search();

        return container;

    }

    protected void addIdentifierCheckButton(Composite searchAndFilter) {

       //as default do nothing

    }

    abstract void createFilterButton(Composite searchAndFilter) ;

    protected abstract void search();

    /**

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

//        }

        @Override

        public Object[] getElements(Object inputElement) {

            return items.toArray();

        }

        public int getNumberOfElements() {

           return items.size();

        }

        @Override

        public void dispose() {

        }

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

                }

                if ( super.getButton(IDialogConstants.OK_ID) != null){

                    super.getButton(IDialogConstants.OK_ID).setEnabled(true);

                }

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

        }

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

        }

        @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;

        }

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

        }

        @Override

        public void addListener(ILabelProviderListener listener) {

            listeners.add(listener);

        }

        @Override

        public void dispose() {

            provider.removeListener(this);

            provider.dispose();

            super.dispose();

        }

        @Override

        public boolean isLabelProperty(Object element, String property) {

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

                return true;

            }

            return false;

        }

        @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;

        }

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

    }

}