EDIT

/**

 * Copyright (C) 2007 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.bulkeditor.e4.handler;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import javax.inject.Named;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.e4.core.di.annotations.CanExecute;

import org.eclipse.e4.core.di.annotations.Execute;

import org.eclipse.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;

import org.eclipse.e4.ui.services.IServiceConstants;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.swt.widgets.Shell;

import eu.etaxonomy.cdm.api.application.ICdmRepository;

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

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

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

import eu.etaxonomy.cdm.api.service.config.DeleteConfiguratorBase;

import eu.etaxonomy.cdm.api.service.config.MediaDeletionConfigurator;

import eu.etaxonomy.cdm.api.service.config.NameDeletionConfigurator;

import eu.etaxonomy.cdm.api.service.config.SpecimenDeleteConfigurator;

import eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator;

import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

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

import eu.etaxonomy.cdm.model.media.Media;

import eu.etaxonomy.cdm.model.name.TaxonName;

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

import eu.etaxonomy.cdm.model.permission.Group;

import eu.etaxonomy.cdm.model.permission.User;

import eu.etaxonomy.cdm.model.reference.Reference;

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

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

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

import eu.etaxonomy.taxeditor.bulkeditor.e4.BulkEditor;

import eu.etaxonomy.taxeditor.bulkeditor.internal.TaxeditorBulkeditorPlugin;

import eu.etaxonomy.taxeditor.l10n.Messages;

import eu.etaxonomy.taxeditor.model.DeleteResultMessagingUtils;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.remoting.CdmEagerLoadingException;

import eu.etaxonomy.taxeditor.security.RequiredPermissions;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.ui.dialog.configurator.deleteConfigurator.DeleteConfiguratorDialog;

/**

 *

 * @author pplitzner

 * @date 11.09.2017

 *

 */

public class DeleteHandlerE4 {

    private static final String COULD_NOT_BE_DELETED = eu.etaxonomy.taxeditor.l10n.Messages.DeleteHandler_COULD_NOT_BE_DELETED;

    private static final String AN_EXCEPTION_OCCURED = Messages.DeleteHandler_EXCEPTION;

    private static final String DELETE_NOT_POSSIBLE = Messages.DeleteHandler_DELETE_NOT_POSSIBLE;

    private static final String ALREADY_DELETED = Messages.DeleteHandler_ALREADY_DELETED;

    private static final String DO_YOU_REALLY_WANT_TO_DELETE_THE_S = Messages.DeleteHandler_REALLY_DELETE;

    private static final String MEDIA = Messages.DeleteHandler_MEDIA;

    private static final String TEAM_OR_PERSON = Messages.DeleteHandler_TEAM_OR_PERSON;

    private static final String TAXON = Messages.DeleteHandler_TAXON;

    private static final String SYNONYM = Messages.DeleteHandler_SYNONYM;

    private static final String NAME = Messages.DeleteHandler_NAME;

    private static final String OBJECT_MISSIN_RIGHTS = Messages.DeleteHandler_OBJECT_MISSING_RIGHTS;

    private static final String USER = Messages.DeleteHandler_USER;

    private static final String GROUP = Messages.DeleteHandler_GROUP;

    private static final String REFERENCE = Messages.DeleteHandler_REFERENCE;

    private static final String SPECIMEN_OR_OBSERVATION = Messages.DeleteHandler_SPECIMEN;

    private static final String OBJECT = Messages.DeleteHandler_OBJECT;

    private static final String SKIP = Messages.DeleteHandler_SKIP;

    private static final String DELETE = eu.etaxonomy.taxeditor.l10n.Messages.DeleteHandler_DELETE;

    private static final String CONFIRM_DELETION = Messages.DeleteHandler_CONFIRM;

    @Execute

    public void execute(@Named(IServiceConstants.ACTIVE_PART)MPart activePart,

            @Named(IServiceConstants.ACTIVE_SHELL)Shell shell) {

        BulkEditor editor= (BulkEditor) activePart.getObject();

        IStructuredSelection selection = editor.getSelection();

        Iterator iterator = selection.iterator();

        int selectionCount = selection.size();

        Set<CdmBase> removeFromSelection = new HashSet();

        for(selection.iterator();iterator.hasNext();){

            CdmBase cdmBase = (CdmBase) iterator.next();

            if (!cdmBase.isPersited()){

                editor.getEditorInput().getModel().remove(cdmBase);

                editor.getEditorInput().getSaveCandidates().remove(cdmBase);

                removeFromSelection.add(cdmBase);

                selectionCount--;

            }

        }

        if (selectionCount == 0){

            if (editor.getEditorInput().getMergeCandidates().size() == 0 && editor.getEditorInput().getSaveCandidates().size() == 0 && editor.getEditorInput().getToDelete().size() == 0){

                editor.setDirty(false);

            }

            return;

        }

        if (editor.isDirty()){

            boolean proceed = MessageDialog.openQuestion(null,

                    "Save changes", "You have made changes that must be saved before this query can be executed. Would you like to proceed?");

            if (proceed) {

                editor.save(new NullProgressMonitor());

            } else {

                return ;

            }

        }

        iterator = selection.iterator();

        for(selection.iterator();iterator.hasNext();){

            CdmBase cdmBase = (CdmBase) iterator.next();

            if (cdmBase.isPersited()){

                delete(cdmBase, shell, editor);

            }

        }

    }

    private void delete(CdmBase object, Shell shell, BulkEditor editor){

        String errorMessage= OBJECT;

        DeleteConfiguratorBase config = null;

        DeleteResult result = new DeleteResult();

        boolean deleteAllowed = CdmStore.currentAuthentiationHasPermission(object,

                RequiredPermissions.NAME_DELETE);

        if (!deleteAllowed){

            MessagingUtils.messageDialog(OBJECT_MISSIN_RIGHTS, getClass(),

                    String.format(

                            Messages.DeleteHandler_OBJECT_MISSING_RIGHTS_MESSAGE+"\n",

                            object.getUserFriendlyDescription()),

                    null);

            return;

        }

        try {

            ICdmRepository controller;

            controller = CdmStore.getCurrentApplicationConfiguration();

            if (object instanceof SpecimenOrObservationBase){

                IOccurrenceService service = controller.getOccurrenceService();

                config = new SpecimenDeleteConfigurator();

                DeleteConfiguratorDialog dialog = new DeleteConfiguratorDialog(config,

                        shell, CONFIRM_DELETION, null,

                        String.format(

                                DO_YOU_REALLY_WANT_TO_DELETE_THE_S+"\n"+Messages.DeleteHandler_IRREVERSIBLE,

                                SPECIMEN_OR_OBSERVATION),

                        MessageDialog.WARNING,

                        new String[] { DELETE, SKIP }, 0, true);

                int result_dialog = dialog.open();

                if (result_dialog != IStatus.OK){

                    return;

                }

                result = service.isDeletable(((SpecimenOrObservationBase<?>) object).getUuid(), config);

                errorMessage = SPECIMEN_OR_OBSERVATION;

            } else if (object instanceof Reference){

                IReferenceService service = controller.getReferenceService();

                result = service.isDeletable(((Reference)object).getUuid(), null);

                errorMessage = REFERENCE;

            } else if (object instanceof Group){

                errorMessage = GROUP;

            }else if (object instanceof User){

                errorMessage = USER;

            } else if (object instanceof TaxonName){

                try{

                    TaxonName name = HibernateProxyHelper.deproxy(object, TaxonName.class);

                    config = new NameDeletionConfigurator();

                    DeleteConfiguratorDialog dialog = new DeleteConfiguratorDialog(config,

                            shell, CONFIRM_DELETION, null,

                            String.format(

                                    DO_YOU_REALLY_WANT_TO_DELETE_THE_S+"\n"+Messages.DeleteHandler_IRREVERSIBLE,

                                    NAME),

                            MessageDialog.WARNING, new String[] { DELETE, SKIP }, 0, true);

                    int result_dialog = dialog.open();

                    if (result_dialog != IStatus.OK){

                        return;

                    }

                    if (deleteAllowed){

                        result = controller.getNameService().isDeletable(name.getUuid(), config);

                        errorMessage = NAME;

                    }else{

                        errorMessage = NAME;

                        result.setError();

                    }

                } catch(Exception e){

                    MessagingUtils.messageDialog(((TaxonName) object).getTitleCache() + " " +ALREADY_DELETED, getClass(),

                            Messages.DeleteHandler_ALREADY_DELETED,

                            null);

                    return;

                }

            } else if (object instanceof TaxonBase){

                // synonym

                if(object instanceof Synonym){

                    try{

                        Synonym synonym = HibernateProxyHelper.deproxy(object, Synonym.class);

                        config = new SynonymDeletionConfigurator();

                        errorMessage = SYNONYM;

                        DeleteConfiguratorDialog dialog = new DeleteConfiguratorDialog(config,

                                shell, CONFIRM_DELETION, null,

                                String.format(DO_YOU_REALLY_WANT_TO_DELETE_THE_S, SYNONYM),

                                MessageDialog.WARNING, new String[] { DELETE, SKIP }, 0, true);

                        int result_dialog = dialog.open();

                        if (result_dialog != IStatus.OK){

                            return;

                        }

                        result = controller.getTaxonService().isDeletable(synonym.getUuid(), config);

                    } catch(CdmEagerLoadingException e){

                        MessagingUtils.messageDialog(((TaxonBase) object).getTitleCache() + " " +ALREADY_DELETED, getClass(),

                                Messages.DeleteHandler_ALREADY_DELETED,

                                null);

                        return;

                    }

                }

                else if(object instanceof Taxon ){

                    try{

                        Taxon  taxon = HibernateProxyHelper.deproxy(object, Taxon.class);

                        if (((Taxon)object).getTaxonNodes().isEmpty()){

                            errorMessage = TAXON;

                        } else {

                            MessagingUtils.messageDialog(DELETE_NOT_POSSIBLE, getClass(),

                                    Messages.DeleteHandler_TAXON_CAN_NOT_BE_DELETED,

                                    null);

                            return;

                        }

                        config = new TaxonDeletionConfigurator();

                        ((TaxonDeletionConfigurator) config).setDeleteInAllClassifications(true);

                        DeleteConfiguratorDialog dialog;

                        dialog = new DeleteConfiguratorDialog(config, shell,

                                CONFIRM_DELETION, null,

                                String.format(DO_YOU_REALLY_WANT_TO_DELETE_THE_S, TAXON),

                                MessageDialog.WARNING, new String[] { DELETE, SKIP }, 0, true);

                        int result_dialog = dialog.open();

                        if (result_dialog != IStatus.OK){

                            return;

                        }

                        result = controller.getTaxonService().isDeletable(taxon.getUuid(), config);

                    } catch(CdmEagerLoadingException e){

                        MessagingUtils.messageDialog(((TaxonBase) object).getTitleCache() + " " +ALREADY_DELETED, getClass(),

                                Messages.DeleteHandler_ALREADY_DELETED,

                                null);

                        return;

                    }

                }

            } else if (object instanceof TeamOrPersonBase){

                result = controller.getAgentService().isDeletable(object.getUuid(), null);

                errorMessage = TEAM_OR_PERSON;

            } else if (object instanceof Media){

                config = new MediaDeletionConfigurator();

                Media media = HibernateProxyHelper.deproxy(object, Media.class);

                ((MediaDeletionConfigurator)config).setDeleteFrom(media);

                DeleteConfiguratorDialog dialog;

                dialog = new DeleteConfiguratorDialog(config, shell,

                        CONFIRM_DELETION, null,

                        String.format(DO_YOU_REALLY_WANT_TO_DELETE_THE_S, MEDIA),

                        MessageDialog.WARNING, new String[] { DELETE, SKIP }, 0, true);

                int result_dialog = dialog.open();

                if (result_dialog != IStatus.OK){

                    return;

                }

                result = controller.getMediaService().isDeletable(media.getUuid(), config);

                errorMessage = MEDIA;

            }

        } catch (Exception e){

            MessagingUtils.errorDialog(AN_EXCEPTION_OCCURED+" "+DELETE_NOT_POSSIBLE, getClass(), e.getMessage(), TaxeditorBulkeditorPlugin.PLUGIN_ID, null, true); //$NON-NLS-1$

        }

        if (result.isError() || result.isAbort()){

            //convert first letter to upper case

            errorMessage = errorMessage.substring(0, 1).toUpperCase()+errorMessage.substring(1);

            if (!result.getExceptions().isEmpty()) {

                List<String> messages = new ArrayList<String>();

                for (Exception e:result.getExceptions()){

                    messages.add(e.getMessage());

                }

                errorMessage += " " +COULD_NOT_BE_DELETED; //$NON-NLS-1$

                //MessagingUtils.errorDialog("test", getClass(), "message", TaxeditorBulkeditorPlugin.PLUGIN_ID, result.getExceptions().iterator().next(),true);

                DeleteResultMessagingUtils.messageDialogWithDetails(result,errorMessage, TaxeditorBulkeditorPlugin.PLUGIN_ID);

            }else{

                MessagingUtils.messageDialog(DELETE_NOT_POSSIBLE, getClass(), errorMessage+" "+COULD_NOT_BE_DELETED+" "+AN_EXCEPTION_OCCURED, null); //$NON-NLS-1$ //$NON-NLS-2$

            }

        }

        if (result.isOk() ){

            editor.getEditorInput().addToDelete(object, config);

            editor.getEditorInput().getModel().remove(object);

            editor.refresh();

            editor.setDirty();

            if(result.getUpdatedObjects().size() != 0 || !result.getExceptions().isEmpty()){

                List<String> messages = new ArrayList<String>();

                for (Exception e:result.getExceptions()){

                    messages.add(e.getMessage());

                }

                //convert first letter to upper case

                errorMessage = errorMessage.substring(0, 1).toUpperCase()+errorMessage.substring(1);

                errorMessage += eu.etaxonomy.taxeditor.l10n.Messages.DeleteHandler_CAN_BE_DELETED;

                //MessagingUtils.errorDialog("test", getClass(), "message", TaxeditorBulkeditorPlugin.PLUGIN_ID, result.getExceptions().iterator().next(),true);

                DeleteResultMessagingUtils.messageDialogWithDetails(result, errorMessage, TaxeditorBulkeditorPlugin.PLUGIN_ID);

            }

        }

    }

    @CanExecute

    public boolean canExecute(@Named(IServiceConstants.ACTIVE_PART)MPart activePart,

            MHandledMenuItem menuItem){

        boolean canExecute = false;

        IStructuredSelection selection = ((BulkEditor)activePart.getObject()).getSelection();

        canExecute = !selection.isEmpty();

        Iterator iterator = selection.iterator();

        for(selection.iterator();iterator.hasNext();){

            if(!(iterator.next() instanceof CdmBase)){

                canExecute = false;

                break;

            }

        }

        menuItem.setVisible(canExecute);

        return canExecute;

    }

}