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

/**

 *

 * @author p.ciardelli

 * @created 20.08.2009

 */

public class NameEditorInput extends AbstractBulkEditorInput<TaxonName> {

	private static final long serialVersionUID = -3085029575759626823L;

	private static NameEditorInput instance;

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

	private static final String PROPERTY_NAME_CACHE = "Name Cache";

	private static final String PROPERTY_PROTECT_NAME_CACHE = "Protect Name Cache";

	private static final String PROPERTY_AUTHORSHIP_CACHE = "Authorship Cache";

	private static final String PROPERTY_PROTECT_AUTHORSHIP_CACHE = "Protect Authorship Cache";

	private static final String PROPERTY_GENUS = "Genus";

	private static final String PROPERTY_INFRA_GENERIC = "Infra Generic";

	private static final String PROPERTY_SPECIFIC_EPITHET = "Spec. Epithet";

	private static final String PROPERTY_INFRA_SPECIFIC_EPITHET = "Infra Spec. Epithet";

	public static AbstractBulkEditorInput getInstance() {

		if (instance == null) {

			instance = new NameEditorInput();

		}

		return instance;

	}

	@Override

    protected List<String> getPropertyKeys_internal() {

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

        propertyKeysInternal.add(PROPERTY_NAME_CACHE);

        propertyKeysInternal.add(PROPERTY_PROTECT_NAME_CACHE);

        propertyKeysInternal.add(PROPERTY_AUTHORSHIP_CACHE);

        propertyKeysInternal.add(PROPERTY_PROTECT_AUTHORSHIP_CACHE);

        propertyKeysInternal.add(PROPERTY_GENUS);

        propertyKeysInternal.add(PROPERTY_INFRA_GENERIC);

        propertyKeysInternal.add(PROPERTY_SPECIFIC_EPITHET);

        propertyKeysInternal.add(PROPERTY_INFRA_SPECIFIC_EPITHET);

        return propertyKeysInternal;

    }

	@Override

	public Object getPropertyValue(TaxonName cdmBase, String property) {

	    if(property.equals(PROPERTY_NAME_CACHE)){

	        return cdmBase.getNameCache();

	    }

	    else if(property.equals(PROPERTY_PROTECT_NAME_CACHE)){

	        return cdmBase.isProtectedNameCache();

	    }

	    else if(property.equals(PROPERTY_AUTHORSHIP_CACHE)){

	        return cdmBase.getAuthorshipCache();

	    }

	    else if(property.equals(PROPERTY_PROTECT_AUTHORSHIP_CACHE)){

	        return cdmBase.isProtectedAuthorshipCache();

	    }

	    else if(property.equals(PROPERTY_GENUS)){

	        return cdmBase.getGenusOrUninomial();

	    }

	    else if(property.equals(PROPERTY_INFRA_GENERIC)){

	        return cdmBase.getInfraGenericEpithet();

	    }

	    else if(property.equals(PROPERTY_SPECIFIC_EPITHET)){

	        return cdmBase.getSpecificEpithet();

	    }

	    else if(property.equals(PROPERTY_INFRA_SPECIFIC_EPITHET)){

	        return cdmBase.getInfraSpecificEpithet();

	    }

	    return super.getPropertyValue(cdmBase, property);

	}

	@Override

	public boolean isBooleanProperty(String property) {

	    if(property.equals(PROPERTY_PROTECT_NAME_CACHE)

	            || property.equals(PROPERTY_PROTECT_AUTHORSHIP_CACHE)){

	        return true;

	    }

	    return super.isBooleanProperty(property);

	}

    @Override

    public boolean isCacheProperty(String property) {

        if(property.equals(PROPERTY_PROTECT_NAME_CACHE)

                || property.equals(PROPERTY_PROTECT_AUTHORSHIP_CACHE)){

            return true;

        }

        return super.isCacheProperty(property);

    }

    @Override

    public String getName() {

		return BulkEditorInputType.NAME.label;

	}

	public static Object getID() {

		return ID;

	}

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

	}

	@Override

	public List listEntities(IIdentifiableEntityServiceConfigurator configurator) {

		configurator.setPropertyPaths(getPropertyPaths());

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

	}

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

	}

	@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).getNameType() != null)){

			return ((TaxonName) entity).getNameType().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[] {

    	 "descriptions.descriptionElements.multilanguageText",

    	 "descriptions.descriptionElements.*",

         "typeDesignations",

         "status",

         "combinationAuthorship",

         "exCombinationAuthorship",

         "inCombinationAuthorship",

         "basionymAuthorship",

         "exBasionymAuthorship",

         "inBasionymAuthorship",

         "nomenclaturalReference.inReference",

         "taxonBases.taxonNodes",

         "relationsFromThisName",

         "relationsToThisName",

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

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

    	 return nameBasePropertyPaths;

    }

}