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

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

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

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

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

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

import eu.etaxonomy.taxeditor.annotatedlineeditor.IEntityCreator;

import eu.etaxonomy.taxeditor.bulkeditor.IBulkEditorSortProvider;

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

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

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * <p>NameEditorInput class.</p>

 *

 * @author p.ciardelli

 * @created 20.08.2009

 */

public class NameEditorInput extends AbstractBulkEditorInput<TaxonName> {

	private static final long serialVersionUID = -3085029575759626823L;

	private static NameEditorInput instance;

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

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

	/**

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

		}

		return instance;

	}

    @Override

    public String getName() {

		return BulkEditorInputType.NAME.label;

	}

	/**

	 * <p>getID</p>

	 *

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

	 */

	public static Object getID() {

		return ID;

	}

	/* (non-Javadoc)

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

	 */

	/** {@inheritDoc} */

	@Override

	public boolean isMergingEnabled() {

		return false;

	}

	@Override

	protected int getPageSize() {

	    return 50;

	}

	@Override

	protected long countEntities(IIdentifiableEntityServiceConfigurator configurator) {

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

	}

	/** {@inheritDoc} */

	@Override

	public List listEntities(IIdentifiableEntityServiceConfigurator configurator) {

		configurator.setPropertyPaths(getPropertyPaths());

		return CdmStore.getSearchManager().findNames(configurator, this.getConversation());

	}

	/** {@inheritDoc}

	@Override

	public TaxonNameBase loadEntity(UUID uuid) {

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

		return CdmStore.getService(INameService.class).load(uuid, propertyPaths);

	}

*/

	@Override

    public boolean delete(TaxonName entity, DeleteConfiguratorBase config)  {

		NameDeletionConfigurator nameConfig = null;

		if (config instanceof NameDeletionConfigurator){

			nameConfig = (NameDeletionConfigurator) config;

		} else{

		}

		return CdmStore.getService(INameService.class).delete(entity.getUuid(), nameConfig) != null;

	}

	/** {@inheritDoc} */

	@Override

    public TaxonName save(TaxonName entity) {

		TaxonName mergedName = null;

		mergedName =  CdmStore.getService(INameService.class).merge(entity, true).getMergedEntity();

	   	return mergedName;

	}

	@Override

	protected IEntityCreator<TaxonName> createEntityCreator() {

		return new NameCreator();

	}

	@Override

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

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

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

		return sortProviders;

	}

	@Override

	public String getTypeText(Object entity) {

		if((entity instanceof TaxonName) && (((TaxonName) entity).getNomenclaturalCode() != null)){

			return ((TaxonName) entity).getNomenclaturalCode().getTitleCache();

		}

		return super.getTypeText(entity);

	}

	@Override

	public String getText(TaxonName entity) {

		return (entity).getFullTitleCache();

	}

    @Override

    public void merge() {

    }

	@Override

	protected TaxonName loadEntity(UUID entityUuid) {

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

		return CdmStore.getService(INameService.class).load(entityUuid, getPropertyPaths());

	}

	@Override

	 public void addSaveCandidate(TaxonName name){

	    if (!name.getHybridChildRelations().isEmpty()){

	        for (HybridRelationship rel: name.getHybridChildRelations()){

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

	                super.addSaveCandidate(rel.getParentName());

	            }

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

                    super.addSaveCandidate(rel.getHybridName());

                }

	        }

	    }

        super.addSaveCandidate(name);

    }

    private List<String> getPropertyPaths(){

    	 List<String> nameBasePropertyPaths = Arrays.asList(new String[] {

    	 "name.descriptions",

         "name.typeDesignations",

         "name.status",

         "name.nomenclaturalReference.inReference",

         "name.taxonBases.taxonNodes",

         "name.relationsFromThisName",

         "name.relationsToThisName",

         "name.homotypicalGroup.typifiedNames.taxonBases.synonyms.synonym.name.status",

         "name.homotypicalGroup.typifiedNames.relationsToThisName.fromName"});

    	 return nameBasePropertyPaths;

    }

}