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

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

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

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

import eu.etaxonomy.cdm.strategy.merge.DefaultMergeStrategy;

import eu.etaxonomy.cdm.strategy.merge.IMergable;

import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;

import eu.etaxonomy.cdm.strategy.merge.MergeException;

import eu.etaxonomy.cdm.strategy.merge.MergeMode;

import eu.etaxonomy.taxeditor.annotatedlineeditor.IEntityCreator;

import eu.etaxonomy.taxeditor.bulkeditor.IBulkEditorSortProvider;

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

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

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

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author p.ciardelli

 * @created 25.06.2009

 */

public class AgentEditorInput extends AbstractBulkEditorInput<TeamOrPersonBase> {

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

	private static AgentEditorInput instance;

	private static final String PROPERTY_NOMENCLATURAL_TITLE = "Abbrev. Title Cache";

	private static final String PROPERTY_NOMENCLATURAL_TITLECACHE_PROTECTED = "Protect Abbrev. Title Cache";

	private static final String PROPERTY_FAMILY_NAME = "Family Name";

	private static final String PROPERTY_OTHER_NAME = "Other/Given Name";

	private static final String PROPERTY_INITIALS = "Initials";

	private static final String PROPERTY_TEAM_HAS_MORE_MEMBERS = "et al.";

	private static final String PROPERTY_COLLECTOR_TITLECACHE = "Collector Title Cache";

	private static final String PROPERTY_COLLECTOR_TITLECACHE_PROTECTED = "Protect Collector Title Cache";

	public static String getID() {

		return ID;

	}

	@Override

	protected List<String> getPropertyKeys_internal() {

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

	    propertyKeysInternal.add(PROPERTY_NOMENCLATURAL_TITLE);

	    propertyKeysInternal.add(PROPERTY_NOMENCLATURAL_TITLECACHE_PROTECTED);

	    propertyKeysInternal.add(PROPERTY_COLLECTOR_TITLECACHE);

        propertyKeysInternal.add(PROPERTY_COLLECTOR_TITLECACHE_PROTECTED);

	    propertyKeysInternal.add(PROPERTY_FAMILY_NAME);

	    propertyKeysInternal.add(PROPERTY_OTHER_NAME);

	    propertyKeysInternal.add(PROPERTY_INITIALS);

	    propertyKeysInternal.add(PROPERTY_TEAM_HAS_MORE_MEMBERS);

	    return propertyKeysInternal;

	}

	@Override

	public Object getPropertyValue(TeamOrPersonBase cdmBase, String property) {

	    if(property.equals(PROPERTY_NOMENCLATURAL_TITLE)){

	        return cdmBase.getNomenclaturalTitleCache();

	    }

	    else if(property.equals(PROPERTY_NOMENCLATURAL_TITLECACHE_PROTECTED) && cdmBase.isInstanceOf(Team.class)){

            return HibernateProxyHelper.deproxy(cdmBase, Team.class).isProtectedNomenclaturalTitleCache();

        }

	    else if(property.equals(PROPERTY_COLLECTOR_TITLECACHE)){

	        return HibernateProxyHelper.deproxy(cdmBase, TeamOrPersonBase.class).getCollectorTitleCache();

        }

	    else if(property.equals(PROPERTY_COLLECTOR_TITLECACHE_PROTECTED) && cdmBase.isInstanceOf(Team.class)){

            return HibernateProxyHelper.deproxy(cdmBase, Team.class).isProtectedCollectorTitleCache();

        }

	    else if(property.equals(PROPERTY_FAMILY_NAME)

	            && cdmBase.isInstanceOf(Person.class)){

	        return HibernateProxyHelper.deproxy(cdmBase, Person.class).getFamilyName();

	    }

	    else if(property.equals(PROPERTY_OTHER_NAME)

	            && cdmBase.isInstanceOf(Person.class)){

	        return HibernateProxyHelper.deproxy(cdmBase, Person.class).getGivenName();

	    }

	    else if(property.equals(PROPERTY_INITIALS)

	            && cdmBase.isInstanceOf(Person.class)){

	        return HibernateProxyHelper.deproxy(cdmBase, Person.class).getInitials();

	    }

	    else if(property.equals(PROPERTY_TEAM_HAS_MORE_MEMBERS)

	            && cdmBase.isInstanceOf(Team.class)){

	        return HibernateProxyHelper.deproxy(cdmBase, Team.class).isHasMoreMembers();

	    }

	    return super.getPropertyValue(cdmBase, property);

	}

	@Override

	public boolean isBooleanProperty(String property) {

	    if(property.equals(PROPERTY_TEAM_HAS_MORE_MEMBERS) || property.equals(PROPERTY_NOMENCLATURAL_TITLECACHE_PROTECTED)

	            || property.equals(PROPERTY_COLLECTOR_TITLECACHE_PROTECTED)){

	        return true;

	    }

	    return super.isBooleanProperty(property);

	}

	@Override

    public boolean isCacheProperty(String property) {

        if(property.equals(PROPERTY_NOMENCLATURAL_TITLECACHE_PROTECTED)

                || property.equals(PROPERTY_COLLECTOR_TITLECACHE_PROTECTED)){

            return true;

        }

        return super.isCacheProperty(property);

    }

    @Override

    public String getName() {

		return BulkEditorInputType.AGENT.label;

	}

	public static AbstractBulkEditorInput getInstance() {

		if (instance == null) {

			instance = new AgentEditorInput();

		}

		return instance;

	}

	@Override

	public boolean isMergingEnabled() {

		return true;

	}

	@Override

	public boolean isConvertingEnabled() {

		return true;

	}

	@Override

    public boolean merge(TeamOrPersonBase entity, TeamOrPersonBase mergeTarget) {

		if (entity instanceof IMergable) {

			try {

				if(entity instanceof Person && mergeTarget instanceof Person) {

				    IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(Person.class);

				    strategy.setMergeMode("institutionalMemberships", MergeMode.FIRST);

				    CdmStore.getCommonService().merge(mergeTarget.getUuid(), entity.getUuid(), Person.class);

				} else {

				    IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);

				    CdmStore.getCommonService().merge(mergeTarget.getUuid(), entity.getUuid(), TeamOrPersonBase.class);

				}

			} catch (MergeException e) {

				MessagingUtils.errorDialog("Bulk Editor Merge Error",

						this,

						"Could not merge chosen objects of type " + entity.getClass().getName(),

						TaxeditorBulkeditorPlugin.PLUGIN_ID,

						e,

						true);

			}

		}

		return true;

	}

	@Override

	protected int getPageSize() {

	    return 200;

	}

    @Override

    protected long countEntities(IIdentifiableEntityServiceConfigurator configurator) {

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

    }

	@Override

	public List<TeamOrPersonBase> listEntities(IIdentifiableEntityServiceConfigurator configurator) {

		return CdmStore.getSearchManager().findTeamOrPersons(configurator);

	}

	public boolean delete(AgentBase entity) throws ReferencedObjectUndeletableException  {

			return CdmStore.getService(IAgentService.class).delete(entity) != null;

	}

	@Override

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

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

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

		return sortProviders;

	}

	@Override

	protected IEntityCreator<TeamOrPersonBase> createEntityCreator() {

		return new AgentCreator();

	}

	@Override

	public TeamOrPersonBase save(TeamOrPersonBase entity) {

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

	}

	@Override

	public boolean delete(TeamOrPersonBase entity, DeleteConfiguratorBase config)

			throws ReferencedObjectUndeletableException {

	    if (entity.getUuid() != null){

	        return CdmStore.getService(IAgentService.class).delete(entity.getUuid()) != null;

	    }else{

	        return false;

	    }

	}

    @Override

    public void merge() {

    }

	@Override

	protected TeamOrPersonBase loadEntity(UUID entityUuid) {

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

		return HibernateProxyHelper.deproxy(CdmStore.getService(IAgentService.class).load(entityUuid, propertyPaths), TeamOrPersonBase.class);

	}

}