/**

  * 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.common.messagebuilder.impl;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import org.apache.velocity.exception.VelocityException;

 import org.kuali.student.common.messagebuilder.MessageTreeBuilder;

 import org.kuali.student.common.messagebuilder.booleanmessage.BooleanMessage;

 import org.kuali.student.common.messagebuilder.booleanmessage.ast.BinaryMessageTree;

 import org.kuali.student.common.messagebuilder.booleanmessage.ast.BooleanFunction;

 import org.kuali.student.common.messagebuilder.booleanmessage.ast.BooleanFunctionResult;

 import org.kuali.student.common.messagebuilder.booleanmessage.ast.BooleanMessageImpl;

 import org.kuali.student.common.messagebuilder.booleanmessage.ast.BooleanNode;

 import org.kuali.student.common.messagebuilder.booleanmessage.ast.exceptions.BooleanFunctionException;

 import org.kuali.student.common.messagebuilder.impl.exceptions.MessageBuilderException;

 import org.kuali.student.common.util.VelocityTemplateEngine;

 /**

  * This <code>AbstractMessageBuilder</code> class builds a summary message 

  * from plain strings or Velocity template messages. Summary message is built 

  * from analysing the outcome of a boolean expression. 

  * If no language is specified then the default language locale is used. 

  */

 public abstract class AbstractMessageBuilder {

     private final VelocityTemplateEngine templateEngine = new VelocityTemplateEngine();

     private String booleanExpression;

     private Map<String, ? extends BooleanMessage> messageMap;

     private Map<String, Object> messageContextMap;

     private String language;

     private MessageTreeBuilder treeNodeMessageBuilder;

     /**

      * Constructor.

      * 

      * @param language Language

      * @param treeNodeMessageBuilder AST tree node Message builder

      */

     public AbstractMessageBuilder(final String language, final MessageTreeBuilder treeNodeMessageBuilder) {

         this.language = language; 

         this.treeNodeMessageBuilder = treeNodeMessageBuilder;

     }

         /**

      * <p>Builds and evaluates a boolean expression and returns the message and result 

      * of the expression. Messages in the <code>messageMap</code> can 

      * also contain VTL (Velocity Template Language) but without any VTL keys</p>

      * <p><b>Note:</b> Order of boolean operation: ANDs before ORs and operations 

      * inside parentheses before anything else.</p> 

          * Example 1: 'A AND B OR C AND D' internally evaluates to '(A AND B) OR (C AND D)'

          * <pre><code>booleanExpression</code> = "A*B+C*D"</pre>

      * Example 2: '(M1 AND M2) OR M3' 

      * <pre><code>booleanExpression</code> = "(M1*M2)+M3"</pre>

      * 

      * @param booleanExpression Boolean expression

      * @param messageMap Contains a map of messages (or VTL)

      * @return Boolean function result

      */

     public BooleanFunctionResult build(

                     final String booleanExpression, 

                     final Map<String, ? extends BooleanMessage> messageMap) {

             this.booleanExpression = booleanExpression;

             this.messageMap = messageMap;

             return build();

     }

     /**

      * <p>Builds and evaluates a boolean expression and returns the message and result 

      * of the expression. Messages in the <code>messageMap</code> can 

      * also contain VTL (Velocity Template Language). 

      * <code>messageContextMap</code> contains Velocity key/value entries 

      * referenced in the <code>messageMap</code>.</p>

      * <p><b>Note:</b> Order of boolean operation: ANDs before ORs and operations 

      * inside parentheses before anything else.</p> 

          * Example 1: 'A AND B OR C AND D' internally evaluates to '(A AND B) OR (C AND D)'

          * <pre><code>booleanExpression</code> = "A*B+C*D"</pre>

      * Example 2: '(M1 AND M2) OR M3' 

      * <pre><code>booleanExpression</code> = "(M1*M2)+M3"</pre>

      * 

      * 

      * @param booleanExpression Boolean expression

      * @param messageMap Contains a map of messages (or VTL)

      * @param messageContextMap Message contact map for Velocity Template Engine

      * @return Boolean function result

      * @throws MessageBuilderException Errors building message

      */

     public BooleanFunctionResult build(

                     final String booleanExpression, 

                     final Map<String, ? extends BooleanMessage> messageMap, 

                     final Map<String, Object> messageContextMap) {

             this.booleanExpression = booleanExpression;

             this.messageMap = messageMap;

             this.messageContextMap = messageContextMap;

             return build();

     }

     public BooleanFunctionResult build() {

             BinaryMessageTree astTree = null;

         try {

             // set the functionString and Maps from the proposition container

                 Map<String, BooleanMessage> nodeMessageMap = buildMessageMap();

             // go parse function in buildTree

             astTree = new BinaryMessageTree(this.language, nodeMessageMap);

             BooleanNode root = astTree.buildTree(this.booleanExpression);

             astTree.traverseTreePostOrder(root, null);

             List<BooleanNode> treeNodes = astTree.getAllNodes();

             // tree node order in the list is important for building 

             // the success and failure message

             this.treeNodeMessageBuilder.buildMessage(treeNodes);

         } catch(VelocityException e) {

             throw new MessageBuilderException("Building Velocity message failed: " + e.getMessage(), e);

             } catch (BooleanFunctionException e) {

             throw new MessageBuilderException("Building message failed: " + e.getMessage(), e);

         }

         // This is the final rule report message summary

         String message = astTree.getRoot().getNodeMessage();

         Boolean result = astTree.getRoot().getValue();

                 // Removed starting and ending brackets if they are the only brackets in the message

         if (message.startsWith("(") && message.endsWith(")") && 

                                 message.replaceAll("[^(]","").length() == 1 &&

                                 message.replaceAll("[^)]","").length() == 1) {

                         message = message.substring(1, message.length()-1);

                 }

         return new BooleanFunctionResult(this.booleanExpression, result, message);

     }

     /**

      * Builds message map. Also builds message map using velocity templates.

      * 

      * @return Boolean message map

      */

     private Map<String, BooleanMessage> buildMessageMap() {

             Map<String, BooleanMessage> nodeMessageMap = new HashMap<String, BooleanMessage>();

         if (this.booleanExpression == null || this.booleanExpression.isEmpty()) {

                 throw new MessageBuilderException("Boolean expression is null");

         }

         BooleanFunction func = new BooleanFunction(this.booleanExpression);

         List<String> funcVars = func.getVariables();

             if(funcVars == null || funcVars.isEmpty()) {

                     throw new MessageBuilderException("Boolean function variables are null or empty. Boolean expression: " + this.booleanExpression);

             } 

         for (String id : funcVars) {

                 if(id == null) {

                         throw new MessageBuilderException("Boolean variable id is null or empty. Boolean variable ids: " + funcVars);

                 } 

                 BooleanMessage message = this.messageMap.get(id);

                 if (message == null) {

                         throw new MessageBuilderException("Boolean message is null for id='" + id + "'");

                 }

                 BooleanMessage booleanMessage = buildMessage(message);

             nodeMessageMap.put(id, booleanMessage);

         }

         return nodeMessageMap;

     }

     /**

      * Builds a failure/success message using the Velocity template engine.

      * 

      * @param message Boolean failure/success message

      * @return

      */

     private BooleanMessage buildMessage(BooleanMessage message) {

                 String msg = message.getMessage();

                 if(msg != null) {

                     msg = this.templateEngine.evaluate(this.messageContextMap, msg);

                 }

             return new BooleanMessageImpl(message.getMessageId(), message.isSuccesful(), msg);

     }

 }