/**
    * 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.booleanmessage.ast;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  
  import org.antlr.runtime.ANTLRStringStream;
  import org.antlr.runtime.CommonTokenStream;
  import org.antlr.runtime.RecognitionException;
  import org.antlr.runtime.Token;
  import org.antlr.runtime.tree.CommonTreeAdaptor;
  import org.antlr.runtime.tree.TreeAdaptor;
  
  import org.kuali.student.common.messagebuilder.booleanmessage.BooleanMessage;
  import org.kuali.student.common.messagebuilder.booleanmessage.ast.exceptions.BooleanFunctionException;
  import org.kuali.student.common.messagebuilder.booleanmessage.ast.parsers.BooleanFunctionLexer;
  import org.kuali.student.common.messagebuilder.booleanmessage.ast.parsers.BooleanFunctionParser;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  public class BinaryMessageTree {
      /** SLF4J logging framework */
      final static Logger logger = LoggerFactory.getLogger(BinaryMessageTree.class);
  
      private BooleanNode root;
  	private ArrayList<BooleanNode> nodes;
  	private String language;
  	
  	private Map<String, ? extends BooleanMessage> nodeMessageMap;
  	
  	private static final TreeAdaptor adaptor = new CommonTreeAdaptor() {
  		public Object create(Token payload) {
  			return new BooleanNode(payload);
  		}
  	};
  	
  	/**
  	 * Constructor.
  	 */
  	public BinaryMessageTree() {
  		language = Locale.getDefault().getLanguage();
  		nodes = new ArrayList<BooleanNode>();
  	}
  
  	/**
  	 * Constructor. 
  	 * Creates a new binary message tree for the in the specified language
  	 * for the boolean message map.
  	 *  
  	 * @param messageLanguage Language for the message 
  	 * @param messageMap map of boolean messages
  	 */
  	public BinaryMessageTree(String language, Map<String, ? extends BooleanMessage> messageMap) {
  		this.language = language;
  		nodeMessageMap = messageMap;
  		nodes = new ArrayList<BooleanNode>();
  	}
  	
  	/**
  	 * <p>Builds the binary message tree from the <code>booleanFunction</code>.</p>
  	 * <p>Order of boolean operation: ANDs before ORs and 
  	 * operations inside parentheses before anything else.</p>
  	 * <p>Example: A AND B OR C AND D evaluates to (A AND B) OR (C AND D).</p>
  	 * 
  	 * @param booleanFunction: Boolean expression 
  	 * @return Root boolean node
  	 */
  	public BooleanNode buildTree(String booleanFunction){
  		if (booleanFunction == null || booleanFunction.trim().isEmpty()) {
  			return null;
  		}
  		
  		BooleanFunctionLexer lex = new BooleanFunctionLexer(new ANTLRStringStream(booleanFunction) );
  		CommonTokenStream tokens = new CommonTokenStream(lex);
  		
  		BooleanFunctionParser parser = new BooleanFunctionParser(tokens);
  		parser.setTreeAdaptor(adaptor);
  		
  		// parse the expression
  		BooleanFunctionParser.booleanExpression_return booleanExpression = null;
          try {
          	booleanExpression = parser.booleanExpression();  
         } catch (RecognitionException e)  {
         	String parserErrorMsg = parser.getErrorMessage(e, parser.getTokenNames());
         	String errorMsg = "Boolean Function Parser Error. " +
         			"Invalid Boolean Expression: '" + booleanFunction + "'; " + parserErrorMsg;  
         	throw new BooleanFunctionException(errorMsg, e);
         }
         // get the root of the AST from the parsed expression
         return root = (BooleanNode) booleanExpression.getTree();
 	}
 	
 	/** 
 	 * This method walks the tree depth first, while setting node values with 
 	 * setNode(). Setting a nodes parent and adding the node to the ArrayList 
 	 * for later. This method has to be called after buildTree. 
 	 * 
 	 * @param bnode Boolean node
 	 * @param parent Parent boolean node
 	 */
 	public void traverseTreePostOrder(BooleanNode bnode, BooleanNode parent) {
 		for (int i = 0; i < bnode.getChildCount(); i++) {
 			traverseTreePostOrder((BooleanNode) bnode.getChild(i), bnode);
 		}
 		setNode(bnode);
 		if (parent != null) {
 			bnode.setParent(parent);
 		}
 
 		if(logger.isDebugEnabled()) {
 		    logger.debug(bnode.getText());
 		}
 		nodes.add(bnode);
 	}
 
 	/**
 	 * This method walks the tree depth first. Setting a nodes parent and 
 	 * adding the node to the ArrayList for later. 
 	 * This method has to be called after buildTree. 
 	 * 
 	 * @param bnode Boolean node
 	 * @param parent Parent boolean node
 	 */
 	public void traverseTreePostOrderDontSetNode(BooleanNode bnode, BooleanNode parent) {
 		if (bnode != null) {
 			for (int i = 0; i < bnode.getChildCount(); i++ ) {
 				traverseTreePostOrderDontSetNode((BooleanNode)bnode.getChild(i), bnode);
 			}
 
 			if (parent != null) {
 				bnode.setParent(parent);
 			}
 		    
 			if(logger.isDebugEnabled()) {
 				logger.debug(bnode.getText());
 			}
 			nodes.add(bnode);
 		}
 	}
 
 	/** 
 	 * Here we set the value(true or false) and the failure message for each node. 
 	 * Setting the failure message here does not mean the function failed, the node just holds the message. 
 	 * Failure is determined by the rules engine which will extract the failure message.
 	 * 
 	 * @param bnode Boolean node
 	 */
 	private void setNode(BooleanNode bnode) {
 		bnode.setLanguage(language);
 		
 		if (bnode.getChildCount() == 0) {
 			// If node is a leaf then set value and message
 			BooleanMessage message = nodeMessageMap.get(bnode.getLabel());
 			bnode.setValue(message.isSuccesful());
 			bnode.setNodeMessage(message.getMessage());
 		}
 		else {
 			// If node is intermediate, compute value and set it
 			BooleanNode child0 = (BooleanNode)bnode.getChild(0);
 			BooleanNode child1 = (BooleanNode)bnode.getChild(1);
 			
 			if ( bnode.getLabel().equalsIgnoreCase("+") ) {
 				// OR node
 				Boolean newValue = child0.getValue() || child1.getValue();
 				bnode.setValue(newValue);
 				bnode.setNodeMessage("null");
 			}
 			else if ( bnode.getLabel().equalsIgnoreCase("*") ) {
 				// AND node
 				Boolean newValue = child0.getValue() && child1.getValue();
 				bnode.setValue(newValue);
 				bnode.setNodeMessage("null");
 			}
 		}
 	}
 	
 	/**
 	 * Gets all boolean nodes.
 	 * 
 	 * @return All boolean nodes
 	 */
 	public List<BooleanNode> getAllNodes() {
 		return nodes;
 	}
 
 	/**
 	 * Gets the root boolean node.
 	 * 
 	 * @return Root boolean node
 	 */
 	public BooleanNode getRoot() {
 		return root;
 	}
 }