package com.sri.emo.dbobj.model_tree;
   
   import com.jcorporate.expresso.core.controller.ExpressoResponse;
   import com.jcorporate.expresso.core.dataobjects.jdbc.JoinedDataObject;
   import com.jcorporate.expresso.core.db.DBException;
   import com.sri.emo.controller.AddNodeAction;
   import com.sri.emo.dbobj.Attribute;
   import com.sri.emo.dbobj.Node;
   import com.sri.emo.dbobj.Part;
  import com.sri.emo.dbobj.PartsFactory;
  import org.apache.log4j.Logger;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  /***
   * Factory that builds a tree hierarchy from the Nodes.  Included are parts, attributes,
   * relations, etc.  If there is a problem with the Model hierarchy the bug is located
   * here since this class is responsible for the construction.
   *
   * @author Michael Rimov
   */
  public class DefaultModelFactory {
  
      /***
       * The single instance of the logger.
       */
      private static final Logger LOG = Logger.getLogger(DefaultModelFactory.class);
  
      /***
       * Root node instance to the hierarchy.
       */
      private final Node root;
  
      /***
       * Maximum levels to recurse.
       */
      private final int MAX_LEVELS;
  
      /***
       * Constructs a Default Model Factory.
       *
       * @param rootNode         Node the base node that we're going create the tree from.
       * @param response         ControllerResponse.
       * @param maxNestingLevels int
       */
      public DefaultModelFactory(final Node rootNode, final ExpressoResponse response, int maxNestingLevels) {
          assert maxNestingLevels > 0;
          assert rootNode != null;
          assert response != null;
  
          MAX_LEVELS = maxNestingLevels;
          root = rootNode;
      }
  
      /***
       * Function that builds the actual model that has been defined in the
       * constructor.
       *
       * @return Model the resulting model.
       */
      public Model buildModel() {
  
          long startTime = System.currentTimeMillis();
  
          //Start the building
          ModelNode modelNode = buildModelNode(null, root, 0);
  
          //Grab the result
          DefaultModel result = new DefaultModel(modelNode);
          if (LOG.isInfoEnabled()) {
              LOG.info("Model building complete.  Time taken: " + (System.currentTimeMillis() - startTime) + " ms.");
          }
          return result;
      }
  
      /***
       * Recursively constructs a model node given a dbobj.Node instance.
       *
       * @param parent         MutableModelNode parent.  May be null if root.
       * @param dataNode       Node the current node to render.
       * @param currentNesting int the current nesting level.
       * @return ModelNode or null if we are past the current nesting level
       */
      private ModelNode buildModelNode(final MutableModelNode parent, final Node dataNode, int currentNesting) {
  
          DefaultModelNode currentModelNode;
          if (parent != null) {
              currentModelNode = new DefaultModelNode(dataNode, parent);
          } else {
              currentModelNode = new DefaultModelNode(dataNode);
          }
          
          
  
          try {
              Part[] parts = PartsFactory.getParts(dataNode.getNodeType());
              addParts(currentModelNode, dataNode, currentNesting, parts);
 
         } catch (DBException ex) {
             LOG.error("Error building model tree", ex);
             throw new IllegalStateException(
                     "Unable to build model tree. " + ex.getMessage() + " more details have been logged");
         }
 
         return currentModelNode;
     }
 
 
     /***
      * Checks if the current data node already exists further up the tree.  We
      * don't use a standard hashmap because we only care about loops above us
      * not in siblings.
      *
      * @param currentDataNode  Node the current data node that we're considering
      *                         recursinv into.
      * @param currentModelNode DefaultModelNode the current model node we've just
      *                         added and we're concerned about checking his parents.
      * @return boolean true if the node is recursive.
      */
     private boolean isNodeRecursive(final Node currentDataNode, final DefaultModelNode currentModelNode) {
         if (getRecursiveNodeReference(currentDataNode, currentModelNode) == null) {
             return false;
         } else {
             return true;
         }
     }
 
 
     /***
      * Retrieve the instance of the node further up the tree hierarchy
      * that is a recursive reference.
      *
      * @param currentDataNode  Node the data node we're examining.
      * @param currentModelNode DefaultModelNode the current node in the model
      *                         tree that goes along with the data node.
      * @return DefaultModelNode or null if there is no such node found.
      */
     private DefaultModelNode getRecursiveNodeReference(final Node currentDataNode,
                                                        final DefaultModelNode currentModelNode) {
         //Initialize the current examining node.
         ModelNode currentExaminingNode = currentModelNode.getParent();
 
         //While we still have nodes to traverse up the tree.
         while (currentExaminingNode != ModelNode.NO_PARENT) {
 
             //If we have a node instance.
             //And it is equal node then we have a  recursive node.
             if (currentExaminingNode.getVisitable() instanceof Node && currentDataNode.equals(currentExaminingNode.getVisitable())) {
                     assert currentExaminingNode instanceof DefaultModelNode;
                     return (DefaultModelNode) currentExaminingNode;
             }
 
             //Otherwise we just continue up the tree
             currentExaminingNode = currentExaminingNode.getParent();
         }
 
         //We have not found a recursive node.
         return null;
 
     }
 
     /***
      * Add the parts to the tree.  May end up with a recursive call if
      * a part contains a relation to a subnode.
      *
      * @param currentModelNode DefaultModelNode
      * @param dataNode         Node
      * @param currentNesting   int
      * @param parts            The parts to add. (Prefetched in an array)
      * @return True if we found at least one value to insert in the nested
      *         nodes.  If we didn't then this current node fill status is going to
      *         be empty.
      * @throws DBException upon database query error.
      */
     private boolean addParts(final DefaultModelNode currentModelNode,
                              final Node dataNode,
                              final int currentNesting,
                              Part[] parts) throws DBException {
 
         boolean foundAtLeastOneValueForNode = false;
         if (parts == null) {
             throw new DBException("No parts found for model type: " + dataNode.getNodeType());
         }
 
         List allAttribs = dataNode.getAttributes();
         List allRelations = dataNode.getRawRelatedUsingDataObjects();
 
         // ignore the reflexive relations formed when src node is part of
         // another node
         // @todo using this list iAmAPartOf, attach an artificial Part to bottom of Node, just like flat view has
 //        List iAmAPartOf = AddNodeAction.filterIamPartOfJoinedRelations(allRelations);
 
         //Iterate through all the parts.
         for (int i = 0; i < parts.length; i++) {
             Part part = parts[i];
             ArrayList attribsForThisPart = new ArrayList();
             ArrayList relatedJoinedForThisPart = new ArrayList();
 
             //If the part is an owned attribute
             if (part.isOwnedAttribute()) {
                 AddNodeAction.filterAttribs(allAttribs, part, attribsForThisPart);
                 foundAtLeastOneValueForNode |=
                         addOwnedAttribute(currentModelNode, part, attribsForThisPart);
             } else {
                 AddNodeAction.filterJoinedDataObjectRelations(allRelations, part, relatedJoinedForThisPart);
 //                AddNodeAction.filterRelations(allRelations, part, relatedMultiesForThisPart);
                 foundAtLeastOneValueForNode |= addSharedAttribute(currentModelNode, currentNesting, part,
                         relatedJoinedForThisPart);
             }
 
             allAttribs.removeAll(attribsForThisPart);
             allRelations.removeAll(relatedJoinedForThisPart);
         } // for all parts
 
         //If somewhere we didn't find any filled attributes then
         if (!foundAtLeastOneValueForNode) {
 
             //Set the current node fills status to empty.
             currentModelNode.setModelFilledStatus(ModelFillStatus.EMPTY);
         }
 
         // all relations and attribs should have been removed by now; any remaining are 'strays'
         AddNodeAction.deleteJoinedRelations(allRelations, dataNode);
         AddNodeAction.deleteAttributes(allAttribs, dataNode);
 
         return foundAtLeastOneValueForNode;
     }
 
     /***
      * Adds the shared attribute to the tree.
      *
      * @param currentModelNode DefaultModelNode the current data model node we're dealing with.
      * @param currentNesting   int the current nesting level.  If we go over MAX_LEVELS then
      *                         we end depth traversal of the model tree.
      * @param part             Part
      * @param relations        The prefetched list of relations to add.
      * @return boolean true if there are children to descend into.
      * @throws NullPointerException
      * @throws DBException
      */
     private boolean addSharedAttribute(DefaultModelNode currentModelNode,
                                        int currentNesting,
                                        Part part,
                                        List relations) throws NullPointerException, DBException {
 
         boolean returnValue = false;
         //IF we got here then we are a shared attribute.
         DefaultModelNode partToNest = new DefaultModelNode(part, currentModelNode);
 
         //Get the related nodes.
 
         //If there are no related nodes then set the fill status to empty
         //and continue to the next node.
         if (relations.size() == 0) {
             partToNest.setModelFilledStatus(ModelFillStatus.EMPTY);
             return false;
         }
 
         //Iterate through the related nodes.
         for (Iterator iterator = relations.iterator(); iterator.hasNext();) {
             JoinedDataObject oneJoin = (JoinedDataObject) iterator.next();
             Node aRelatedNode = (Node) oneJoin.getNestedFromFieldName("Node." + Node.NODE_ID);
 
             DefaultModelNode nested = new DefaultModelNode(aRelatedNode, partToNest);
 
             //If we are recursive
             if (isNodeRecursive(aRelatedNode, nested)) {
                 //Set the recursive node completion status.
                 ModelNode recursedNode = getRecursiveNodeReference(aRelatedNode, nested);
                 assert recursedNode != null;
                 if (recursedNode == null) {
                     throw new NullPointerException("getRecursiveNode() should not have returned Null if the node "
                             + "is indeed recursive");
                 }
                 NodeCompletionStatus recursiveNodeStatus = new NodeCompletionStatus(recursedNode);
                 nested.setNodeCompletionStatus(recursiveNodeStatus);
                 nested.setModelFilledStatus(ModelFillStatus.PARTIALLY_FILLED);
 
                 //Else if we are under the maximum levels to prevent truncation
             } else {
                 if (currentNesting < MAX_LEVELS) {
 
                     //Set node status.
                     nested.setNodeCompletionStatus(NodeCompletionStatus.COMPLETE_NODE);
                     nested.setModelFilledStatus(ModelFillStatus.PARTIALLY_FILLED);
 
                     //Check to see if there are any parts defined for the
                     //nested node
                     Part[] nestedParts = PartsFactory.getParts(aRelatedNode.getNodeType());
                     if (nestedParts.length > 0) {
                         //If there are, then recurse
                         returnValue |= addParts(nested, aRelatedNode, (currentNesting + 1), nestedParts);
                     } else {
                         //Otherwise we have an empty part -- continue afterwards
                         nested.setModelFilledStatus(ModelFillStatus.EMPTY);
                     }
 
                     //Otherwise truncate the node and continue
                 } else {
                     //Set truncated status on the node
                     nested.setNodeCompletionStatus(NodeCompletionStatus.TRUNCATED_NODE);
                     nested.setModelFilledStatus(ModelFillStatus.PARTIALLY_FILLED);
                 }
             }
         } // for all related nodes.
         return returnValue;
     }
     
 
     /***
      * Adds an owned attribute (Part) to the current model node.
      *
      * @param currentModelNode DefaultModelNode the current model node
      *                         to work with.
      * @param part             Part the part we're examining.
      * @param attribs          a prefetched list of attributes.
      * @return boolean true if we have found a part for the node.
      */
     private boolean addOwnedAttribute(DefaultModelNode currentModelNode, Part part, List attribs) {
         boolean foundAtLeastOneValueForNode = false;
 
         //Handle the attribute
         if (attribs.size() == 1) {
             Attribute attrib = (Attribute) attribs.get(0);
             attrib.setExplicitPart(part);
             DefaultModelNode parentForSingleAttribute = new DefaultModelNode(part, currentModelNode);
             DefaultModelNode subNode = new DefaultModelNode(attrib, parentForSingleAttribute);
             foundAtLeastOneValueForNode = true;
             subNode.setModelFilledStatus(ModelFillStatus.PARTIALLY_FILLED);
         } else if (attribs.size() == 0) {
             DefaultModelNode newNode = new DefaultModelNode(part, currentModelNode);
             foundAtLeastOneValueForNode |= false;
             newNode.setModelFilledStatus(ModelFillStatus.EMPTY);
         } else {
             DefaultModelNode parentForMultiAttributes = new DefaultModelNode(part, currentModelNode);
 
             for (Iterator iterator = attribs.iterator(); iterator.hasNext();) {
                 Attribute attrib = (Attribute) iterator.next();
                 attrib.setExplicitPart(part);
                 DefaultModelNode newNode = new DefaultModelNode(attrib, parentForMultiAttributes);
                 foundAtLeastOneValueForNode = true;
                 newNode.setModelFilledStatus(ModelFillStatus.PARTIALLY_FILLED);
             }
         }
 
         return foundAtLeastOneValueForNode;
     }
 }