/**

  * 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.kuali.rice.kew.engine.RouteContext;

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

 import org.kuali.rice.kew.rule.bo.RuleAttribute;

 import org.kuali.rice.kew.rule.bo.RuleTemplateAttributeBo;

 import org.kuali.rice.kew.rule.xmlrouting.GenericXMLRuleAttribute;

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

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

 import java.util.ArrayList;

 import java.util.List;

 /**

  * Standard rule expression implementation that evaluates the attributes associated with the rule definition 

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

  */

 class WorkflowAttributeRuleExpression implements RuleExpression {

         public RuleExpressionResult evaluate(Rule rule, RouteContext context) {

                 org.kuali.rice.kew.api.rule.Rule ruleDefinition =

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

         boolean match = isMatch(ruleDefinition, context.getDocumentContent());

         if (match) {

             return new RuleExpressionResult(rule, match, ruleDefinition.getRuleResponsibilities());

         }

                 return new RuleExpressionResult(rule, match);

     }

     public boolean isMatch(org.kuali.rice.kew.api.rule.Rule ruleDefinition, DocumentContent docContent) {

         if (ruleDefinition.getRuleTemplate() == null) {

             // this can happen if neither rule template nor expression was specified in the rule definition

             // because WorkflowAttributeRuleExpression is the default expression implementation, we should

             // handle this here in order to support rules that fire unconditionally (and just return a statically

             // configured list of responsibilities)

             // the alternative is to either detect this situation in the rule xml parser or RuleImpl, and either substitute

             // a different RuleExpression implementation (a "default default" one) in the configuration, or at runtime,

             // that simply implements the one-liner of returning responsibilities.

             // doing this in the existing WorkflowAttributeRuleExpression implementation introduces the least change

             // or compatibilities issues, and avoids pushing compensating logic into RuleImpl

             return true;

         }

         RuleBaseValues rule = KEWServiceLocator.getRuleService().getRuleByName(ruleDefinition.getName());

         for (RuleTemplateAttributeBo ruleTemplateAttribute : rule.getRuleTemplate().getActiveRuleTemplateAttributes()) {

             if (!ruleTemplateAttribute.isWorkflowAttribute()) {

                 continue;

             }

             WorkflowRuleAttribute routingAttribute = (WorkflowRuleAttribute) ruleTemplateAttribute.getWorkflowAttribute();

             RuleAttribute ruleAttribute = ruleTemplateAttribute.getRuleAttribute();

             if (ruleAttribute.getType().equals(KewApiConstants.RULE_XML_ATTRIBUTE_TYPE)) {

                 ((GenericXMLRuleAttribute) routingAttribute).setExtensionDefinition(RuleAttribute.to(ruleAttribute));

             }

             String className = ruleAttribute.getResourceDescriptor();

             List<RuleExtensionBo> editedRuleExtensions = new ArrayList();

             for (RuleExtensionBo extension : rule.getRuleExtensions()) {

                 if (extension.getRuleTemplateAttribute().getRuleAttribute().getResourceDescriptor().equals(className)) {

                     editedRuleExtensions.add(extension);

                 }

             }

             if (!routingAttribute.isMatch(docContent, editedRuleExtensions)) {

                 return false;

             }

         }

         return true;

     }

 }