/*

  * Copyright 2005-2008 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.opensource.org/licenses/ecl2.php

  *

  * 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.rice.kew.rule.dao.impl;

 import org.apache.commons.lang.StringUtils;

 import org.kuali.rice.core.exception.RiceRuntimeException;

 import org.kuali.rice.core.jpa.criteria.Criteria;

 import org.kuali.rice.core.jpa.criteria.QueryByCriteria;

 import org.kuali.rice.core.util.OrmUtils;

 import org.kuali.rice.kew.rule.RuleBaseValues;

 import org.kuali.rice.kew.rule.RuleExtension;

 import org.kuali.rice.kew.rule.RuleResponsibility;

 import org.kuali.rice.kew.rule.dao.RuleDAO;

 import org.kuali.rice.kew.util.KEWConstants;

 import org.kuali.rice.kew.util.Utilities;

 import org.kuali.rice.kim.bo.entity.KimPrincipal;

 import org.kuali.rice.kim.service.KIMServiceLocator;

 import javax.persistence.EntityManager;

 import javax.persistence.PersistenceContext;

 import javax.persistence.Query;

 import java.sql.Timestamp;

 import java.util.*;

 public class RuleDAOJpaImpl implements RuleDAO {

         private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(RuleDAOJpaImpl.class);

         @PersistenceContext(unitName="kew-unit")

         private EntityManager entityManager;

         private static final String OLD_DELEGATIONS_SQL =

                 "select oldDel.dlgn_rule_id "+

                 "from krew_rule_rsp_t oldRsp, krew_dlgn_rsp_t oldDel "+

                 "where oldRsp.rule_id=? and "+

                 "oldRsp.rule_rsp_id=oldDel.rule_rsp_id and "+

                 "oldDel.dlgn_rule_base_val_id not in "+

                 "(select newDel.dlgn_rule_base_val_id from krew_rule_rsp_t newRsp, krew_dlgn_rsp_t newDel "+

                 "where newRsp.rule_id=? and "+

                 "newRsp.rule_rsp_id=newDel.rule_rsp_id)";

         public void save(RuleBaseValues ruleBaseValues) {

                 if(ruleBaseValues.getRuleBaseValuesId()==null){

                         entityManager.persist(ruleBaseValues);

                 }else{

                         OrmUtils.merge(entityManager, ruleBaseValues);

                 }

         }

         public List fetchAllCurrentRulesForTemplateDocCombination(Long ruleTemplateId, List documentTypes) {

                 Criteria crit = new Criteria(RuleBaseValues.class.getName());

                 crit.in("docTypeName", documentTypes);

                 crit.eq("ruleTemplateId", ruleTemplateId);

                 crit.eq("currentInd", Boolean.TRUE);

                 crit.eq("activeInd", Boolean.TRUE);

                 crit.eq("delegateRule", Boolean.FALSE);

                 crit.eq("templateRuleInd", Boolean.FALSE);

                 crit.and(generateFromToDateCriteria(new Date()));

                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         }

         public List fetchAllCurrentRulesForTemplateDocCombination(Long ruleTemplateId, List documentTypes, Timestamp effectiveDate) {

                 Criteria crit = new Criteria(RuleBaseValues.class.getName());

                 crit.in("docTypeName", documentTypes);

                 crit.eq("ruleTemplateId", ruleTemplateId);

                 crit.eq("activeInd", Boolean.TRUE);

                 crit.eq("delegateRule", Boolean.FALSE);

                 crit.eq("templateRuleInd", Boolean.FALSE);

                 if (effectiveDate != null) {

                         crit.lte("activationDate", effectiveDate);

                         crit.gte("deactivationDate", effectiveDate);

                 }

                 crit.and(generateFromToDateCriteria(new Date()));

                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         }

         public Criteria generateFromToDateCriteria(Date date) {

                 Criteria crit = new Criteria(RuleBaseValues.class.getName());

                 Criteria fromCrit = new Criteria(RuleBaseValues.class.getName());

                 Criteria fromNullCrit = new Criteria(RuleBaseValues.class.getName());

                 fromNullCrit.isNull("fromDate");

                 Criteria fromLessOrEqualCrit = new Criteria(RuleBaseValues.class.getName());

                 fromLessOrEqualCrit.lte("fromDate", new Timestamp(date.getTime()));

                 fromCrit.or(fromNullCrit);

                 fromCrit.or(fromLessOrEqualCrit);

                 Criteria toCrit = new Criteria(RuleBaseValues.class.getName());

                 Criteria toNullCrit = new Criteria(RuleBaseValues.class.getName());

                 toNullCrit.isNull("toDate");

                 Criteria toGreaterOrEqualCrit = new Criteria(RuleBaseValues.class.getName());

                 toGreaterOrEqualCrit.gte("toDate", new Timestamp(date.getTime()));

                 toCrit.or(toNullCrit);

                 toCrit.or(toGreaterOrEqualCrit);

                 crit.and(fromCrit);

                 crit.and(toCrit);

                 return crit;

         }

         public List fetchAllRules(boolean currentRules) {

                 Criteria crit = new Criteria(RuleBaseValues.class.getName());

                 crit.eq("currentInd", new Boolean(currentRules));

                 crit.eq("templateRuleInd", Boolean.FALSE);

                 crit.orderBy("activationDate", false);

                 QueryByCriteria query = new QueryByCriteria(entityManager, crit);

                 return (List) query.toQuery().getResultList();

         }

         public void delete(Long ruleBaseValuesId) {

                 entityManager.remove(entityManager.find(RuleBaseValues.class, ruleBaseValuesId));

         }

         public List findByRouteHeaderId(Long routeHeaderId) {

                 Criteria crit = new Criteria(RuleBaseValues.class.getName());

                 crit.eq("routeHeaderId", routeHeaderId);

                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         }

     public RuleBaseValues findRuleBaseValuesByName(String name) {

         Criteria crit = new Criteria(RuleBaseValues.class.getName());

         crit.eq("name", name);

         crit.eq("currentInd", Boolean.TRUE);

         try{

                 return (RuleBaseValues) new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();

         }catch (javax.persistence.NoResultException e){

                 return null;

         }

     }

         public RuleBaseValues findRuleBaseValuesById(Long ruleBaseValuesId) {

                 Criteria crit = new Criteria(RuleBaseValues.class.getName());

                 crit.eq("ruleBaseValuesId", ruleBaseValuesId);

                 try{

                         return (RuleBaseValues) new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();

                 }catch(javax.persistence.NoResultException e){

                         return null;

                 }

         }

         public List findRuleBaseValuesByResponsibilityReviewer(String reviewerName, String type) {

                 Criteria crit = new Criteria(RuleResponsibility.class.getName());

                 crit.eq("ruleResponsibilityName", reviewerName);

                 crit.eq("ruleResponsibilityType", type);

                 List responsibilities = (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();

                 List rules = new ArrayList();

                 for (Iterator iter = responsibilities.iterator(); iter.hasNext();) {

                         RuleResponsibility responsibility = (RuleResponsibility) iter.next();

                         RuleBaseValues rule = responsibility.getRuleBaseValues();

                         if (rule != null && rule.getCurrentInd() != null && rule.getCurrentInd().booleanValue()) {

                                 rules.add(rule);

                         }

                 }

                 return rules;

         }

         public List findRuleBaseValuesByResponsibilityReviewerTemplateDoc(String ruleTemplateName, String documentType, String reviewerName, String type) {

             Criteria crit = new Criteria(RuleResponsibility.class.getName());

                 crit.eq("ruleResponsibilityName", reviewerName);

                 crit.eq("ruleResponsibilityType", type);

                 crit.eq("ruleBaseValues.currentInd", Boolean.TRUE);

                 if (!StringUtils.isBlank(ruleTemplateName)) {

                     crit.like("ruleBaseValues.ruleTemplate.name", ruleTemplateName.replace("*", "%").concat("%"));

                 }

                 if (!StringUtils.isBlank(documentType)) {

                     crit.like("ruleBaseValues.docTypeName", documentType.replace("*", "%").concat("%"));

                 }

                 List responsibilities = (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();

                 List rules = new ArrayList();

                 for (Iterator iter = responsibilities.iterator(); iter.hasNext();) {

                         RuleResponsibility responsibility = (RuleResponsibility) iter.next();

                         RuleBaseValues rule = responsibility.getRuleBaseValues();

                         if (rule != null && rule.getCurrentInd() != null && rule.getCurrentInd().booleanValue()) {

                                 rules.add(rule);

                         }

                 }

                 return rules;

         }

         //FIXME nothing uses this, it's not in ruleDAO interface

 //        public List findRuleBaseValuesByObjectGraph(RuleBaseValues ruleBaseValues) {

 //                ruleBaseValues.setCurrentInd(Boolean.TRUE);

 //                ruleBaseValues.setTemplateRuleInd(Boolean.FALSE);

 //                return (List) new QueryByObject(entityManager,ruleBaseValues).toQuery().getResultList();

 //        }

         public RuleResponsibility findRuleResponsibility(Long responsibilityId) {

                 Criteria crit = new Criteria(RuleResponsibility.class.getName());

                 crit.eq("responsibilityId", responsibilityId);

                 Collection responsibilities = new QueryByCriteria(entityManager, crit).toQuery().getResultList();

                 for (Iterator iterator = responsibilities.iterator(); iterator.hasNext();) {

                         RuleResponsibility responsibility = (RuleResponsibility) iterator.next();

                         if (responsibility.getRuleBaseValues().getCurrentInd().booleanValue()) {

                                 return responsibility;

                         }

                 }

                 return null;

         }

         public List search(String docTypeName, Long ruleId, Long ruleTemplateId, String ruleDescription, String groupId, String principalId, Boolean delegateRule, Boolean activeInd, Map extensionValues, String workflowIdDirective) {

         Criteria crit = getSearchCriteria(docTypeName, ruleTemplateId, ruleDescription, delegateRule, activeInd, extensionValues);

         if (ruleId != null) {

             crit.eq("ruleBaseValuesId", ruleId);

         }

         if (groupId != null) {

             crit.in("responsibilities.ruleBaseValuesId", getResponsibilitySubQuery(groupId), "ruleBaseValuesId");

         }

         Collection<String> kimGroupIds = new HashSet<String>();

         Boolean searchUser = Boolean.FALSE;

         Boolean searchUserInWorkgroups = Boolean.FALSE;

         if ("group".equals(workflowIdDirective)) {

             searchUserInWorkgroups = Boolean.TRUE;

         } else if (StringUtils.isBlank(workflowIdDirective)) {

             searchUser = Boolean.TRUE;

             searchUserInWorkgroups = Boolean.TRUE;

         } else {

             searchUser = Boolean.TRUE;

         }

         if (!Utilities.isEmpty(principalId) && searchUserInWorkgroups) {

             KimPrincipal principal = null;

             principal = KIMServiceLocator.getIdentityManagementService().getPrincipal(principalId);

             if (principal == null)

             {

                     throw new RiceRuntimeException("Failed to locate user for the given principal id: " + principalId);

             }

             kimGroupIds = KIMServiceLocator.getIdentityManagementService().getGroupIdsForPrincipal(principalId);

         }

         Criteria responsibilityCrit = getResponsibilitySubQuery(kimGroupIds, principalId, searchUser, searchUserInWorkgroups);

         if (responsibilityCrit != null) {

                 crit.in("responsibilities.ruleBaseValuesId", responsibilityCrit,"ruleBaseValuesId");

         }

         crit.distinct(true);

                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         }

     public List search(String docTypeName, Long ruleTemplateId, String ruleDescription, Collection<String> workgroupIds, String workflowId, Boolean delegateRule, Boolean activeInd, Map extensionValues, Collection actionRequestCodes) {

         Criteria crit = getSearchCriteria(docTypeName, ruleTemplateId, ruleDescription, delegateRule, activeInd, extensionValues);

         Criteria responsibilityCrit = getResponsibilitySubQuery(workgroupIds, workflowId, actionRequestCodes, (workflowId != null), ((workgroupIds != null) && !workgroupIds.isEmpty()));

         if (responsibilityCrit != null) {

                 crit.in("responsibilities.ruleBaseValuesId", responsibilityCrit, "ruleBaseValuesId");

         }

         return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();

     }

     private Criteria getResponsibilitySubQuery(Collection<String> kimGroupIds, String principalId, Boolean searchUser, Boolean searchUserInWorkgroups) {

         Collection<String> workgroupIdStrings = new ArrayList<String>();

         for (String workgroupId : kimGroupIds) {

             workgroupIdStrings.add(workgroupId.toString());

         }

         return getResponsibilitySubQuery(workgroupIdStrings,principalId,new ArrayList<String>(), searchUser, searchUserInWorkgroups);

     }

     private Criteria getResponsibilitySubQuery(Collection<String> workgroupIds, String workflowId, Collection actionRequestCodes, Boolean searchUser, Boolean searchUserInWorkgroups) {

         Criteria responsibilityCrit = null;

         Criteria ruleResponsibilityNameCrit = null;

         if (!Utilities.isEmpty(workflowId)) {

             // workflow user id exists

             if (searchUser != null && searchUser) {

                 // searching user wishes to search for rules specific to user

                 ruleResponsibilityNameCrit = new Criteria(RuleResponsibility.class.getName(), "rr");

                 ruleResponsibilityNameCrit.like("ruleResponsibilityName", workflowId);

                 ruleResponsibilityNameCrit.eq("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID);

             }

             if ( (searchUserInWorkgroups != null && searchUserInWorkgroups) && (workgroupIds != null) && (!workgroupIds.isEmpty()) ) {

                 // at least one workgroup id exists and user wishes to search on workgroups

                 if (ruleResponsibilityNameCrit == null) {

                     ruleResponsibilityNameCrit = new Criteria(RuleResponsibility.class.getName(), "rr");

                 }

                 Criteria workgroupCrit = new Criteria(RuleResponsibility.class.getName(), "rr");

                 workgroupCrit.in("ruleResponsibilityName", new ArrayList<String>(workgroupIds));

                 workgroupCrit.eq("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);

                 ruleResponsibilityNameCrit.or(workgroupCrit);

             }

         } else if ( (workgroupIds != null) && (workgroupIds.size() == 1) ) {

             // no user and one workgroup id

             ruleResponsibilityNameCrit = new Criteria(RuleResponsibility.class.getName(), "rr");

             ruleResponsibilityNameCrit.like("ruleResponsibilityName", workgroupIds.iterator().next());

             ruleResponsibilityNameCrit.eq("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);

         } else if ( (workgroupIds != null) && (workgroupIds.size() > 1) ) {

             // no user and more than one workgroup id

             ruleResponsibilityNameCrit = new Criteria(RuleResponsibility.class.getName(), "rr");

             ruleResponsibilityNameCrit.in("ruleResponsibilityName",  new ArrayList<String>(workgroupIds));

             ruleResponsibilityNameCrit.eq("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);

         }

         if (ruleResponsibilityNameCrit != null) {

                 responsibilityCrit = new Criteria(RuleResponsibility.class.getName(), "rr");

             if ( (actionRequestCodes != null) && (!actionRequestCodes.isEmpty()) ) {

                 responsibilityCrit.in("actionRequestedCd", new ArrayList(actionRequestCodes));

             }

             responsibilityCrit.and(ruleResponsibilityNameCrit);

         }

         return responsibilityCrit;

     }

     private Criteria getSearchCriteria(String docTypeName, Long ruleTemplateId, String ruleDescription, Boolean delegateRule, Boolean activeInd, Map extensionValues) {

         Criteria crit = new Criteria(RuleBaseValues.class.getName());

         crit.eq("currentInd", Boolean.TRUE);

         crit.eq("templateRuleInd", Boolean.FALSE);

         if (activeInd != null) {

             crit.eq("activeInd", activeInd);

         }

         if (docTypeName != null) {

             crit.like("UPPER(docTypeName)", docTypeName.toUpperCase());

         }

         if (ruleDescription != null && !ruleDescription.trim().equals("")) {

             crit.like("UPPER(description)", ruleDescription.toUpperCase());

         }

         if (ruleTemplateId != null) {

             crit.eq("ruleTemplateId", ruleTemplateId);

         }

         if (delegateRule != null) {

             crit.eq("delegateRule", delegateRule);

         }

         if (extensionValues != null && !extensionValues.isEmpty()) {

             for (Iterator iter2 = extensionValues.entrySet().iterator(); iter2.hasNext();) {

                 Map.Entry entry = (Map.Entry) iter2.next();

                 if (!Utilities.isEmpty((String) entry.getValue())) {

                     // Criteria extensionCrit = new Criteria();

                     // extensionCrit.addEqualTo("extensionValues.key",

                     // entry.getKey());

                     // extensionCrit.addLike("extensionValues.value",

                     // "%"+(String) entry.getValue()+"%");

                     Criteria extensionCrit2 = new Criteria(RuleExtension.class.getName());

                     extensionCrit2.eq("extensionValues.key", entry.getKey());

                     extensionCrit2.like("UPPER(extensionValues.value)", ("%" + (String) entry.getValue() + "%").toUpperCase());

                     // Criteria extensionCrit3 = new Criteria();

                     // extensionCrit3.addEqualTo("extensionValues.key",

                     // entry.getKey());

                     // extensionCrit3.addLike("extensionValues.value",

                     // ("%"+(String) entry.getValue()+"%").toLowerCase());

                     // extensionCrit.addOrCriteria(extensionCrit2);

                     // extensionCrit.addOrCriteria(extensionCrit3);

                     crit.in("ruleExtensions.ruleBaseValuesId", extensionCrit2, "ruleBaseValuesId");

                 }

             }

         }

         return crit;

     }

 //    private Criteria getWorkgroupOrCriteria(Collection workgroupIds) {

 //        Criteria responsibilityCrit = new Criteria(RuleResponsibility.class.getName());

 //        for (Iterator iter = workgroupIds.iterator(); iter.hasNext();) {

 //            String workgroupIdFromList = (String) iter.next();

 //            Criteria orCriteria = new Criteria(RuleResponsibility.class.getName());

 //            orCriteria.like("ruleResponsibilityName", workgroupIdFromList);

 //            responsibilityCrit.or(orCriteria);

 //        }

 //

 //        Criteria crit = new Criteria();

 //        crit.in("responsibilities.ruleBaseValuesId", responsibilityCrit,"ruleBaseValuesId");

 //        return crit;

 //    }

         private Criteria getResponsibilitySubQuery(String ruleResponsibilityName) {

                 Criteria responsibilityCrit = new Criteria(RuleResponsibility.class.getName());

                 responsibilityCrit.like("ruleResponsibilityName", ruleResponsibilityName);

                 //ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, responsibilityCrit);

                 //query.setAttributes(new String[] { "ruleBaseValuesId" });

                 return responsibilityCrit;

         }

 //        private Criteria getWorkgroupResponsibilitySubQuery(Set<Long> workgroupIds) {

 //                    Set<String> workgroupIdStrings = new HashSet<String>();

 //                    for (Long workgroupId : workgroupIds) {

 //                        workgroupIdStrings.add(workgroupId.toString());

 //                    }

 //                Criteria responsibilityCrit = new Criteria(RuleResponsibility.class.getName());

 //                responsibilityCrit.in("ruleResponsibilityName", new ArrayList(workgroupIds));

 //                responsibilityCrit.eq("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);

 ////                ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, responsibilityCrit);

 ////                query.setAttributes(new String[] { "ruleBaseValuesId" });

 //                return responsibilityCrit;

 //        }

         public List findByPreviousVersionId(Long previousVersionId) {

                 Criteria crit = new Criteria(RuleBaseValues.class.getName());

                 crit.eq("previousVersionId", previousVersionId);

                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         }

         public RuleBaseValues findDefaultRuleByRuleTemplateId(Long ruleTemplateId) {

                 Criteria crit = new Criteria(RuleBaseValues.class.getName());

                 crit.eq("ruleTemplateId", ruleTemplateId);

                 crit.eq("templateRuleInd", Boolean.TRUE);

                 List rules = (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();

                 if (rules != null && !rules.isEmpty()) {

                         return (RuleBaseValues) rules.get(0);

                 }

                 return null;

         }

         public void clearCache() {

                 //TODO clear the cache

         }

         public void retrieveAllReferences(RuleBaseValues rule) {

                 // getPersistenceBroker().retrieveAllReferences(rule);

         }

         public RuleBaseValues getParentRule(Long ruleBaseValuesId) {

                 Criteria criteria = new Criteria(RuleBaseValues.class.getName());

                 criteria.eq("currentInd", Boolean.TRUE);

                 criteria.eq("responsibilities.delegationRules.delegateRuleId", ruleBaseValuesId);

                 Collection rules = new QueryByCriteria(entityManager, criteria).toQuery().getResultList();

                 RuleBaseValues rule = null;

                 for (Iterator iterator = rules.iterator(); iterator.hasNext();) {

                         RuleBaseValues currentRule = (RuleBaseValues) iterator.next();

                         if (rule == null || currentRule.getVersionNbr().intValue() > rule.getVersionNbr().intValue()) {

                                 rule = currentRule;

                         }

                 }

                 return rule;

         }

         public List findOldDelegations(final RuleBaseValues oldRule, final RuleBaseValues newRule) {

                 Query q = entityManager.createNativeQuery(OLD_DELEGATIONS_SQL);

                 q.setParameter(1, oldRule.getRuleBaseValuesId().longValue());

                 q.setParameter(2, newRule.getRuleBaseValuesId().longValue());

                 List oldDelegations = new ArrayList();

                 for(Object l:q.getResultList()){

                         oldDelegations.add(findRuleBaseValuesById((Long)l));

                 }

                 return oldDelegations;

         }

         public Long findResponsibilityIdForRule(String ruleName, String ruleResponsibilityName, String ruleResponsibilityType) {

                 Criteria crit = new Criteria(RuleResponsibility.class.getName());

                 crit.eq("ruleResponsibilityName", ruleResponsibilityName);

                 crit.eq("ruleResponsibilityType", ruleResponsibilityType);

                 crit.eq("ruleBaseValues.currentInd", Boolean.TRUE);

                 crit.eq("ruleBaseValues.name", ruleName);

                 Collection responsibilities = new QueryByCriteria(entityManager, crit).toQuery().getResultList();

                 if (responsibilities != null) {

                         for (Iterator iter = responsibilities.iterator(); iter.hasNext();) {

                                 RuleResponsibility responsibility = (RuleResponsibility) iter.next();

                                 return responsibility.getResponsibilityId();

                         }

                 }

                 return null;

         }

     public EntityManager getEntityManager() {

         return this.entityManager;

     }

     public void setEntityManager(EntityManager entityManager) {

         this.entityManager = entityManager;

     }

 }