/**
    * Copyright 2010 The Kuali Foundation Licensed under the
    * Educational Community License, Version 2.0 (the "License"); you may
    * not use this file except in compliance with the License. You may
    * obtain a copy of the License at
    *
    * http://www.osedu.org/licenses/ECL-2.0
    *
    * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an "AS IS"
   * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
   * or implied. See the License for the specific language governing
   * permissions and limitations under the License.
   */
  
  package org.kuali.student.r2.lum.lu.dao.impl;
  
  import java.util.*;
  
  import javax.persistence.EntityManager;
  import javax.persistence.PersistenceContext;
  import javax.persistence.Query;
  
  import org.kuali.student.r1.common.dao.impl.AbstractCrudDaoImpl;
  import org.kuali.student.r2.core.versionmanagement.dto.VersionDisplayInfo;
  import org.kuali.student.r2.lum.lu.dao.LuDao;
  import org.kuali.student.r2.lum.lu.entity.Clu;
  import org.kuali.student.r2.lum.lu.entity.CluCluRelation;
  import org.kuali.student.r2.lum.lu.entity.CluLoRelation;
  import org.kuali.student.r2.lum.lu.entity.CluPublication;
  import org.kuali.student.r2.lum.lu.entity.CluResult;
  import org.kuali.student.r2.lum.lu.entity.CluResultType;
  import org.kuali.student.r2.lum.lu.entity.CluSet;
  //import org.kuali.student.r2.lum.lu.entity.Lui;
  //import org.kuali.student.r2.lum.lu.entity.LuiLuiRelation;
  
  public class LuDaoImpl extends AbstractCrudDaoImpl implements LuDao {
  
  	@PersistenceContext(unitName = "Lu")
  	@Override
  	public void setEm(EntityManager em) {
  		super.setEm(em);
  	}
  
  	@Override
  	public List<Clu> getClusByIdList(List<String> cluIdList) {
  		Query query = em.createNamedQuery("Clu.findClusByIdList");
  		query.setParameter("idList", cluIdList);
  		@SuppressWarnings("unchecked")
  		List<Clu> resultList = query.getResultList();
  		return resultList;
  	}
  
  	@Override
  	public List<Clu> getClusByLuType(String luTypeKey, String luState) {
  		Query query = em.createNamedQuery("Clu.getClusByLuType");
  		query.setParameter("luTypeKey", luTypeKey);
  		query.setParameter("luState", luState);
  		@SuppressWarnings("unchecked")
  		List<Clu> resultList = query.getResultList();
  		return resultList;
  	}
  
  	@Override
  	public List<CluSet> getCluSetInfoByIdList(List<String> cluSetIdList) {
  		Query query = em.createNamedQuery("CluSet.getCluSetInfoByIdList");
  		query.setParameter("cluSetIdList", cluSetIdList);
          @SuppressWarnings("unchecked")
  		List<CluSet> resultList = query.getResultList();
  		return resultList;
  	}
            /*
  	@Override
  	public List<Lui> getLuisByIdList(List<String> luiIds) {
  		Query query = em.createNamedQuery("Lui.getLuisByIdList");
  		query.setParameter("luiIdList", luiIds);
  		@SuppressWarnings("unchecked")
  		List<Lui> luis = query.getResultList();
  		return luis;
  	}
                     */
  	@Override
  	public List<String> getLuiIdsByCluId(String cluId) {
  		Query query = em.createNamedQuery("Lui.getLuiIdsByCluId");
  		query.setParameter("cluId", cluId);
  		@SuppressWarnings("unchecked")
  		List<String> luiIds = query.getResultList();
  		return luiIds;
  	}
                       /*
  	@Override
  	public List<Lui> getLuisByRelationType(String luiId,
  			String luLuRelationTypeId) {
  		Query query = em
  				.createNamedQuery("LuiLuiRelation.getLuisByRelationType");
  		query.setParameter("luiId", luiId);
  		query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
  
  		@SuppressWarnings("unchecked")
 		List<Lui> luis = query.getResultList();
 		return luis;
 	}
                             */
 	@Override
 	public List<String> getLuiIdsByRelationType(String relatedLuiId,
 			String luLuRelationTypeId) {
 		Query query = em
 				.createNamedQuery("LuiLuiRelation.getLuiIdsByRelationType");
 		query.setParameter("luiId", relatedLuiId);
 		query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
 
 		@SuppressWarnings("unchecked")
 		List<String> luiIds = query.getResultList();
 		return luiIds;
 	}
 
 	@Override
 	public List<String> getLuiIdsInAtpByCluId(String cluId, String atpKey) {
 		Query query = em.createNamedQuery("Lui.getLuiIdsInAtpByCluId");
 		query.setParameter("cluId", cluId);
 		query.setParameter("atpKey", atpKey);
 		@SuppressWarnings("unchecked")
 		List<String> luiIds = query.getResultList();
 		return luiIds;
 	}
 
 	@Override
 	public Boolean isCluInCluSet(String cluId, String cluSetId) {
 		Query query = em.createNamedQuery("CluSet.isCluInCluSet");
 		query.setParameter("cluId", cluId);
 		query.setParameter("cluSetId", cluSetId);
 		Long valid = (Long) query.getSingleResult();
 		return valid.intValue() > 0;
 	}
                               /*
 	@Override
 	public List<LuiLuiRelation> getLuiLuiRelations(String luiId) {
 		Query query = em
 				.createNamedQuery("LuiLuiRelation.getLuiLuiRelationsByLuiId");
 		query.setParameter("luiId", luiId);
 		@SuppressWarnings("unchecked")
 		List<LuiLuiRelation> luiLuiRelations = query.getResultList();
 		return luiLuiRelations;
 	}
                                      */
 	@Override
 	public List<CluCluRelation> getCluCluRelationsByClu(String cluId) {
 		Query query = em.createNamedQuery("CluCluRelation.getCluCluRelation");
 		query.setParameter("cluId", cluId);
 		@SuppressWarnings("unchecked")
 		List<CluCluRelation> cluCluRelations = query.getResultList();
 		return cluCluRelations;
 	}
 
 	@Override
 	public List<String> getCluIdsByLoId(String loId) {
 		Query query = em.createNamedQuery("Clu.getCluIdsByLoId");
 		query.setParameter("loId", loId);
 		@SuppressWarnings("unchecked")
 		List<String> cluIds = query.getResultList();
 		return cluIds;
 	}
 
 	@Override
 	public List<String> getRelatedCluIdsByCluId(String cluId,
 			String luLuRelationTypeId) {
 		Query query = em
 				.createNamedQuery("CluCluRelation.getRelatedCluIdsByCluId");
 		query.setParameter("cluId", cluId);
 		query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
 		@SuppressWarnings("unchecked")
 		List<String> relatedCluIds = query.getResultList();
 		return relatedCluIds;
 	}
 
 	@Override
     public List<String> getCluIdsByRelatedCluId(String relatedCluId, String luLuRelationTypeId) {
         Query query = em.createNamedQuery("CluCluRelation.getCluIdsByRelatedCluId");
         query.setParameter("relatedCluId", relatedCluId);
         query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
         @SuppressWarnings("unchecked")
         List<String> relatedCluIds = query.getResultList();
         return relatedCluIds;
     }
 
     @Override
 	public List<Clu> getRelatedClusByCluId(String cluId,
 			String luLuRelationTypeId) {
 		Query query = em
 				.createNamedQuery("CluCluRelation.getRelatedClusByCluId");
 		query.setParameter("cluId", cluId);
 		query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
 		@SuppressWarnings("unchecked")
 		List<Clu> relatedClus = query.getResultList();
 		return relatedClus;
 	}
 
     @Override
 	public List<Clu> getClusByRelatedCluId(String relatedCluId,
 			String luLuRelationTypeId) {
 		Query query = em
 				.createNamedQuery("CluCluRelation.getClusByRelatedCluId");
 		query.setParameter("relatedCluId", relatedCluId);
 		query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
 		@SuppressWarnings("unchecked")
 		List<Clu> relatedClus = query.getResultList();
 		return relatedClus;
 	}
     
     
 
 	@Override
 	public List<String> getRelatedLuiIdsByLuiId(String luiId,
 			String luLuRelationTypeId) {
 		Query query = em
 				.createNamedQuery("LuiLuiRelation.getRelatedLuiIdsByLuiId");
 		query.setParameter("luiId", luiId);
 		query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
 		@SuppressWarnings("unchecked")
 		List<String> relatedLuiIds = query.getResultList();
 		return relatedLuiIds;
 	}
                      /*
 	@Override
 	public List<Lui> getRelatedLuisByLuiId(String luiId,
 			String luLuRelationTypeId) {
 		Query query = em
 				.createNamedQuery("LuiLuiRelation.getRelatedLuisByLuiId");
 		query.setParameter("luiId", luiId);
 		query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
 		@SuppressWarnings("unchecked")
 		List<Lui> relatedLuis = query.getResultList();
 		return relatedLuis;
 	}                    */
 
 	@Override
 	public List<Clu> getClusByRelation(String parentCluId,
 			String luLuRelationTypeKey) {
 		Query query = em.createNamedQuery("Clu.getClusByRelation");
 		query.setParameter("parentCluId", parentCluId);
 		query.setParameter("luLuRelationTypeKey", luLuRelationTypeKey);
 		@SuppressWarnings("unchecked")
 		List<Clu> resultList = query.getResultList();
 		return resultList;
 	}
 
 	@Override
 	public List<Clu> getClusByRelationSt(String cluId, String luLuRelationTypeId, List<String> luStateList) {
 		Query query = em.createNamedQuery("CluCluRelation.getRelatedClusByCluIdSt");
 		query.setParameter("cluId", cluId);
 		query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
 		query.setParameter("luStateList", luStateList);
 		@SuppressWarnings("unchecked")
 		List<Clu> resultList = query.getResultList();
 		
 		query = em.createNamedQuery("CluCluRelation.getClusByRelatedCluIdSt");
 		query.setParameter("relatedCluId", cluId);
 		query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
 		query.setParameter("luStateList", luStateList);		
 		List<Clu> resultListRel = query.getResultList();
 		if(resultListRel != null)
 			for(Clu clu:resultListRel) {
 				if (!resultList.contains(clu))
 					resultList.add(clu);
 			}
 		
 		return resultList;
 	}
 	
 	@Override
 	public List<CluLoRelation> getCluLoRelationsByClu(String cluId) {
 		Query query = em
 				.createNamedQuery("CluLoRelation.getCluLoRelationByClu");
 		query.setParameter("cluId", cluId);
 		@SuppressWarnings("unchecked")
 		List<CluLoRelation> cluLoRelations = query.getResultList();
 		return cluLoRelations;
 	}
 
 	@Override
 	public List<CluLoRelation> getCluLoRelationsByLo(String loId) {
 		Query query = em
 				.createNamedQuery("CluLoRelation.getCluLoRelationByLo");
 		query.setParameter("loId", loId);
 		@SuppressWarnings("unchecked")
 		List<CluLoRelation> cluLoRelations = query.getResultList();
 		return cluLoRelations;
 	}
 
 	@Override
 	public List<CluLoRelation> getCluLoRelationsByCludIdAndLoId(String cluId,
 			String loId) {
 		Query query = em.createNamedQuery("CluLoRelation.getCluLoRelation");
 		query.setParameter("cluId", cluId);
 		query.setParameter("loId", loId);
 
 		@SuppressWarnings("unchecked")
 		List<CluLoRelation> rels = query.getResultList();
 		return rels;
 	}
 
 	@Override
 	public List<String> getAllowedLuLuRelationTypesForLuType(String luTypeId,
 			String relatedLuTypeId) {
 		Query query = em
 				.createNamedQuery("AllowedLuLuRelationType.getAllowedTypesByLuTypes");
 		query.setParameter("luTypeId", luTypeId);
 		query.setParameter("relatedLuTypeId", relatedLuTypeId);
 		@SuppressWarnings("unchecked")
 		List<String> resultList = query.getResultList();
 		return resultList;
 	}
 
 	@Override
 	public List<String> getAllowedCluLoRelationTypesForLuType(String luTypeId) {
 		Query query = em
 				.createNamedQuery("AllowedCluLoRealtionType.getAllowedTypesByLuType");
 		query.setParameter("luTypeId", luTypeId);
 		@SuppressWarnings("unchecked")
 		List<String> resultList = query.getResultList();
 		return resultList;
 	}
 
 	@Override
 	public List<String> getAllowedResultUsageTypesForLuType(String luTypeId) {
 		Query query = em
 				.createNamedQuery("AllowedResultUsageLuType.getAllowedTypesByLuType");
 		query.setParameter("luTypeId", luTypeId);
 		@SuppressWarnings("unchecked")
 		List<String> resultList = query.getResultList();
 		return resultList;
 	}
 
 	@Override
 	public List<String> getAllowedResultComponentTypesForResultUsageType(
 			String resultUsageType) {
 		Query query = em
 				.createNamedQuery("AllowedResultComponentUsageType.getAllowedComponentsByUsageType");
 		query.setParameter("resultUsageType", resultUsageType);
 		@SuppressWarnings("unchecked")
 		List<String> resultList = query.getResultList();
 		return resultList;
 	}
 
 	@Override
 	public List<CluResultType> getAllowedCluResultTypesForLuType(String luTypeId) {
 		Query query = em
 				.createNamedQuery("AllowedCluResultLuType.getAllowedTypesByLuType");
 		query.setParameter("luTypeId", luTypeId);
 		@SuppressWarnings("unchecked")
 		List<CluResultType> resultList = query.getResultList();
 		return resultList;
 	}
 
 	@Override
 	public List<String> getCluIdsByResultUsageType(String resultUsageTypeKey) {
 		Query query = em
 				.createNamedQuery("CluResult.getCluIdByResultUsageType");
 		query.setParameter("resultUsageType", resultUsageTypeKey);
 		@SuppressWarnings("unchecked")
 		List<String> resultList = query.getResultList();
 		return resultList;
 	}
 
 	@Override
 	public List<String> getCluIdsByResultComponentId(String resultComponentId) {
 		Query query = em
 				.createNamedQuery("CluResult.getCluIdByResultComponentId");
 		query.setParameter("resultComponentId", resultComponentId);
 		@SuppressWarnings("unchecked")
 		List<String> resultList = query.getResultList();
 		return resultList;
 	}
 
 	@Override
 	public List<String> getAllowedLuLuRelationTypesByLuiId(String luiId,
 			String relatedLuiId) {
 		Query query = em
 				.createNamedQuery("LuiLuiRelation.getRelationTypeByLuiId");
 		query.setParameter("luiId", luiId);
 		query.setParameter("relatedLuiId", relatedLuiId);
 		@SuppressWarnings("unchecked")
 		List<String> resultList = query.getResultList();
 		return resultList;
 	}
 
 	@Override
 	public List<String> getAllowedLuLuRelationTypesByCluId(String cluId,
 			String relatedCluId) {
 		Query query = em
 				.createNamedQuery("CluCluRelation.getRelationTypeByCluId");
 		query.setParameter("cluId", cluId);
 		query.setParameter("relatedCluId", relatedCluId);
 		@SuppressWarnings("unchecked")
 		List<String> resultList = query.getResultList();
 		return resultList;
 	}
 
 	@Override
 	public List<CluResult> getCluResultByClu(String cluId) {
 		Query query = em
 				.createNamedQuery("CluResult.getCluResultByCluId");
 		query.setParameter("cluId", cluId);
 		@SuppressWarnings("unchecked")
 		List<CluResult> resultList = query.getResultList();
 		return resultList;
 	}
 
     @Override
     public List<CluResult> getCluResultsByClus(List<String> cluIds) {
         Set<String> cluIdSet = new HashSet<String>(cluIds.size());
         // remove duplicates from the key list
         cluIdSet.addAll(cluIds);
         return (List<CluResult>) em.createNamedQuery("CluResult.getCluResultsByCluIds").setParameter("cluIds", cluIdSet).getResultList();
     }
 
     @Override
     public Clu getLatestCluVersion(String cluVersionIndId) {
         Query query = em.createNamedQuery("Clu.findLatestClu");
         query.setParameter("versionIndId", cluVersionIndId);
         Clu clu = (Clu)query.getSingleResult();
         return clu;
     }
 
 	@Override
 	public Clu getCurrentCluVersion(String cluVersionIndId) {
         Query query = em.createNamedQuery("Clu.findCurrentClu");
         query.setParameter("versionIndId", cluVersionIndId);
         query.setParameter("currentTime", new Date());
         Clu clu = (Clu)query.getSingleResult();
         return clu;
 	}
 
 	@Override
 	public VersionDisplayInfo getCurrentCluVersionInfo(String cluVersionIndId, String objectTypeURI) {
         Query query = em.createNamedQuery("Clu.findCurrentVersionInfo");
         query.setParameter("versionIndId", cluVersionIndId);
         query.setParameter("currentTime", new Date());
         VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
         versionDisplayInfo.setRefObjectUri(objectTypeURI);
         return versionDisplayInfo;
 	}
 
 	@Override
 	public VersionDisplayInfo getCurrentVersionOnDate(String versionIndId,
 			String objectTypeURI, Date date) {
         Query query = em.createNamedQuery("Clu.findCurrentVersionOnDate");
         query.setParameter("versionIndId", versionIndId);
         query.setParameter("date", date);
         VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
         versionDisplayInfo.setRefObjectUri(objectTypeURI);
         return versionDisplayInfo;
 	}
 
 	@Override
 	public VersionDisplayInfo getFirstVersion(String versionIndId,
 			String objectTypeURI) {
         Query query = em.createNamedQuery("Clu.findFirstVersion");
         query.setParameter("versionIndId", versionIndId);
         VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
         versionDisplayInfo.setRefObjectUri(objectTypeURI);
         return versionDisplayInfo;
 	}
 
 	@Override
 	public VersionDisplayInfo getLatestVersion(String versionIndId,
 			String objectTypeURI) {
         Query query = em.createNamedQuery("Clu.findLatestVersion");
         query.setParameter("versionIndId", versionIndId);
         VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
         versionDisplayInfo.setRefObjectUri(objectTypeURI);
         return versionDisplayInfo;
 	}
 
 	@Override
 	public VersionDisplayInfo getVersionBySequenceNumber(String versionIndId,
 			String objectTypeURI, Long sequenceNumber) {
         Query query = em.createNamedQuery("Clu.findVersionBySequence");
         query.setParameter("versionIndId", versionIndId);
         query.setParameter("sequenceNumber", sequenceNumber);
         VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
         versionDisplayInfo.setRefObjectUri(objectTypeURI);
         return versionDisplayInfo;
 	}
 
 	@Override
 	public List<VersionDisplayInfo> getVersions(String versionIndId,
 			String objectTypeURI) {
         Query query = em.createNamedQuery("Clu.findVersions");
         query.setParameter("versionIndId", versionIndId);
         List<VersionDisplayInfo> versionDisplayInfos = (List<VersionDisplayInfo>)query.getResultList();
         if(versionDisplayInfos==null){
         	versionDisplayInfos = Collections.emptyList();
         }
         for(VersionDisplayInfo versionDisplayInfo:versionDisplayInfos){
         	versionDisplayInfo.setRefObjectUri(objectTypeURI);
         }
         return versionDisplayInfos;
 	}
 
 	@Override
 	public List<VersionDisplayInfo> getVersionsInDateRange(String versionIndId,
 			String objectTypeURI, Date from, Date to) {
 		if(from==null&&to==null){
 			throw new IllegalArgumentException("from and to dates can not both be null");
 		}
 		Query query;
 		if(from==null){
 			query = em.createNamedQuery("Clu.findVersionsBeforeDate");
 	        query.setParameter("versionIndId", versionIndId);
 	        query.setParameter("date", to);			
 		}else if(to==null){
 			query = em.createNamedQuery("Clu.findVersionsAfterDate");
 	        query.setParameter("versionIndId", versionIndId);
 	        query.setParameter("date", from);
 		}else{
 			query = em.createNamedQuery("Clu.findVersionsInDateRange");
 	        query.setParameter("versionIndId", versionIndId);
 	        query.setParameter("from", from);
 	        query.setParameter("to", to);
 		}
 		
         List<VersionDisplayInfo> versionDisplayInfos = (List<VersionDisplayInfo>)query.getResultList();
         if(versionDisplayInfos==null){
         	versionDisplayInfos = Collections.emptyList();
         }
         for(VersionDisplayInfo versionDisplayInfo:versionDisplayInfos){
         	versionDisplayInfo.setRefObjectUri(objectTypeURI);
         }
         return versionDisplayInfos;
 	}
 
 	@Override
 	public List<CluPublication> getCluPublicationsByType(
 			String luPublicationTypeKey) {
         Query query = em.createNamedQuery("CluPublication.findCluPublicationsByType");
         query.setParameter("luPublicationTypeKey", luPublicationTypeKey);
         List<CluPublication> cluPublications = query.getResultList();
         return cluPublications;
 	}
 
 	@Override
 	public List<CluPublication> getCluPublicationsByCluId(String cluId) {
         Query query = em.createNamedQuery("CluPublication.findPublicationsByCluId");
         query.setParameter("cluId", cluId);
         List<CluPublication> cluPublications = query.getResultList();
         return cluPublications;
 	}
 
 	@Override
 	public List<CluSet> getCluSetsByCluVersionIndId(List<String> cluVersionIndIds) {
         Query query = em.createNamedQuery("CluSet.findCluSetsByCluVersionIndIds");
         query.setParameter("cluVersionIndIds", cluVersionIndIds);
         List<CluSet> cluSetIds = query.getResultList();
         return cluSetIds;
 	}
 
 	@Override
 	public List<CluSet> getAllDynamicCluSets() {
         Query query = em.createNamedQuery("CluSet.findAllDynamicCluSets");
         List<CluSet> cluSetIds = query.getResultList();
         return cluSetIds;
 	}
 
 	@Override
 	public List<Clu> getCrossListedClusByCodes(List<String> crossListedCodes) {
 		if(crossListedCodes!=null && crossListedCodes.isEmpty()){
 			crossListedCodes.add(""); //Add a blank param value because jpql IN(:var) has problems with empty lists
 		}
         Query query = em.createNamedQuery("Clu.getCrossListedClusByCodes");
         query.setParameter("crossListedCodes", crossListedCodes);
         List<Clu> clus = query.getResultList();
         return clus;
 	}
 	
 }