EDIT

// $Id$

/**

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

import java.util.HashMap;

import java.util.Map;

import java.util.UUID;

import org.eclipse.core.commands.Command;

import org.eclipse.core.commands.ParameterizedCommand;

import org.eclipse.core.commands.common.NotDefinedException;

import org.eclipse.jface.dialogs.PopupDialog;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.ILabelProvider;

import org.eclipse.jface.viewers.ILabelProviderListener;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.Table;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.handlers.IHandlerService;

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

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

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

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.taxon.Synonym;

import eu.etaxonomy.cdm.model.taxon.Taxon;

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

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * This class opens a popup dialog and provides the possibility to choose from a

 * list of possible viewers which can be opened for a given input.

 *

 * @author pplitzner

 * @date Feb 23, 2015

 *

 */

public class CdmViewerChooser extends PopupDialog implements ISelectionChangedListener, ILabelProvider{

    private Map<Command, String> nameViewerMap;

    private Object input;

    public CdmViewerChooser(Shell parentShell) {

        this(parentShell, SWT.RESIZE | SWT.ON_TOP, true, false, false, false, false, "Open in ...",

                "Clicking will open the selected viewer");

    }

    public CdmViewerChooser(Shell parent, int shellStyle, boolean takeFocusOnOpen, boolean persistSize,

            boolean persistLocation, boolean showDialogMenu, boolean showPersistActions, String titleText,

            String infoText) {

        super(parent, shellStyle, takeFocusOnOpen, persistSize, persistLocation, showDialogMenu, showPersistActions,

                titleText, infoText);

    }

    /**

     * Opens a popup dialog with all possible viewers for the given input.

     * @param input the input for which the viewers are listed

     */

    public void chooseViewer(Object input){

        this.input = input;

        this.nameViewerMap = CdmViewerUtil.getAvailableViewers(input);

        //if only one editor is available then open it

        if(nameViewerMap.size()==1){

            Command command = nameViewerMap.keySet().iterator().next();

            executeCommand(command, input);

        }

        else{

            if(nameViewerMap.isEmpty()){

                this.setInfoText("No viewers registered for this input");

            }

            this.open();

        }

    }

    private void executeCommand(Command command, Object input) {

    	 //for generic UuidAndTitleCache objects try to load the object

        if (input instanceof UuidAndTitleCache){

            UuidAndTitleCache uuidAndTitleCache = (UuidAndTitleCache)input;

            Class type = uuidAndTitleCache.getType();

            if(type == Taxon.class || type == Synonym.class){

            	input = CdmStore.getService(ITaxonService.class).load(uuidAndTitleCache.getUuid());

            }

            else if(SpecimenOrObservationBase.class.isAssignableFrom(type)){

            	input = CdmStore.getService(IOccurrenceService.class).load(uuidAndTitleCache.getUuid());

            }

        }

        //set uuid parameter

        if(input instanceof ICdmBase){

            Map<String, UUID> params = new HashMap<String, UUID>();

            String commandId = command.getId();

			params.put(commandId+".uuid", ((ICdmBase) input).getUuid());

			if(command.isEnabled()) {

			    //build the parameterized command

			    ParameterizedCommand pc = ParameterizedCommand.generateCommand(command, params);

                IHandlerService handlerService = (IHandlerService)PlatformUI.getWorkbench().getService(IHandlerService.class);

                try {

                    if(pc!=null){

                        handlerService.executeCommand(pc, null);

                    }

                    else{

                        handlerService.executeCommand(commandId, null);

                    }

                } catch (NotDefinedException nde) {

                    throw new RuntimeException("Could not find open command: " + commandId);

                } catch (Exception exception) {

                    MessagingUtils.error(getClass(), "An exception occured while trying execute "+commandId, exception);

                }

            }

        }

    }

    @Override

    protected Control createDialogArea(Composite parent) {

        TableViewer viewer = new TableViewer(new Table(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION));

        viewer.setContentProvider(new ArrayContentProvider());

        viewer.setLabelProvider(this);

        viewer.addSelectionChangedListener(this);

        viewer.setInput(nameViewerMap.keySet());

        return parent;

    }

    @Override

    public void selectionChanged(SelectionChangedEvent event) {

        ISelection selection = event.getSelection();

        if(selection instanceof IStructuredSelection){

            Object firstElement = ((IStructuredSelection) selection).getFirstElement();

            if(firstElement instanceof Command && nameViewerMap.containsKey(firstElement)){

                executeCommand((Command) firstElement, this.input);

                this.close();

            }

        }

    }

    @Override

    public String getText(Object element) {

        return nameViewerMap.get(element);

    }

    @Override

    public void addListener(ILabelProviderListener listener) {

        // TODO Auto-generated method stub

    }

    @Override

    public void dispose() {

        // TODO Auto-generated method stub

    }

    @Override

    public boolean isLabelProperty(Object element, String property) {

        // TODO Auto-generated method stub

        return false;

    }

    @Override

    public void removeListener(ILabelProviderListener listener) {

        // TODO Auto-generated method stub

    }

    @Override

    public Image getImage(Object element) {

        // TODO Auto-generated method stub

        return null;

    }

}