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.cdm.persistence.dao.hibernate.common;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.hibernate.Criteria;

import org.hibernate.HibernateException;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.criterion.Criterion;

import org.hibernate.criterion.Order;

import org.hibernate.criterion.Restrictions;

import org.hibernate.engine.spi.SessionFactoryImplementor;

import org.hibernate.internal.SessionImpl;

import org.hibernate.metadata.ClassMetadata;

import org.hibernate.sql.JoinType;

import org.hibernate.type.BooleanType;

import org.hibernate.type.CollectionType;

import org.hibernate.type.ComponentType;

import org.hibernate.type.DoubleType;

import org.hibernate.type.EntityType;

import org.hibernate.type.EnumType;

import org.hibernate.type.FloatType;

import org.hibernate.type.ForeignKeyDirection;

import org.hibernate.type.IntegerType;

import org.hibernate.type.LongType;

import org.hibernate.type.MaterializedClobType;

import org.hibernate.type.OneToOneType;

import org.hibernate.type.SerializableType;

import org.hibernate.type.StringType;

import org.hibernate.type.Type;

import org.jadira.usertype.dateandtime.joda.PersistentDateTime;

import org.springframework.dao.DataAccessException;

import org.springframework.stereotype.Repository;

import org.springframework.util.ReflectionUtils;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.common.DoubleResult;

import eu.etaxonomy.cdm.database.data.FullCoverageDataGenerator;

import eu.etaxonomy.cdm.hibernate.BigDecimalUserType;

import eu.etaxonomy.cdm.hibernate.DOIUserType;

import eu.etaxonomy.cdm.hibernate.EnumSetUserType;

import eu.etaxonomy.cdm.hibernate.EnumUserType;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.hibernate.OrcidUserType;

import eu.etaxonomy.cdm.hibernate.PartialUserType;

import eu.etaxonomy.cdm.hibernate.SeverityUserType;

import eu.etaxonomy.cdm.hibernate.ShiftUserType;

import eu.etaxonomy.cdm.hibernate.URIUserType;

import eu.etaxonomy.cdm.hibernate.UUIDUserType;

import eu.etaxonomy.cdm.hibernate.WSDLDefinitionUserType;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.IdentifiableEntity;

import eu.etaxonomy.cdm.model.metadata.CdmMetaData;

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

import eu.etaxonomy.cdm.persistence.dto.ReferencingObjectDto;

import eu.etaxonomy.cdm.strategy.match.CacheMatcher;

import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy;

import eu.etaxonomy.cdm.strategy.match.FieldMatcher;

import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;

import eu.etaxonomy.cdm.strategy.match.IMatchable;

import eu.etaxonomy.cdm.strategy.match.MatchException;

import eu.etaxonomy.cdm.strategy.match.MatchMode;

import eu.etaxonomy.cdm.strategy.match.Matching;

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

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

@Repository

public class CdmGenericDaoImpl

         extends CdmEntityDaoBase<CdmBase>

         implements ICdmGenericDao{

    private static final Logger logger = Logger.getLogger(CdmGenericDaoImpl.class);

	private Set<Class<? extends CdmBase>> allCdmClasses = null;

	private final Map<Class<? extends CdmBase>, Set<ReferenceHolder>> referenceMap = new HashMap<>();

	protected class ReferenceHolder{

		String propertyName;

		Class<? extends CdmBase> otherClass;

		Class<?> itemClass;

		Class<?> targetClass;  //new as item class is used for isCollection we have a duplicate here

		public boolean isCollection(){return itemClass != null;}

		@Override

        public String toString(){return otherClass.getSimpleName() + "." + propertyName ;}

	}

	public CdmGenericDaoImpl() {

		super(CdmBase.class);

	}

//    @Override

    private List<ReferencingObjectDto> getCdmBasesByFieldAndClassDto(Class<? extends CdmBase> clazz, String propertyName,

            CdmBase referencedCdmBase, Integer limit){

        Query query = getSession().createQuery("SELECT new eu.etaxonomy.cdm.persistence.dto.ReferencingObjectDto(this.uuid, this.id) "

                    + "FROM "+ clazz.getSimpleName() + " this "

                    + "WHERE this." + propertyName +" = :referencedObject")

                .setEntity("referencedObject", referencedCdmBase);

        if (limit != null){

            query.setMaxResults(limit);

        }

        @SuppressWarnings("unchecked")

        List<ReferencingObjectDto> result = query.list();

        result.forEach(dto->dto.setType((Class<CdmBase>)clazz));

        return result;

    }

	@Override

    public List<CdmBase> getCdmBasesByFieldAndClass(Class<? extends CdmBase> clazz, String propertyName, CdmBase referencedCdmBase, Integer limit){

        Session session = super.getSession();

      Criteria criteria = session.createCriteria(clazz);

      criteria.add(Restrictions.eq(propertyName, referencedCdmBase));

      if (limit != null){

          criteria.setMaxResults(limit);

      }

        @SuppressWarnings("unchecked")

        List<CdmBase> result = criteria.list();

        return result;

	}

	@Override

    public long getCountByFieldAndClass(Class<? extends CdmBase> clazz, String propertyName, CdmBase referencedCdmBase){

        Query query = getSession().createQuery("SELECT count(this) "

                + "FROM "+ clazz.getSimpleName() + " this "

                + "WHERE this." + propertyName +" = :referencedObject")

                .setEntity("referencedObject", referencedCdmBase);

        long result =(Long)query.uniqueResult();

        return result;

    }

    @Override

    public List<ReferencingObjectDto> getCdmBasesWithItemInCollectionDto(Class<?> itemClass,

            Class<? extends CdmBase> clazz, String propertyName, CdmBase item, Integer limit){

        String queryStr = withItemInCollectionHql(itemClass, clazz, propertyName,

                "new eu.etaxonomy.cdm.persistence.dto.ReferencingObjectDto(other.uuid, other.id)");

        Query query = getSession().createQuery(queryStr).setEntity("referencedObject", item);

        if (limit != null){

            query.setMaxResults(limit);

        }

        @SuppressWarnings("unchecked")

        List<ReferencingObjectDto> result = query.list();

        result.forEach(dto->dto.setType((Class)clazz));

        return result;

    }

	@Override

	public List<CdmBase> getCdmBasesWithItemInCollection(Class<?> itemClass,

	        Class<?> clazz, String propertyName, CdmBase item, Integer limit){

		String queryStr = withItemInCollectionHql(itemClass, clazz, propertyName, "other");

		Query query = getSession().createQuery(queryStr).setEntity("referencedObject", item);

		if (limit != null){

		    query.setMaxResults(limit);

		}

		@SuppressWarnings("unchecked")

		List<CdmBase> result = query.list();

		return result;

	}

    private String withItemInCollectionHql(Class<?> itemClass, Class<?> clazz, String propertyName, String select) {

        String thisClassStr = itemClass.getSimpleName();

        String otherClassStr = clazz.getSimpleName();

        String result =  "SELECT "+select+" FROM "+ thisClassStr + " this, " + otherClassStr + " other " +

                " WHERE this = :referencedObject AND this member of other." + propertyName ;

        return result;

    }

    @Override

    public long getCountWithItemInCollection(Class<?> itemClass, Class<?> clazz, String propertyName,

            CdmBase item){

        String queryStr = withItemInCollectionHql(itemClass, clazz, propertyName, "count(this)");

        Query query = getSession().createQuery(queryStr).setEntity("referencedObject", item);

        long result =(Long)query.uniqueResult();

        return result;

    }

	@Override

	public Set<Class<? extends CdmBase>> getAllPersistedClasses(boolean includeAbstractClasses){

		Set<Class<? extends CdmBase>> result = new HashSet<>();

		SessionFactory sessionFactory = getSession().getSessionFactory();

		Map<String,?> allClassMetadata = sessionFactory.getAllClassMetadata();

		Collection<String> keys = allClassMetadata.keySet();

		for (String strKey : keys){

			if (! strKey.endsWith("_AUD") && !strKey.endsWith("_AUD1")){

				try {

                    Class<?> clazz = Class.forName(strKey);

					boolean isAbstractClass = Modifier.isAbstract(clazz.getModifiers());

					if (! isAbstractClass || includeAbstractClasses){

						result.add((Class)clazz);

					}

				} catch (ClassNotFoundException e) {

				    String message = "Persisted CDM class not found: " + strKey;

				    logger.warn(message);

				    //TODO better throw exception, but currently some keys are really not found yet

//					throw new RuntimeException("Persisted CDM class not found: " + strKey,e);

				}

			}

		}

		return result;

	}

    @Override

    public Set<ReferencingObjectDto> getReferencingObjectsDto(CdmBase referencedCdmBase){

        Set<ReferencingObjectDto> result = new HashSet<>();

        if (referencedCdmBase == null) {

            return null;

        }

        try {

            referencedCdmBase = HibernateProxyHelper.deproxy(referencedCdmBase);

            Class<? extends CdmBase> referencedClass = referencedCdmBase.getClass();

            Set<ReferenceHolder> holderSet = getOrMakeHolderSet(referencedClass);

            for (ReferenceHolder refHolder: holderSet){

                handleReferenceHolderDto(referencedCdmBase, result, refHolder, false);

            }

            return result;

        } catch (Exception e) {

            e.printStackTrace();

            throw new RuntimeException(e);

        }

    }

	@Override

	public Set<CdmBase> getReferencingObjects(CdmBase referencedCdmBase){

		Set<CdmBase> result = new HashSet<>();

		if (referencedCdmBase == null) {

			return null;

		}

		try {

			referencedCdmBase = HibernateProxyHelper.deproxy(referencedCdmBase);

			Class<? extends CdmBase> referencedClass = referencedCdmBase.getClass();

			Set<ReferenceHolder> holderSet = getOrMakeHolderSet(referencedClass);

			//Integer count = getReferencingObjectsCount(referencedCdmBase);

			for (ReferenceHolder refHolder: holderSet){

//			    if (count > 100000) {

//                    handleReferenceHolder(referencedCdmBase, result, refHolder, true);

//                }else{

                    handleReferenceHolder(referencedCdmBase, result, refHolder, false);

//                }

			}

			return result;

		} catch (Exception e) {

			e.printStackTrace();

			throw new RuntimeException(e);

		}

	}

	@Override

    public long getReferencingObjectsCount(CdmBase referencedCdmBase){

        long result = 0;

        if (referencedCdmBase == null) {

            return 0;

        }

        try {

            referencedCdmBase = HibernateProxyHelper.deproxy(referencedCdmBase);

            Class<? extends CdmBase> referencedClass = referencedCdmBase.getClass();

            Set<ReferenceHolder> holderSet = getOrMakeHolderSet(referencedClass);

            for (ReferenceHolder refHolder: holderSet){

                result =+ handleReferenceHolderForCount(referencedCdmBase, result, refHolder);

            }

            return result;

        } catch (Exception e) {

            e.printStackTrace();

            throw new RuntimeException(e);

        }

    }

	protected Set<ReferenceHolder> getOrMakeHolderSet(

			Class<? extends CdmBase> referencedClass)

			throws ClassNotFoundException, NoSuchFieldException {

		Set<ReferenceHolder> holderSet = referenceMap.get(referencedClass);

		if (holderSet == null){

			holderSet = makeHolderSet(referencedClass);

			referenceMap.put(referencedClass, holderSet);

		}

		return holderSet;

	}

	@Override

	public Set<CdmBase> getReferencingObjectsForDeletion(CdmBase referencedCdmBase){

	    if (referencedCdmBase == null){

	        return null;

	    }

		Set<CdmBase> result = getReferencingObjects(referencedCdmBase);

		Set<ReferenceHolder> holderSet = referenceMap.get(IdentifiableEntity.class);

		try {

			if (holderSet == null){

				holderSet = makeHolderSet(IdentifiableEntity.class);

				referenceMap.put(IdentifiableEntity.class, holderSet);

			}

			Set<CdmBase> resultIdentifiableEntity = new HashSet<>();

			for (ReferenceHolder refHolder: holderSet){

				handleReferenceHolder(referencedCdmBase, resultIdentifiableEntity, refHolder, false);

			}

			result.removeAll(resultIdentifiableEntity);

			return result;

		} catch (Exception e) {

			e.printStackTrace();

			throw new RuntimeException(e);

		}

	}

    private void handleReferenceHolderDto(CdmBase referencedCdmBase,

            Set<ReferencingObjectDto> result, ReferenceHolder refHolder, boolean limited) {

        boolean isCollection = refHolder.isCollection();

        if (isCollection){

            if (limited){

                result.addAll(getCdmBasesWithItemInCollectionDto(refHolder.itemClass, refHolder.otherClass, refHolder.propertyName, referencedCdmBase, 100));

            }else{

                result.addAll(getCdmBasesWithItemInCollectionDto(refHolder.itemClass, refHolder.otherClass, refHolder.propertyName, referencedCdmBase, null));

            }

        }else{

            if (limited){

                result.addAll(getCdmBasesByFieldAndClassDto(refHolder.otherClass, refHolder.propertyName, referencedCdmBase, 100));

            }else{

                result.addAll(getCdmBasesByFieldAndClassDto(refHolder.otherClass, refHolder.propertyName, referencedCdmBase, null));

            }

        }

    }

	private void handleReferenceHolder(CdmBase referencedCdmBase,

			Set<CdmBase> result, ReferenceHolder refHolder, boolean limited) {

	    boolean isCollection = refHolder.isCollection();

		if (isCollection){

		    if (limited){

		        result.addAll(getCdmBasesWithItemInCollection(refHolder.itemClass, refHolder.otherClass, refHolder.propertyName, referencedCdmBase, 100));

		    }else{

		        result.addAll(getCdmBasesWithItemInCollection(refHolder.itemClass, refHolder.otherClass, refHolder.propertyName, referencedCdmBase, null));

		    }

		}else{

		    if (limited){

		        result.addAll(getCdmBasesByFieldAndClass(refHolder.otherClass, refHolder.propertyName, referencedCdmBase, 100));

		    }else{

		        result.addAll(getCdmBasesByFieldAndClass(refHolder.otherClass, refHolder.propertyName, referencedCdmBase, null));

		    }

		}

	}

    private Long handleReferenceHolderForCount(CdmBase referencedCdmBase,

            Long result, ReferenceHolder refHolder) {

        boolean isCollection = refHolder.isCollection();

        if (isCollection){

            result += getCountWithItemInCollection(refHolder.itemClass, refHolder.otherClass, refHolder.propertyName, referencedCdmBase);

        }else{

            result += getCountByFieldAndClass(refHolder.otherClass, refHolder.propertyName, referencedCdmBase);

        }

        return result;

    }

	/**

	 * @param referencedClass

	 * @return

	 * @throws NoSuchFieldException

	 * @throws ClassNotFoundException

	 */

	protected Set<ReferenceHolder> makeHolderSet(Class<?> referencedClass) throws ClassNotFoundException, NoSuchFieldException {

		Set<ReferenceHolder> result = new HashSet<>();

		//init

		if (allCdmClasses == null){

			allCdmClasses = getAllPersistedClasses(false); //findAllCdmClasses();

		}

		SessionFactory sessionFactory = getSession().getSessionFactory();

		for (Class<? extends CdmBase> cdmClass : allCdmClasses){

			ClassMetadata classMetadata = sessionFactory.getClassMetadata(cdmClass);

			Type[] propertyTypes = classMetadata.getPropertyTypes();

			int propertyNr = 0;

			for (Type propertyType: propertyTypes){

				String propertyName = classMetadata.getPropertyNames()[propertyNr];

				makePropertyType(result, referencedClass, sessionFactory, cdmClass, propertyType, propertyName, false);

				propertyNr++;

			}

		}

		return result;

	}

	private void makePropertyType(

//			CdmBase referencedCdmBase,

			Set<ReferenceHolder> result,

			Class<?> referencedClass,

			SessionFactory sessionFactory, Class<? extends CdmBase> cdmClass,

			Type propertyType, String propertyName, boolean isCollection)

				throws ClassNotFoundException, NoSuchFieldException {

		if (propertyType.isEntityType()){

			EntityType entityType = (EntityType)propertyType;

			String associatedEntityName = entityType.getAssociatedEntityName();

			Class<?> entityClass = Class.forName(associatedEntityName);

			if (entityClass.isInterface()){

			    logger.debug("There is an interface");

			}

			if (entityType instanceof OneToOneType){

			    OneToOneType oneToOneType = (OneToOneType)entityType;

			    ForeignKeyDirection direction = oneToOneType.getForeignKeyDirection();

			    if (direction == ForeignKeyDirection.TO_PARENT){  //this

			        return;

			    }

			}

			if (entityClass.isAssignableFrom(referencedClass)){

			    makeSingleProperty(referencedClass, entityClass, propertyName, cdmClass, result, isCollection);

			}

		}else if (propertyType.isCollectionType()){

			CollectionType collectionType = (CollectionType)propertyType;

			//String role = collectionType.getRole();

			Type elType = collectionType.getElementType((SessionFactoryImplementor)sessionFactory);

			makePropertyType(result, referencedClass, sessionFactory, cdmClass, elType, propertyName, true);

		}else if (propertyType.isAnyType()){

//			AnyType anyType = (AnyType)propertyType;

			Field field = cdmClass.getDeclaredField(propertyName);

			Class<?> returnType = field.getType();

			if (returnType.isInterface()){

				logger.debug("There is an interface");

			}

			if (returnType.isAssignableFrom(referencedClass)){

				makeSingleProperty(referencedClass, returnType, propertyName, cdmClass, result, isCollection);

			}

		}else if (propertyType.isComponentType()){

			ComponentType componentType = (ComponentType)propertyType;

			Type[] subTypes = componentType.getSubtypes();

//			Field field = cdmClass.getDeclaredField(propertyName);

//			Class returnType = field.getType();

			int propertyNr = 0;

			for (Type subType: subTypes){

				String subPropertyName = componentType.getPropertyNames()[propertyNr];

				if (!isNoDoType(subType)){

					logger.warn("SubType not yet handled: " + subType);

				}

//				handlePropertyType(referencedCdmBase, result, referencedClass,

//						sessionFactory, cdmClass, subType, subPropertyName, isCollection);

				propertyNr++;

			}

		}else if (isNoDoType(propertyType)){

			//do nothing

		}else{

			logger.warn("propertyType not yet handled: " + propertyType.getName());

		}

		//OLD:

				//		if (! type.isInterface()){

		//		if (referencedClass.isAssignableFrom(type)||

		//				type.isAssignableFrom(referencedClass) && CdmBase.class.isAssignableFrom(type)){

		//			handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false);

		//		}

		//	//interface

		//	}else if (type.isAssignableFrom(referencedClass)){

		//			handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false);

	}

	private boolean makeSingleProperty(Class<?> itemClass, Class<?> type, String propertyName, Class<? extends CdmBase> cdmClass, Set<ReferenceHolder> result,/*CdmBase item,*/ boolean isCollection){

//			String fieldName = StringUtils.rightPad(propertyName, 30);

//			String className = StringUtils.rightPad(cdmClass.getSimpleName(), 30);

//			String returnTypeName = StringUtils.rightPad(type.getSimpleName(), 30);

//			logger.debug(fieldName +   "\t\t" + className + "\t\t" + returnTypeName);

			ReferenceHolder refHolder = new ReferenceHolder();

			refHolder.propertyName = propertyName;

			refHolder.otherClass = cdmClass;

			refHolder.itemClass = (isCollection ? itemClass : null) ;

			refHolder.targetClass = type ;

			result.add(refHolder);

		return true;

	}

	protected static boolean isNoDoType(Type propertyType) {

		boolean result = false;

		Class<?>[] classes = new Class[]{

				PersistentDateTime.class,

				WSDLDefinitionUserType.class,

				UUIDUserType.class,

				PartialUserType.class,

				StringType.class,

				BooleanType.class,

				IntegerType.class,

				MaterializedClobType.class,

				LongType.class,

				FloatType.class,

				SerializableType.class,

				DoubleType.class,

				URIUserType.class,

				EnumType.class,

				EnumUserType.class,

				DOIUserType.class,

				OrcidUserType.class,

				ShiftUserType.class,

				EnumSetUserType.class,

				SeverityUserType.class,

				BigDecimalUserType.class,

				};

		Set<String> classNames = new HashSet<>();

		for (Class<?> clazz: classes){

			classNames.add(clazz.getCanonicalName());

			if (clazz == propertyType.getClass()){

				return true;

			}

		}

		String propertyTypeClassName = propertyType.getName();

		if (classNames.contains(propertyTypeClassName)){

			return true;

		}

		return result;

	}

	@Override

	public List<CdmBase> getHqlResult(String hqlQuery, Object[] params){

		Query query = getSession().createQuery(hqlQuery);

		for(int i = 0; i<params.length; i++){

		    query.setParameter(String.valueOf(i), params[i]);  //for some reason using int, not String, throws exceptions, this seems to be a hibernate bug

		}

		@SuppressWarnings("unchecked")

        List<CdmBase> result = query.list();

		return result;

	}

	@Override

	public Query getHqlQuery(String hqlQuery){

		Query query = getSession().createQuery(hqlQuery);

		return query;

	}

	@Override

	public <T extends CdmBase> void   merge(T cdmBase1, T cdmBase2, IMergeStrategy mergeStrategy) throws MergeException {

		SessionImpl session = (SessionImpl) getSession();

		DeduplicationHelper helper = new DeduplicationHelper(session, this);

		helper.merge(cdmBase1, cdmBase2, mergeStrategy);

	}

	@Override

	public <T extends CdmBase> boolean isMergeable(T cdmBase1, T cdmBase2, IMergeStrategy mergeStrategy) throws MergeException {

		SessionImpl session = (SessionImpl) getSession();

		DeduplicationHelper helper = new DeduplicationHelper(session, this);

		return helper.isMergeable(cdmBase1, cdmBase2, mergeStrategy);

	}

	@Override

	public <T extends CdmBase> T find(Class<T> clazz, int id){

		Session session;

		session =  getSession();

		//session = getSession().getSessionFactory().getCurrentSession();

		T o = session.get(clazz, id);

		return o;

	}

	@Override

	public <T extends CdmBase> T find(Class<T> clazz, int id, List<String> propertyPaths){

	    Session session;

	    session =  getSession();

	    T bean = session.get(clazz, id);

	    if(bean == null){

            return bean;

        }

        defaultBeanInitializer.initialize(bean, propertyPaths);

        return bean;

	}

	@Override

    public <T extends CdmBase> T find(Class<T> clazz, UUID uuid){

	    return find(clazz, uuid, null);

	}

    @Override

    public <T extends CdmBase> T find(Class<T> clazz, UUID uuid, List<String> propertyPaths){

        Session session = getSession();

        Criteria crit = session.createCriteria(type);

        crit.add(Restrictions.eq("uuid", uuid));

        crit.addOrder(Order.desc("created"));

        @SuppressWarnings("unchecked")

        List<T> results = crit.list();

        if (results.isEmpty()){

            return null;

        }else{

            if(results.size() > 1){

                logger.error("findByUuid() delivers more than one result for UUID: " + uuid);

            }

            T result = results.get(0);

            if (result == null || propertyPaths == null){

                return result;

            }else{

                defaultBeanInitializer.initialize(result, propertyPaths);

                return result;

            }

        }

    }

	@Override

	public <T extends IMatchable> List<T> findMatching(T objectToMatch,

			IMatchStrategy matchStrategy) throws MatchException {

		getSession().flush();

		try {

			List<T> result = new ArrayList<>();

			if(objectToMatch == null){

				return result;

			}

			if (matchStrategy == null){

				matchStrategy = DefaultMatchStrategy.NewInstance(objectToMatch.getClass());

			}

			result.addAll(findMatchingNullSafe(objectToMatch, matchStrategy));

			return result;

		} catch (IllegalArgumentException e) {

			throw new MatchException(e);

		} catch (IllegalAccessException e) {

			throw new MatchException(e);

		}

	}

	private <T extends IMatchable> List<T> findMatchingNullSafe(T objectToMatch,

	        IMatchStrategy matchStrategy) throws IllegalArgumentException, IllegalAccessException, MatchException {

	    List<T> result = new ArrayList<>();

		Session session = getSession();

		Class<?> matchClass = objectToMatch.getClass();

		ClassMetadata classMetaData = session.getSessionFactory().getClassMetadata(matchClass.getCanonicalName());

		Criteria criteria = session.createCriteria(matchClass);

		boolean noMatch = makeCriteria(objectToMatch, matchStrategy, classMetaData, criteria);

		if (logger.isDebugEnabled()){logger.debug(criteria);}

		//session.flush();

		if (noMatch == false){

			@SuppressWarnings("unchecked")

            List<T> matchCandidates = criteria.list();

			matchCandidates.remove(objectToMatch);

			for (T matchCandidate : matchCandidates ){

				if (matchStrategy.invoke(objectToMatch, matchCandidate).isSuccessful()){

					result.add(matchCandidate);

				}else{

					logger.info("Match candidate did not match: " + matchCandidate);

				}

			}

		}

		return result;

	}

	private <T> boolean makeCriteria(T objectToMatch,

			IMatchStrategy matchStrategy, ClassMetadata classMetaData,

			Criteria criteria) throws IllegalAccessException, MatchException {

	    Matching matching = matchStrategy.getMatching((IMatchable)objectToMatch);

		boolean noMatch = false;

		Map<String, List<MatchMode>> replaceMatchers = new HashMap<>();

		for (CacheMatcher cacheMatcher: matching.getCacheMatchers()){

		    Field protectedField = cacheMatcher.getProtectedField(matching);

			boolean cacheProtected = protectedField == null ? false : (Boolean)protectedField.get(objectToMatch);

			if (cacheProtected == true){

				String cacheValue = (String)cacheMatcher.getField().get(objectToMatch);

				if (StringUtils.isBlank(cacheValue)){

					return true;  //no match

				}else{

					criteria.add(Restrictions.eq(cacheMatcher.getPropertyName(), cacheValue));

					criteria.add(Restrictions.eq(cacheMatcher.getProtectedPropertyName(), cacheProtected));

					List<DoubleResult<String, MatchMode>> replacementModes = cacheMatcher.getReplaceMatchModes(matching);

					for (DoubleResult<String, MatchMode> replacementMode: replacementModes ){

						String propertyName = replacementMode.getFirstResult();

						List<MatchMode> replaceMatcherList = replaceMatchers.get(propertyName);

						if (replaceMatcherList == null){

							replaceMatcherList = new ArrayList<>();

							replaceMatchers.put(propertyName, replaceMatcherList);

						}

						replaceMatcherList.add(replacementMode.getSecondResult());

					}

				}

			}

		}

		for (FieldMatcher fieldMatcher : matching.getFieldMatchers(false)){

			String propertyName = fieldMatcher.getPropertyName();

			Type propertyType = classMetaData.getPropertyType(propertyName);

			Object value = fieldMatcher.getField().get(objectToMatch);

			List<MatchMode> matchModes= new ArrayList<>();

			matchModes.add(fieldMatcher.getMatchMode());

			if (replaceMatchers.get(propertyName) != null){

				matchModes.addAll(replaceMatchers.get(propertyName));

			}

			boolean isIgnore = false;

			for (MatchMode matchMode : matchModes){

				isIgnore |= matchMode.isIgnore(value);

			}

			if (! isIgnore ){

				if (propertyType.isComponentType()){

					matchComponentType(criteria, fieldMatcher, propertyName, value, matchModes);

				}else{

					noMatch = matchNonComponentType(criteria, fieldMatcher, propertyName, value, matchModes, propertyType);

				}

			}

			if (noMatch){

				return noMatch;

			}

		}

		return noMatch;

	}

	private void matchComponentType(Criteria criteria,

			FieldMatcher fieldMatcher, String propertyName, Object value,

			List<MatchMode> matchModes) throws MatchException, IllegalAccessException {

		if (value == null){

			boolean requiresSecondNull = requiresSecondNull(matchModes, null);

			if (requiresSecondNull){

				criteria.add(Restrictions.isNull(propertyName));

			}else{

				//this should not happen, should be handled as ignore before

				logger.warn("Component type not yet implemented for (null) value: " + propertyName);

				throw new MatchException("Component type not yet fully implemented for (null) value. Property: " + propertyName);

			}

		}else{

			Class<?> componentClass = fieldMatcher.getField().getType();

			Map<String, Field> fields = CdmUtils.getAllFields(componentClass, Object.class, false, false, true, false);

			for (String fieldName : fields.keySet()){

				String restrictionPath = propertyName +"."+fieldName;

				Object componentValue = fields.get(fieldName).get(value);

				//TODO differentiate matchMode

				createCriterion(criteria, restrictionPath, componentValue, matchModes);

			}

		}

	}

    private boolean matchNonComponentType(Criteria criteria,

			FieldMatcher fieldMatcher,

			String propertyName,

			Object value,