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

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

	private static final String PROPERTY_PUBLISH = "Publish";

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

	public static AbstractBulkEditorInput getInstance() {

		if (instance == null) {

			instance = new TaxonEditorInput();

		}

		return instance;

	}

    @Override

    protected List<String> getPropertyKeys_internal() {

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

        propertyKeysInternal.add(PROPERTY_PUBLISH);

        return propertyKeysInternal;

    }

    @Override

    public Object getPropertyValue(TaxonBase cdmBase, String property) {

        if(property.equals(PROPERTY_PUBLISH)){

            return cdmBase.isPublish();

        }

        return super.getPropertyValue(cdmBase, property);

    }

    @Override

    public boolean isBooleanProperty(String property) {

        if(property.equals(PROPERTY_PUBLISH)){

            return true;

        }

        return super.isBooleanProperty(property);

    }

    @Override

	public String getName() {

		return BulkEditorInputType.TAXON.label;

	}

	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;

    }

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

    }

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

	}

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

	}

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

    }

}