EDIT

package eu.etaxonomy.taxeditor.bulkeditor.input;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.UUID;

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

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

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

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

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

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

import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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.annotatedlineeditor.IEntityCreator;

import eu.etaxonomy.taxeditor.bulkeditor.IBulkEditorSortProvider;

import eu.etaxonomy.taxeditor.bulkeditor.input.entitycreator.TaxonCreator;

import eu.etaxonomy.taxeditor.bulkeditor.input.sortprovider.IdentifiableEntitySortProvider;

import eu.etaxonomy.taxeditor.store.CdmStore;

public class TaxonEditorInput extends AbstractBulkEditorInput<TaxonBase>{

	private static TaxonEditorInput instance;

	/** Constant <code>ID="bulkeditor.input.taxon"</code> */

	public static final String ID = "bulkeditor.input.taxon";

	private List<TaxonName> saveNameCandidates = new ArrayList<>();

	/**

	 * <p>Getter for the field <code>instance</code>.</p>

	 *

	 * @return a {@link eu.etaxonomy.taxeditor.bulkeditor.input.AbstractBulkEditorInput} object.

	 */

	public static AbstractBulkEditorInput getInstance() {

		if (instance == null) {

			instance = new TaxonEditorInput();

		}

		return instance;

	}

    @Override

	public String getName() {

		return BulkEditorInputType.TAXON.label;

	}

	/**

	 * <p>getID</p>

	 *

	 * @return a {@link java.lang.Object} object.

	 */

	public static Object getID() {

		return ID;

	}

	@Override

    public List<IBulkEditorSortProvider<TaxonBase>> getSortProviders() {

        List<IBulkEditorSortProvider<TaxonBase>> sortProviders = super.getSortProviders();

        sortProviders.add(0, new IdentifiableEntitySortProvider<TaxonBase>());

        return sortProviders;

    }

	/* (non-Javadoc)

	 * @see eu.etaxonomy.taxeditor.bulkeditor.input.BulkEditorInput#isMergingEnabled()

	 */

	/** {@inheritDoc} */

	@Override

	public boolean isMergingEnabled() {

		return false;

	}

	@Override

	public TaxonBase save(TaxonBase entity) {

	    return CdmStore.getService(ITaxonService.class).merge(entity, true).getMergedEntity();

	}

    @Override

    protected long countEntities(IIdentifiableEntityServiceConfigurator configurator) {

        return CdmStore.getService(ITaxonService.class).countByTitle(configurator);

    }

	/** {@inheritDoc} */

	@Override

	public List listEntities(IIdentifiableEntityServiceConfigurator configurator) {

//		IFindTaxaAndNamesConfigurator<TaxonBase> newConfig = new FindTaxaAndNamesConfiguratorImpl<>();

//		newConfig.setTitleSearchString(configurator.getTitleSearchStringSqlized());

//		newConfig.setMatchMode(MatchMode.ANYWHERE);

		List<TaxonBase> taxa =  CdmStore.getSearchManager().findTaxa(configurator);

		List<TaxonBase> taxaCopy = new ArrayList<TaxonBase>();

		for (TaxonBase taxon:taxa){

			if (taxon instanceof Taxon){

				taxaCopy.add(HibernateProxyHelper.deproxy(taxon, Taxon.class));

			}else{

				taxaCopy.add(HibernateProxyHelper.deproxy(taxon, Synonym.class));

			}

		}

		return taxaCopy;

	}

	@Override

	protected TaxonBase loadEntity(UUID entityUuid) {

		List<String> propertyPaths = Arrays.asList(new String[]{});

		return CdmStore.getService(ITaxonService.class).load(entityUuid, propertyPaths);

	}

	/** {@inheritDoc}

	 * @throws ReferencedObjectUndeletableException */

	@Override

    public boolean delete(TaxonBase entity, DeleteConfiguratorBase config) {

		if (entity instanceof Taxon){

			TaxonDeletionConfigurator taxonConfig = null;

			if (config instanceof TaxonDeletionConfigurator){

				taxonConfig = (TaxonDeletionConfigurator)config;

			}else{

			}

			return CdmStore.getService(ITaxonService.class).deleteTaxon(entity.getUuid(), taxonConfig, null) != null;

		} else{

			SynonymDeletionConfigurator synConfig = null;

			if (config instanceof SynonymDeletionConfigurator){

				synConfig = (SynonymDeletionConfigurator)config;

			}else{

			}

			return CdmStore.getService(ITaxonService.class).deleteSynonym(entity.getUuid(), synConfig) != null;

		}

	}

	@Override

	protected IEntityCreator<TaxonBase> createEntityCreator() {

		return new TaxonCreator();

	}

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.editor.CdmEntitySessionInput#merge()

     */

    @Override

    public void merge() {

    }

    @Override

    public void addSaveCandidate(TaxonBase taxonBase){

       if (!taxonBase.getName().getHybridChildRelations().isEmpty()){

           for (HybridRelationship rel: taxonBase.getName().getHybridChildRelations()){

               if (!rel.getParentName().isPersited()){

                   this.saveNameCandidates.add(rel.getParentName());

               }

               if (!rel.getHybridName().isPersited()){

                   this.saveNameCandidates.add(rel.getHybridName());

               }

           }

       }

       super.addSaveCandidate(taxonBase);

   }

    @Override

    public void saveModel(boolean resetMerge){

        CdmStore.getService(INameService.class).save(this.saveNameCandidates);

        super.saveModel(resetMerge);

    }

}