EDIT

// $Id$

* Copyright (C) 2007 EDIT

* See LICENSE.TXT at the top of this package for the full license terms.

*/

import java.util.Map;

import org.apache.lucene.index.Term;

import org.apache.lucene.queryParser.ParseException;

import org.apache.lucene.search.BooleanQuery;

import org.apache.lucene.search.FuzzyLikeThisQuery;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.BooleanClause.Occur;

import org.springframework.transaction.annotation.Transactional;

import eu.etaxonomy.cdm.api.service.search.LuceneSearch;

import eu.etaxonomy.cdm.api.service.search.QueryFactory;

import eu.etaxonomy.cdm.api.service.search.SearchResult;

import eu.etaxonomy.cdm.api.service.search.SearchResultBuilder;

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

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

import eu.etaxonomy.cdm.persistence.dao.common.ICdmGenericDao;

@Service

    @Autowired

    protected ITermVocabularyDao vocabularyDao;

    @Autowired

    protected IOrderedTermVocabularyDao orderedVocabularyDao;

    @Autowired

    @Qualifier("refEntDao")

    private INomenclaturalStatusDao nomStatusDao;

    @Autowired

    private ITypeDesignationDao typeDesignationDao;

    @Autowired

    private IHomotypicalGroupDao homotypicalGroupDao;

    private ICdmGenericDao genericDao;

    /**

     * Constructor

     */

    public NameServiceImpl(){

        if (logger.isDebugEnabled()) { logger.debug("Load NameService Bean"); }

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.service.ServiceBase#delete(eu.etaxonomy.cdm.model.common.CdmBase)

     */

    @Override

    public UUID delete(TaxonNameBase name){

        NameDeletionConfigurator config = new NameDeletionConfigurator();

        try {

            return delete(name, config);

        } catch (ReferencedObjectUndeletableException e) {

            //TODO throw DeleteException - current implementation is preliminary for testing

            throw new RuntimeException(e);

        }

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.service.INameService#delete(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.api.service.NameDeletionConfigurator)

     */

    @Override

    public UUID delete(TaxonNameBase name, NameDeletionConfigurator config) throws ReferencedObjectUndeletableException{

        if (name == null){

            return null;

        }

        //remove references to this name

        removeNameRelationshipsByDeleteConfig(name, config);

        //check if this name is still used somewhere

        //name relationships

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

            String message = "Name can't be deleted as it is used in name relationship(s). Remove name relationships prior to deletion.";

            throw new ReferencedObjectUndeletableException(message);

        //concepts

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

            String message = "Name can't be deleted as it is used in concept(s). Remove or change concept prior to deletion.";

            throw new ReferencedObjectUndeletableException(message);

        }

        //hybrid relationships

        if (name.isInstanceOf(NonViralName.class)){

            NonViralName nvn = CdmBase.deproxy(name, NonViralName.class);

//				String message = "Name can't be deleted as it is a child in (a) hybrid relationship(s). Remove hybrid relationships prior to deletion.";

//				throw new RuntimeException(message);

//			}

                String message = "Name can't be deleted as it is a parent in (a) hybrid relationship(s). Remove hybrid relationships prior to deletion.";

                throw new ReferencedObjectUndeletableException(message);

            }

        }

        //all type designation relationships are removed as they belong to the name

        deleteTypeDesignation(name, null);

//		if (! name.getTypeDesignations().isEmpty()){

//			String message = "Name can't be deleted as it has types. Remove types prior to deletion.";

        Set<CdmBase> referencingObjects = genericDao.getReferencingObjects(name);

        for (CdmBase referencingObject : referencingObjects){

            //DerivedUnitBase?.storedUnder

            if (referencingObject.isInstanceOf(DerivedUnitBase.class)){

                String message = "Name can't be deleted as it is used as derivedUnit#storedUnder by %s. Remove 'stored under' prior to deleting this name";

                message = String.format(message, CdmBase.deproxy(referencingObject, DerivedUnitBase.class).getTitleCache());

                throw new ReferencedObjectUndeletableException(message);

            }

            //DescriptionElementSource#nameUsedInSource

            if (referencingObject.isInstanceOf(DescriptionElementSource.class)){

                String message = "Name can't be deleted as it is used as descriptionElementSource#nameUsedInSource";

                throw new ReferencedObjectUndeletableException(message);

            }

            //NameTypeDesignation#typeName

            if (referencingObject.isInstanceOf(NameTypeDesignation.class)){

                String message = "Name can't be deleted as it is used as a name type in a NameTypeDesignation";

                throw new ReferencedObjectUndeletableException(message);

            }

            //TaxonNameDescriptions#taxonName

            //deleted via cascade?

            //NomenclaturalStatus

            //deleted via cascade?

        }

        //TODO inline references

        dao.delete(name);

        return name.getUuid();

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.service.INameService#deleteTypeDesignation(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.name.TypeDesignationBase)

     */

    @Override

    public void deleteTypeDesignation(TaxonNameBase name, TypeDesignationBase typeDesignation){

        if (name == null && typeDesignation == null){

            return;

        }else if (name != null && typeDesignation != null){

            removeSingleDesignation(name, typeDesignation);

        }else if (name != null){

            Set<TypeDesignationBase> designationSet = new HashSet<TypeDesignationBase>(name.getTypeDesignations());

            for (Object o : designationSet){

                TypeDesignationBase desig = CdmBase.deproxy(o, TypeDesignationBase.class);

                removeSingleDesignation(name, desig);

            }

        }else if (typeDesignation != null){

            Set<TaxonNameBase> nameSet = new HashSet<TaxonNameBase>(typeDesignation.getTypifiedNames());

            for (Object o : nameSet){

                TaxonNameBase singleName = CdmBase.deproxy(o, TaxonNameBase.class);

                removeSingleDesignation(singleName, typeDesignation);

            }

        }

    }

    /**

     * @param name

     * @param typeDesignation

     */

    private void removeSingleDesignation(TaxonNameBase name, TypeDesignationBase typeDesignation) {

        name.removeTypeDesignation(typeDesignation);

        if (typeDesignation.getTypifiedNames().isEmpty()){

            typeDesignation.removeType();

            typeDesignationDao.delete(typeDesignation);

        }

    }

    /**

     * @param name

     * @param config

     */

    private void removeNameRelationshipsByDeleteConfig(TaxonNameBase name, NameDeletionConfigurator config) {

        if (config.isRemoveAllNameRelationships()){

            Set<NameRelationship> rels = name.getNameRelations();

            for (NameRelationship rel : rels){

                name.removeNameRelationship(rel);

            }

        }else{

            //relations to this name

            Set<NameRelationship> rels = name.getRelationsToThisName();

            for (NameRelationship rel : rels){

                if (config.isIgnoreHasBasionym() && NameRelationshipType.BASIONYM().equals(rel.getType() )){

                        name.removeNameRelationship(rel);

                }else if (config.isIgnoreHasReplacedSynonym() && NameRelationshipType.REPLACED_SYNONYM().equals(rel.getType())){

                    name.removeNameRelationship(rel);

                }

            }

            //relations from this name

            rels = name.getRelationsFromThisName();

            for (NameRelationship rel : rels){

                if (config.isIgnoreIsBasionymFor() && NameRelationshipType.BASIONYM().equals(rel.getType())  ){

                    name.removeNameRelationship(rel);

                }else if (config.isIgnoreIsReplacedSynonymFor() && NameRelationshipType.REPLACED_SYNONYM().equals(rel.getType())){

                    name.removeNameRelationship(rel);

                }

            }

        }

    }

//********************* METHODS ****************************************************************//

    /**

     * @deprecated To be removed for harmonization see http://dev.e-taxonomy.eu/trac/wiki/CdmLibraryConventions

        return super.findCdmObjectsByTitle(name);

    }

     * new name findByName

        List result = dao.findByName(nameCache, MatchMode.EXACT, null, null, null, null);

        return result;

    }

    /**

     * new name saveHomotypicalGroups

     *

     * findByTitle

        List result = dao.findByTitle(titleCache, matchMode, null, null, null ,propertyPaths);

        return result;

    }

     * TODO candidate for harmonization

     * new name saveHomotypicalGroups

     *

     * findByTitle

     */

        List result = dao.findByName(nameCache, matchMode, null, null, null ,propertyPaths);

        return result;

    }

    /**

     * @deprecated To be removed for harmonization see http://dev.e-taxonomy.eu/trac/wiki/CdmLibraryConventions

        return super.findCdmObjectsByTitle(name, sessionObject);

    }

     * @deprecated To be removed for harmonization see http://dev.e-taxonomy.eu/trac/wiki/CdmLibraryConventions

     * duplicate of findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths)

     */

        return super.findCdmObjectsByTitle(title);

    }

     * @deprecated To be removed for harmonization see http://dev.e-taxonomy.eu/trac/wiki/CdmLibraryConventions

        return super.findCdmObjectsByTitle(title, sessionObject);

    }

     * TODO candidate for harmonization

     * new name saveHomotypicalGroups

     */

    public Map<UUID, HomotypicalGroup> saveAllHomotypicalGroups(Collection<HomotypicalGroup> homotypicalGroups){

        return homotypicalGroupDao.saveAll(homotypicalGroups);

    }

     * TODO candidate for harmonization

     * new name saveTypeDesignations

     */

    public Map<UUID, TypeDesignationBase> saveTypeDesignationAll(Collection<TypeDesignationBase> typeDesignationCollection){

        return typeDesignationDao.saveAll(typeDesignationCollection);

    }

     * TODO candidate for harmonization

     * new name saveReferencedEntities

     */

    public Map<UUID, ReferencedEntityBase> saveReferencedEntitiesAll(Collection<ReferencedEntityBase> referencedEntityCollection){

        return referencedEntityDao.saveAll(referencedEntityCollection);

    }

     * TODO candidate for harmonization

     * new name getNames

     */

        return dao.list(limit, start);

    }

     * TODO candidate for harmonization

     * new name getNomenclaturalStatus

     */

        return nomStatusDao.list(limit, start);

    }

     * TODO candidate for harmonization

     * new name getTypeDesignations

     */

        return typeDesignationDao.getAllTypeDesignations(limit, start);

    }

      /**

     * FIXME Candidate for harmonization

     * homotypicalGroupService.list

     */

        return homotypicalGroupDao.list(limit, start);

    }

    /**

     * FIXME Candidate for harmonization

     * remove

     */

    public List<RelationshipBase> getAllRelationships(int limit, int start){

    /**

     * FIXME Candidate for harmonization

     * since this returns OrderedTermVocabulary

     *

     * @see eu.etaxonomy.cdm.api.service.INameService#getRankVocabulary()

     */

        String uuidString = "ef0d1ce1-26e3-4e83-b47b-ca74eed40b1b";

        UUID uuid = UUID.fromString(uuidString);

        OrderedTermVocabulary<Rank> rankVocabulary =

            (OrderedTermVocabulary)orderedVocabularyDao.findByUuid(uuid);

        return rankVocabulary;

    }

    /**

      * FIXME Candidate for harmonization

     * is this the same as termService.getVocabulary(VocabularyEnum.NameRelationshipType)

     *  (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.service.INameService#getNameRelationshipTypeVocabulary()

     */

        String uuidString = "6878cb82-c1a4-4613-b012-7e73b413c8cd";

        UUID uuid = UUID.fromString(uuidString);

        TermVocabulary<NameRelationshipType> nameRelTypeVocabulary =

    }

    /**

      * FIXME Candidate for harmonization

     * is this the same as termService.getVocabulary(VocabularyEnum.StatusType)

     * (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.service.INameService#getStatusTypeVocabulary()

     */

        String uuidString = "bb28cdca-2f8a-4f11-9c21-517e9ae87f1f";

        UUID uuid = UUID.fromString(uuidString);

        TermVocabulary<NomenclaturalStatusType> nomStatusTypeVocabulary =

    }

    /**

      * FIXME Candidate for harmonization

     * is this the same as termService.getVocabulary(VocabularyEnum.SpecimenTypeDesignationStatus)

     *  (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.service.INameService#getTypeDesignationStatusVocabulary()

     */

        String uuidString = "ab177bd7-d3c8-4e58-a388-226fff6ba3c2";

        UUID uuid = UUID.fromString(uuidString);

        TermVocabulary<SpecimenTypeDesignationStatus> typeDesigStatusVocabulary =

    }

    /**

       * FIXME Candidate for harmonization

     * is this the same as termService.getVocabulary(VocabularyEnum.SpecimenTypeDesignationStatus)

     * and also seems to duplicate the above method, differing only in the DAO used and the return type

     * (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.service.INameService#getTypeDesignationStatusVocabulary()

     */

        String uuidString = "ab177bd7-d3c8-4e58-a388-226fff6ba3c2";

        UUID uuid = UUID.fromString(uuidString);

        OrderedTermVocabulary<SpecimenTypeDesignationStatus> typeDesignationVocabulary =

            (OrderedTermVocabulary)orderedVocabularyDao.findByUuid(uuid);

        return typeDesignationVocabulary;

    }

    protected void setDao(ITaxonNameDao dao) {

        this.dao = dao;

    }

        List<HybridRelationship> results = new ArrayList<HybridRelationship>();

        if(AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)) { // no point checking again

            results = dao.getHybridNames(name, type, pageSize, pageNumber,orderHints,propertyPaths);

        }

        return new DefaultPagerImpl<HybridRelationship>(pageNumber, numberOfResults, pageSize, results);

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.service.INameService#listNameRelationships(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.common.RelationshipBase.Direction, eu.etaxonomy.cdm.model.name.NameRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)

     */

    @Override

    public List<NameRelationship> listNameRelationships(TaxonNameBase name,	Direction direction, NameRelationshipType type, Integer pageSize,

            Integer pageNumber, List<OrderHint> orderHints,	List<String> propertyPaths) {

        Integer numberOfResults = dao.countNameRelationships(name, NameRelationship.Direction.relatedFrom, type);

        List<NameRelationship> results = new ArrayList<NameRelationship>();

        if (AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)) { // no point checking again

            results = dao.getNameRelationships(name, direction, type, pageSize,	pageNumber, orderHints, propertyPaths);

        }

        return results;

    }

    protected LuceneSearch prepareFindByFuzzyNameSearch(Class<? extends CdmBase> clazz, 

    		float accuracy,

    		List<Language> languages,

    	String similarity = Float.toString(accuracy);    	

    	String searchSuffix = "~" + similarity;

    	BooleanQuery finalQuery = new BooleanQuery();

    	BooleanQuery textQuery = new BooleanQuery();

    	LuceneSearch luceneSearch = new LuceneSearch(getSession(), TaxonNameBase.class);    	   

    	QueryFactory queryFactory = new QueryFactory(luceneSearch);

    	SortField[] sortFields = new  SortField[]{SortField.FIELD_SCORE, new SortField("titleCache__sort", SortField.STRING,  false)};

    	luceneSearch.setSortFields(sortFields);

    	// ---- search criteria

    	luceneSearch.setClazz(clazz);

    	if(nvn.getGenusOrUninomial() != null && !nvn.getGenusOrUninomial().equals("")) {        	

    		textQuery.add(queryFactory.newTermQuery("genusOrUninomial", nvn.getGenusOrUninomial() + searchSuffix), Occur.SHOULD);

    	} else {

    		textQuery.add(new RegexQuery (new Term ("genusOrUninomial", "^[a-zA-Z]*")), Occur.MUST_NOT);

    	}

    	if(nvn.getInfraGenericEpithet() != null && !nvn.getInfraGenericEpithet().equals("")){

    		textQuery.add(queryFactory.newTermQuery("infraGenericEpithet", nvn.getInfraGenericEpithet() + searchSuffix), Occur.SHOULD);

    	} else {

    		textQuery.add(new RegexQuery (new Term ("infraGenericEpithet", "^[a-zA-Z]*")), Occur.MUST_NOT);

    	}

    	if(nvn.getSpecificEpithet() != null && !nvn.getSpecificEpithet().equals("")){

    		textQuery.add(queryFactory.newTermQuery("specificEpithet", nvn.getSpecificEpithet() + searchSuffix), Occur.SHOULD);  

    	} else {

    		textQuery.add(new RegexQuery (new Term ("specificEpithet", "^[a-zA-Z]*")), Occur.MUST_NOT);

    	}

    	if(nvn.getInfraSpecificEpithet() != null && !nvn.getInfraSpecificEpithet().equals("")){

    		textQuery.add(queryFactory.newTermQuery("infraSpecificEpithet", nvn.getInfraSpecificEpithet() + searchSuffix), Occur.SHOULD);

    	} else {

    		textQuery.add(new RegexQuery (new Term ("infraSpecificEpithet", "^[a-zA-Z]*")), Occur.MUST_NOT);

    	}

    	if(nvn.getAuthorshipCache() != null && !nvn.getAuthorshipCache().equals("")){

    		textQuery.add(queryFactory.newTermQuery("authorshipCache", nvn.getAuthorshipCache() + searchSuffix), Occur.SHOULD);

    	} else {

    		//textQuery.add(new RegexQuery (new Term ("authorshipCache", "^[a-zA-Z]*")), Occur.MUST_NOT);

    	}

    	finalQuery.add(textQuery, Occur.MUST);

    	luceneSearch.setQuery(finalQuery);

    	if(highlightFragments){

    		luceneSearch.setHighlightFields(queryFactory.getTextFieldNamesAsArray());

    	}

    	return luceneSearch;

    }

    protected LuceneSearch prepareFindByExactNameSearch(Class<? extends CdmBase> clazz, 

    		String name,

    		boolean wildcard,

    		List<Language> languages,

        BooleanQuery finalQuery = new BooleanQuery();

        BooleanQuery textQuery = new BooleanQuery();

        LuceneSearch luceneSearch = new LuceneSearch(getSession(), TaxonNameBase.class);

        QueryFactory queryFactory = new QueryFactory(luceneSearch);

        SortField[] sortFields = new  SortField[]{SortField.FIELD_SCORE, new SortField("titleCache__sort", SortField.STRING,  false)};

        luceneSearch.setSortFields(sortFields);

        // ---- search criteria

        luceneSearch.setClazz(clazz);

        	if(wildcard) {

        		textQuery.add(new WildcardQuery(new Term("nameCache", name + "*")), Occur.MUST);

        	} else {

        		textQuery.add(queryFactory.newTermQuery("nameCache", name, false), Occur.MUST);

        	}

        } 

        finalQuery.add(textQuery, Occur.MUST);

        if(highlightFragments){

            luceneSearch.setHighlightFields(queryFactory.getTextFieldNamesAsArray());

        }

        return luceneSearch;

    }

    public List<SearchResult<TaxonNameBase>> findByNameFuzzySearch(

            String name,

            float accuracy,

            List<Language> languages,

            boolean highlightFragments, 

            List<String> propertyPaths,

            int maxNoOfResults) throws CorruptIndexException, IOException, ParseException {

    	logger.info("Name to fuzzy search for : " + name);

    	// parse the input name

    	NonViralNameParserImpl parser = new NonViralNameParserImpl();

    	NonViralName nvn = parser.parseFullName(name);

    	if(name != null && !name.equals("") && nvn == null) {

    		throw new ParseException("Could not parse name " + name);

    	}