/**

  * Copyright 2005-2011 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;

 import org.apache.commons.lang.ObjectUtils;

 import org.apache.commons.lang.StringUtils;

 import org.apache.log4j.Logger;

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

 import org.kuali.rice.core.api.reflect.ObjectDefinition;

 import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;

 import org.kuali.rice.core.api.util.ClassLoaderUtils;

 import org.kuali.rice.kew.actionrequest.ActionRequestFactory;

 import org.kuali.rice.kew.actionrequest.ActionRequestValue;

 import org.kuali.rice.kew.actionrequest.KimGroupRecipient;

 import org.kuali.rice.kew.actionrequest.KimPrincipalRecipient;

 import org.kuali.rice.kew.actionrequest.Recipient;

 import org.kuali.rice.kew.actionrequest.service.ActionRequestService;

 import org.kuali.rice.kew.api.KewApiServiceLocator;

 import org.kuali.rice.kew.api.action.ActionRequestStatus;

 import org.kuali.rice.kew.api.exception.WorkflowException;

 import org.kuali.rice.kew.api.extension.ExtensionDefinition;

 import org.kuali.rice.kew.api.rule.RuleDelegation;

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

 import org.kuali.rice.kew.api.rule.RuleService;

 import org.kuali.rice.kew.api.rule.RuleTemplateAttribute;

 import org.kuali.rice.kew.engine.RouteContext;

 import org.kuali.rice.kew.engine.node.NodeState;

 import org.kuali.rice.kew.engine.node.RouteNode;

 import org.kuali.rice.kew.engine.node.RouteNodeInstance;

 import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;

 import org.kuali.rice.kew.service.KEWServiceLocator;

 import org.kuali.rice.kew.user.RoleRecipient;

 import org.kuali.rice.kew.api.KewApiConstants;

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

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

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

 import java.sql.Timestamp;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.Map;

 /**

  * Generates Action Requests for a Document using the rule system and the specified

  * {@link org.kuali.rice.kew.rule.bo.RuleTemplateBo}.

  *

  * @see ActionRequestValue

  * @see org.kuali.rice.kew.rule.bo.RuleTemplateBo

  * @see RuleBaseValues

  *

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class FlexRM {

         private static final Logger LOG = Logger.getLogger(FlexRM.class);

         /**

          * The default type of rule selector implementation to use if none is explicitly

          * specified for the node.

          */

         public static final String DEFAULT_RULE_SELECTOR = "Template";

         /**

          * Package in which rule selector implementations live

          */

         private static final String RULE_SELECTOR_PACKAGE = "org.kuali.rice.kew.rule";

         /**

          * The class name suffix all rule selectors should have; e.g. FooRuleSelector

          */

         private static final String RULE_SELECTOR_SUFFIX= "RuleSelector";

         private final Timestamp effectiveDate;

         /**

          * An accumulator that keeps track of the number of rules that have been selected over the lifespan of

          * this FlexRM instance.

          */

         private int selectedRules;

         public FlexRM() {

                 this.effectiveDate = null;

         }

         public FlexRM(Timestamp effectiveDate) {

                 this.effectiveDate = effectiveDate;

         }

         /*public List<ActionRequestValue> getActionRequests(DocumentRouteHeaderValue routeHeader, String ruleTemplateName) throws KEWUserNotFoundException, WorkflowException {

         return getActionRequests(routeHeader, null, ruleTemplateName);

     }*/

         // loads a RuleSelector implementation

         protected RuleSelector loadRuleSelector(RouteNode routeNodeDef, RouteNodeInstance nodeInstance) {

                 // first see if there ruleselector is configured on a nodeinstance basis

                 NodeState ns = null;

                 if (nodeInstance != null) {

                         ns = nodeInstance.getNodeState(KewApiConstants.RULE_SELECTOR_NODE_STATE_KEY);

                 }

                 String ruleSelectorName = null;

                 if (ns != null) {

                         ruleSelectorName = ns.getValue();

                 } else {

                         // otherwise pull it from the RouteNode definition/prototype

                         Map<String, String> nodeCfgParams = Utilities.getKeyValueCollectionAsMap(

                                         routeNodeDef.

                                         getConfigParams());

                         ruleSelectorName = nodeCfgParams.get(RouteNode.RULE_SELECTOR_CFG_KEY);

                 }

                 if (ruleSelectorName == null) {

                         ruleSelectorName = DEFAULT_RULE_SELECTOR;

                 }

                 ruleSelectorName = StringUtils.capitalize(ruleSelectorName);

                 // load up the rule selection implementation

                 String className = RULE_SELECTOR_PACKAGE + "." + ruleSelectorName + RULE_SELECTOR_SUFFIX;

                 Class<?> ruleSelectorClass;

                 try {

                         ruleSelectorClass = ClassLoaderUtils.getDefaultClassLoader().loadClass(className);

                 } catch (ClassNotFoundException cnfe) {

                         throw new IllegalStateException("Rule selector implementation '" + className + "' not found", cnfe);

                 }

                 if (!RuleSelector.class.isAssignableFrom(ruleSelectorClass)) {

                         throw new IllegalStateException("Specified class '" + ruleSelectorClass + "' does not implement RuleSelector interface");

                 }

                 RuleSelector ruleSelector;

                 try {

                         ruleSelector = ((Class<RuleSelector>) ruleSelectorClass).newInstance();

                 } catch (Exception e) {

                         if (e instanceof RuntimeException) {

                                 throw (RuntimeException)e;

                         }

                         throw new IllegalStateException("Error instantiating rule selector implementation '" + ruleSelectorClass + "'", e);

                 }

                 return ruleSelector;

         }

         /**

          * Generates action requests

          * @param routeHeader the document route header

          * @param nodeInstance the route node instance; this may NOT be null

          * @param ruleTemplateName the rule template

          * @return list of action requests

          * @throws WorkflowException

          */

         public List<ActionRequestValue> getActionRequests(DocumentRouteHeaderValue routeHeader, RouteNodeInstance nodeInstance, String ruleTemplateName) {

                 return getActionRequests(routeHeader, nodeInstance.getRouteNode(), nodeInstance, ruleTemplateName);

         }

         /**

          * Generates action requests

          * @param routeHeader the document route header

          * @param routeNodeDef the RouteNode definition of the route node instance

          * @param nodeInstance the route node instance; this may be null!

          * @param ruleTemplateName the rule template

          * @return list of action requests

          * @throws WorkflowException

          */

         public List<ActionRequestValue> getActionRequests(DocumentRouteHeaderValue routeHeader, RouteNode routeNodeDef, RouteNodeInstance nodeInstance, String ruleTemplateName) {

                 RouteContext context = RouteContext.getCurrentRouteContext();

                 // TODO really the route context just needs to be able to support nested create and clears

                 // (i.e. a Stack model similar to transaction intercepting in Spring) and we wouldn't have to do this

                 if (context.getDocument() == null) {

                         context.setDocument(routeHeader);

                 }

                 if (context.getNodeInstance() == null) {

                         context.setNodeInstance(nodeInstance);

                 }

                 LOG.debug("Making action requests for document " + routeHeader.getDocumentId());

                 RuleSelector ruleSelector = loadRuleSelector(routeNodeDef, nodeInstance);

                 List<Rule> rules = ruleSelector.selectRules(context, routeHeader, nodeInstance, ruleTemplateName, effectiveDate);

                 // XXX: FIXME: this is a special case hack to expose info from the default selection implementation

                 // this is used in exactly one place, RoutingReportAction, to make a distinction between no rules being

                 // selected, and no rules actually matching when evaluated

                 // if (numberOfRules == 0) {

                 //   errors.add(new WorkflowServiceErrorImpl("There are no rules.", "routereport.noRules"));

                 // } else {

                 //   errors.add(new WorkflowServiceErrorImpl("There are rules, but no matches.", "routereport.noMatchingRules"));

                 // }

                 if (ruleSelector instanceof TemplateRuleSelector) {

                         selectedRules += ((TemplateRuleSelector) ruleSelector).getNumberOfSelectedRules();

                 }

                 PerformanceLogger performanceLogger = new PerformanceLogger();

                 ActionRequestFactory arFactory = new ActionRequestFactory(routeHeader, context.getNodeInstance());

                 List<ActionRequestValue> actionRequests = new ArrayList<ActionRequestValue>();

                 if (rules != null) {

                         LOG.info("Total number of rules selected by RuleSelector for documentType=" + routeHeader.getDocumentType().getName() + " and ruleTemplate=" + ruleTemplateName + ": " + rules.size());

                         for (Rule rule: rules) {

                                 RuleExpressionResult result = rule.evaluate(rule, context);

                                 if (result.isSuccess() && result.getResponsibilities() != null) {

                                         // actionRequests.addAll(makeActionRequests(context, rule, routeHeader, null, null));

                     org.kuali.rice.kew.api.rule.Rule ruleDef = org.kuali.rice.kew.api.rule.Rule.Builder.create(rule.getDefinition()).build();

                                         makeActionRequests(arFactory, result.getResponsibilities(), context, ruleDef, routeHeader, null, null);

                                 }

                         }

                 }

                 actionRequests = new ArrayList<ActionRequestValue>(arFactory.getRequestGraphs());

                 performanceLogger.log("Time to make action request for template " + ruleTemplateName);

                 return actionRequests;

         }

         public ResponsibleParty resolveResponsibilityId(String responsibilityId) {

                 if (responsibilityId == null) {

                         throw new IllegalArgumentException("A null responsibilityId was passed to resolve responsibility!");

                 }

                 RuleResponsibility resp = getRuleService().getRuleResponsibility(responsibilityId);

                 ResponsibleParty responsibleParty = new ResponsibleParty();

                 if (resp!=null && resp.isUsingRole()) {

                         responsibleParty.setRoleName(resp.getResolvedRoleName());

                 } else if (resp!=null && resp.isUsingPrincipal()) {

                         responsibleParty.setPrincipalId(resp.getPrincipalId());

                 } else if (resp!=null && resp.isUsingGroup()) {

                         responsibleParty.setGroupId(resp.getGroupId());

                 } else {

                         throw new RiceRuntimeException("Failed to resolve responsibility from responsibility ID " + responsibilityId + ".  Responsibility was an invalid type: " + resp);

                 }

                 return responsibleParty;

         }

         private void makeActionRequests(ActionRequestFactory arFactory, RouteContext context, org.kuali.rice.kew.api.rule.Rule rule, DocumentRouteHeaderValue routeHeader, ActionRequestValue parentRequest, RuleDelegation ruleDelegation)

                         throws WorkflowException {

                 List<org.kuali.rice.kew.api.rule.RuleResponsibility> responsibilities = rule.getRuleResponsibilities();

                 makeActionRequests(arFactory, responsibilities, context, rule, routeHeader, parentRequest, ruleDelegation);

         }

         public void makeActionRequests(ActionRequestFactory arFactory, List<org.kuali.rice.kew.api.rule.RuleResponsibility> responsibilities, RouteContext context, org.kuali.rice.kew.api.rule.Rule rule, DocumentRouteHeaderValue routeHeader, ActionRequestValue parentRequest, RuleDelegation ruleDelegation) {

                 //        Set actionRequests = new HashSet();

         for (org.kuali.rice.kew.api.rule.RuleResponsibility responsibility : responsibilities)

         {

             //            arFactory = new ActionRequestFactory(routeHeader);

             if (responsibility.isUsingRole())

             {

                 makeRoleActionRequests(arFactory, context, rule, responsibility, routeHeader, parentRequest, ruleDelegation);

             } else

             {

                 makeActionRequest(arFactory, context, rule, routeHeader, responsibility, parentRequest, ruleDelegation);

             }

             //            if (arFactory.getRequestGraph() != null) {

             //            actionRequests.add(arFactory.getRequestGraph());

             //            }

         }

         }

         private void buildDelegationGraph(ActionRequestFactory arFactory, RouteContext context, 

                         org.kuali.rice.kew.api.rule.Rule delegationRule, DocumentRouteHeaderValue routeHeaderValue, ActionRequestValue parentRequest, RuleDelegation ruleDelegation) {

                 context.setActionRequest(parentRequest);

         RuleBaseValues delRuleBo = KEWServiceLocator.getRuleService().getRuleByName(delegationRule.getName());

                 if (delegationRule.isActive()) {

             for (org.kuali.rice.kew.api.rule.RuleResponsibility delegationResp : delegationRule.getRuleResponsibilities())

             {

                 if (delegationResp.isUsingRole())

                 {

                     makeRoleActionRequests(arFactory, context, delegationRule, delegationResp, routeHeaderValue, parentRequest, ruleDelegation);

                 } else if (delRuleBo.isMatch(context.getDocumentContent()))

                 {

                     makeActionRequest(arFactory, context, delegationRule, routeHeaderValue, delegationResp, parentRequest, ruleDelegation);

                 }

             }

                 }

         }

         /**

          * Generates action requests for a role responsibility

          */

         private void makeRoleActionRequests(ActionRequestFactory arFactory, RouteContext context, 

                         org.kuali.rice.kew.api.rule.Rule rule, org.kuali.rice.kew.api.rule.RuleResponsibility resp, DocumentRouteHeaderValue routeHeader, ActionRequestValue parentRequest,

                         RuleDelegation ruleDelegation)

         {

                 String roleName = resp.getResolvedRoleName();

                 //RoleAttribute roleAttribute = resp.resolveRoleAttribute();

         RoleAttribute roleAttribute = null;

         if (resp.isUsingRole()) {

             //get correct extension definition

             roleAttribute = (RoleAttribute) GlobalResourceLoader.getResourceLoader().getObject(new ObjectDefinition(

                     resp.getRoleAttributeName()));

             if (roleAttribute instanceof XmlConfiguredAttribute) {

                 ExtensionDefinition roleAttributeDefinition = null;

                 for (RuleTemplateAttribute ruleTemplateAttribute : rule.getRuleTemplate().getRuleTemplateAttributes()) {

                     if (resp.getRoleAttributeName().equals(ruleTemplateAttribute.getRuleAttribute().getResourceDescriptor())) {

                         roleAttributeDefinition = ruleTemplateAttribute.getRuleAttribute();

                         break;

                     }

                 }

                 ((XmlConfiguredAttribute)roleAttribute).setExtensionDefinition(roleAttributeDefinition);

             }

         }

                 //setRuleAttribute(roleAttribute, rule, resp.getRoleAttributeName());

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

                 if (parentRequest != null && parentRequest.getQualifiedRoleName() != null) {

                         qualifiedRoleNames.add(parentRequest.getQualifiedRoleName());

                 } else {

                 qualifiedRoleNames.addAll(roleAttribute.getQualifiedRoleNames(roleName, context.getDocumentContent()));

                 }

         for (String qualifiedRoleName : qualifiedRoleNames) {

             if (parentRequest == null && isDuplicateActionRequestDetected(routeHeader, context.getNodeInstance(), resp, qualifiedRoleName)) {

                 continue;

             }

             ResolvedQualifiedRole resolvedRole = roleAttribute.resolveQualifiedRole(context, roleName, qualifiedRoleName);

             RoleRecipient recipient = new RoleRecipient(roleName, qualifiedRoleName, resolvedRole);

             if (parentRequest == null) {

                 ActionRequestValue roleRequest = arFactory.addRoleRequest(recipient, resp.getActionRequestedCd(),

                         resp.getApprovePolicy(), resp.getPriority(), resp.getResponsibilityId(), rule.isForceAction(),

                         rule.getDescription(), rule.getId());

                 List<RuleDelegation> ruleDelegations = getRuleService().getRuleDelegationsByResponsibiltityId(resp.getResponsibilityId());

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

                     // create delegations for all the children

                     for (ActionRequestValue request : roleRequest.getChildrenRequests()) {

                         for (RuleDelegation childRuleDelegation : ruleDelegations) {

                             buildDelegationGraph(arFactory, context, childRuleDelegation.getDelegationRule(), routeHeader, request, childRuleDelegation);

                         }

                     }

                 }

             } else {

                 arFactory.addDelegationRoleRequest(parentRequest, resp.getApprovePolicy(), recipient, resp.getResponsibilityId(), rule.isForceAction(), ruleDelegation.getDelegationType(), rule.getDescription(), rule.getId());

             }

         }

         }

         /**

          * Determines if the attribute has a setRuleAttribute method and then sets the value appropriately if it does.

          */

         /*private void setRuleAttribute(RoleAttribute roleAttribute, org.kuali.rice.kew.api.rule.Rule rule, String roleAttributeName) {

                 // look for a setRuleAttribute method on the RoleAttribute

                 Method setRuleAttributeMethod = null;

                 try {

                         setRuleAttributeMethod = roleAttribute.getClass().getMethod("setExtensionDefinition", RuleAttribute.class);

                 } catch (NoSuchMethodException e) {

             LOG.info("method setRuleAttribute not found on " + RuleAttribute.class.getName());

         }

                 if (setRuleAttributeMethod == null) {

                         return;

                 }

                 // find the RuleAttribute by looking through the RuleTemplate

                 RuleTemplate ruleTemplate = rule.getRuleTemplate();

                 if (ruleTemplate != null) {

             for (RuleTemplateAttribute ruleTemplateAttribute : ruleTemplate.getActiveRuleTemplateAttributes())

             {

                 RuleAttribute ruleAttribute = ExtensionUtils.loadExtension(ruleTemplateAttribute.getRuleAttribute());

                 if (ruleAttribute.getResourceDescriptor().equals(roleAttributeName))

                 {

                     // this is our RuleAttribute!

                     try

                     {

                         setRuleAttributeMethod.invoke(roleAttribute, ruleAttribute);

                         break;

                     } catch (Exception e)

                     {

                         throw new WorkflowRuntimeException("Failed to set ExtensionDefinition on our RoleAttribute!", e);

                     }

                 }

             }

                 }

         }*/

         /**

          * Generates action requests for a non-role responsibility, either a user or workgroup

      * @throws org.kuali.rice.kew.api.exception.WorkflowException

      */

         private void makeActionRequest(ActionRequestFactory arFactory, RouteContext context, org.kuali.rice.kew.api.rule.Rule rule, DocumentRouteHeaderValue routeHeader, org.kuali.rice.kew.api.rule.RuleResponsibility resp, ActionRequestValue parentRequest,

                         RuleDelegation ruleDelegation) {

                 if (parentRequest == null && isDuplicateActionRequestDetected(routeHeader, context.getNodeInstance(), resp, null)) {

                         return;

                 }

                 Recipient recipient;

                 if (resp.isUsingPrincipal()) {

                 recipient = new KimPrincipalRecipient(resp.getPrincipalId());

         } else if (resp.isUsingGroup()) {

             recipient = new KimGroupRecipient(resp.getGroupId());

         } else {

             throw new RiceRuntimeException("Illegal rule responsibility type encountered");

         }

                 ActionRequestValue actionRequest;

                 if (parentRequest == null) {

                         actionRequest = arFactory.addRootActionRequest(resp.getActionRequestedCd(),

                                         resp.getPriority(),

                                         recipient,

                                         rule.getDescription(),

                                         resp.getResponsibilityId(),

                                         rule.isForceAction(),

                                         resp.getApprovePolicy(),

                                         rule.getId());

                         List<RuleDelegation> ruleDelegations = getRuleService().getRuleDelegationsByResponsibiltityId(

                     resp.getResponsibilityId());

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

                                 for (RuleDelegation childRuleDelegation : ruleDelegations) {

                                         buildDelegationGraph(arFactory, context, childRuleDelegation.getDelegationRule(), routeHeader, actionRequest, childRuleDelegation);

                                 }

                         }

                 } else {

                         arFactory.addDelegationRequest(parentRequest, recipient, resp.getResponsibilityId(), rule.isForceAction(), ruleDelegation.getDelegationType(), rule.getDescription(), rule.getId());

                 }

         }

         private boolean isDuplicateActionRequestDetected(DocumentRouteHeaderValue routeHeader, RouteNodeInstance nodeInstance, org.kuali.rice.kew.api.rule.RuleResponsibility resp, String qualifiedRoleName) {

                 List<ActionRequestValue> requests = getActionRequestService().findByStatusAndDocId(ActionRequestStatus.DONE.getCode(), routeHeader.getDocumentId());

         for (ActionRequestValue request : requests)

         {

             if (((nodeInstance != null

                     && request.getNodeInstance() != null

                     && request.getNodeInstance().getRouteNodeInstanceId().equals(nodeInstance.getRouteNodeInstanceId())

                  ) || request.getRouteLevel().equals(routeHeader.getDocRouteLevel())

                 )

                     && request.getResponsibilityId().equals(resp.getResponsibilityId())

                         && ObjectUtils.equals(request.getQualifiedRoleName(), qualifiedRoleName)) {

                 return true;

             }

         }

                 return false;

         }

         public RuleService getRuleService() {

                 return KewApiServiceLocator.getRuleService();

         }

         private ActionRequestService getActionRequestService() {

                 return KEWServiceLocator.getActionRequestService();

         }

         public int getNumberOfMatchingRules() {

                 return selectedRules;

         }

 }