package ca.uhn.hl7v2.util;
   
   import java.util.NoSuchElementException;
   
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   import ca.uhn.hl7v2.HL7Exception;
   import ca.uhn.hl7v2.model.Group;
  import ca.uhn.hl7v2.model.Message;
  import ca.uhn.hl7v2.model.Segment;
  import ca.uhn.hl7v2.model.Structure;
  
  /**
   * Iterates over all defined nodes (ie segments, groups) in a message, 
   * regardless of whether they have been instantiated previously.  This is a 
   * tricky process, because the number of nodes is infinite, due to infinitely 
   * repeating segments and groups.  See <code>next()</code> for details on 
   * how this is handled. 
   * 
   * This implementation assumes that the first segment in each group is present (as per
   * HL7 rules).  Specifically, when looking for a segment location, an empty group that has 
   * a spot for the segment will be overlooked if there is anything else before that spot. 
   * This may result in surprising (but sensible) behaviour if a message is missing the 
   * first segment in a group. 
   *  
   * @author Bryan Tripp
   */
  public class MessageIterator implements java.util.Iterator<Structure> {
  
      private Structure currentStructure; 
      private String direction;
      private Position next;
      private final boolean handleUnexpectedSegments;
      
      private static final Logger log = LoggerFactory.getLogger(MessageIterator.class);
      
      /* may add configurability later ... 
      private boolean findUpToFirstRequired;
      private boolean findFirstDescendentsOnly;
      
      public static final String WHOLE_GROUP;
      public static final String FIRST_DESCENDENTS_ONLY;
      public static final String UP_TO_FIRST_REQUIRED;
      */
       
      /** Creates a new instance of MessageIterator */
      public MessageIterator(Structure start, String direction, boolean handleUnexpectedSegments) {
          this.currentStructure = start;
          this.direction = direction;
          this.handleUnexpectedSegments = handleUnexpectedSegments;
      }
      
      /* for configurability (maybe to add later, replacing hard-coded options
        in nextFromEndOfGroup) ... 
      public void setSearchLevel(String level) {
          if (WHOLE_GROUP.equals(level)) {
              this.findUpToFirstRequired = false;
              this.findFirstDescendentsOnly = false;
          } else if (FIRST_DESCENDENTS_ONLY.equals(level)) {
              this.findUpToFirstRequired = false;
              this.findFirstDescendentsOnly = true;
          } else if (UP_TO_FIRST_REQUIRED.equals(level)) {
              this.findUpToFirstRequired = true;
              this.findFirstDescendentsOnly = false;
          } else {
              throw IllegalArgumentException(level + " is not a valid search level.  Should be WHOLE_GROUP, etc.");
          }     
      }
      
      public String getSearchLevel() {
          String level = WHOLE_GROUP;
          if (this.findFirstDescendentsOnly) {
              level = FIRST_DESCENDENTS_ONLY;
          } else if (this.findUpTpFirstRequired) {
              level = UP_TO_FIRST_REQUIRED;
          }
          return level;
      }*/
       
      
      /**
       * Returns true if another object exists in the iteration sequence.  
       */
      public boolean hasNext() {
          boolean has = true;
          if (next == null) {
              if (Group.class.isAssignableFrom(currentStructure.getClass())) {
                  groupNext((Group) currentStructure);
              } else {
                  Group parent = currentStructure.getParent();
                  Index i = getIndex(parent, currentStructure);
                  Position currentPosition = new Position(parent, i);
                  
                  try {                    
                      if (parent.isRepeating(i.name) && currentStructure.getName().equals(direction)) {
                          nextRep(currentPosition);
                      } else {
                          has = nextPosition(currentPosition, this.direction, this.handleUnexpectedSegments);
                     }
                 } catch (HL7Exception e) {
                     throw new Error("HL7Exception arising from bad index: " + e.getMessage());
                 }
             }
         }
         log.debug("MessageIterator.hasNext() in direction {}? {}", direction, has);
         return has;
     }
     
     /**
      * Sets next to the first child of the given group (iteration 
      * always proceeds from group to first child). 
      */
     private void groupNext(Group current) {
         next = new Position(current, current.getNames()[0], 0);
     }
     
     /**
      * Sets next to the next repetition of the current structure.  
      */ 
     private void nextRep(Position current) {        
         next = new Position(current.parent, current.index.name, current.index.rep + 1);
     }
     
     /**
      * Sets this.next to the next position in the message (from the given position), 
      * which could be the next sibling, a new segment, or the next rep 
      * of the parent.  See next() for details. 
      */
     private boolean nextPosition(Position currPos, String direction, boolean makeNewSegmentIfNeeded) throws HL7Exception {
         boolean nextExists = true;
         if (isLast(currPos)) {
             nextExists = nextFromGroupEnd(currPos, direction, makeNewSegmentIfNeeded);
         } else {
             nextSibling(currPos);
         }
         return nextExists;
     }
     
     /** Navigates from end of group */
     private boolean nextFromGroupEnd(Position currPos, String direction, boolean makeNewSegmentIfNeeded) throws HL7Exception {
         assert isLast(currPos);
         boolean nextExists = true;
         
         //the following conditional logic is a little convoluted -- its meant as an optimization 
         // i.e. trying to avoid calling matchExistsAfterCurrentPosition
         
         if (!makeNewSegmentIfNeeded && Message.class.isAssignableFrom(currPos.parent.getClass())) {
             nextExists = false;
         } else if (!makeNewSegmentIfNeeded || matchExistsAfterPosition(currPos, direction, false, true)) {     
             Group grandparent = currPos.parent.getParent();
             Index parentIndex = getIndex(grandparent, currPos.parent);
             Position parentPos = new Position(grandparent, parentIndex);
             
             try {
                 boolean parentRepeats = parentPos.parent.isRepeating(parentPos.index.name);                
                 if (parentRepeats && contains(parentPos.parent.get(parentPos.index.name, 0), direction, false, true)) {
                     nextRep(parentPos);
                 } else {
                     nextExists = nextPosition(parentPos, direction, makeNewSegmentIfNeeded);
                 }
             } catch (HL7Exception e) {
                 throw new Error("HL7Exception arising from bad index: " + e.getMessage());
             }
         } else {
             newSegment(currPos.parent, direction);
         }
         return nextExists;
     }
     
     /** 
      * A match exists for the given name somewhere after the given position (in the 
      * normal serialization order).  
      * @param pos the message position after which to look (note that this specifies 
      *      the message instance)
      * @param name the name of the structure to look for
      * @param firstDescendentsOnly only searches the first children of a group 
      * @param upToFirstRequired only searches the children of a group up to the first 
      *      required child (normally the first one).  This is used when we are parsing 
      *      a message in order and looking for a place to parse a particular segment -- 
      *      if the message is correct then it can't go after a required position of a 
      *      different name. 
      */
     public static boolean matchExistsAfterPosition(Position pos, String name, boolean firstDescendentsOnly, boolean upToFirstRequired) throws HL7Exception {
         boolean matchExists = false;
         
         //check next rep of self (if any)
         if (pos.parent.isRepeating(pos.index.name)) {            
             Structure s = pos.parent.get(pos.index.name, pos.index.rep);
             matchExists = contains(s, name, firstDescendentsOnly, upToFirstRequired);
         } 
         
         //check later siblings (if any) 
         if (!matchExists) {
             String[] siblings = pos.parent.getNames();
             boolean after = false;
             for (int i = 0; i < siblings.length && !matchExists; i++) {
                 if (after) {
                     matchExists = contains(pos.parent.get(siblings[i]), name, firstDescendentsOnly, upToFirstRequired);
                     if (upToFirstRequired && pos.parent.isRequired(siblings[i])) break; 
                 }
                 if (pos.index.name.equals(siblings[i])) after = true;                
             } 
         }
         
         //recurse to parent (if parent is not message root)
         if (!matchExists && !Message.class.isAssignableFrom(pos.parent.getClass())) {
             Group grandparent = pos.parent.getParent();
             Position parentPos = new Position(grandparent, getIndex(grandparent, pos.parent));
             matchExists = matchExistsAfterPosition(parentPos, name, firstDescendentsOnly, upToFirstRequired);
         }
         log.debug("Match exists after position {} for {}? {}", pos, name, matchExists);
         return matchExists;
     }
     
     /** 
      * Sets the next position to a new segment of the given name, within the 
      * given group. 
      */
     private void newSegment(Group parent, String name) throws HL7Exception {
         log.info("MessageIterator creating new segment: {}", name);
         parent.addNonstandardSegment(name);
         next = new Position(parent, parent.getNames()[parent.getNames().length-1], 0);
     }
     
     /** 
      * Determines whether the given structure matches the given name, or contains 
      * a child that does.  
      * @param s the structure to check 
      * @param name the name to look for 
      * @param firstDescendentsOnly only checks first descendents (i.e. first 
      *      child, first child of first child, etc.)  In theory the first child 
      *      of a group should always be present, and we don't use this method with 
      *      subsequent children because finding the next position within a group is 
      *      straightforward.  
      * @param upToFirstRequired only checks first descendents and of their siblings 
      *      up to the first required one.  This may be needed because in practice 
      *      some first children of groups are not required.  
      */
     public static boolean contains(Structure s, String name, boolean firstDescendentsOnly, boolean upToFirstRequired) {
         boolean contains = false;
         if (Segment.class.isAssignableFrom(s.getClass())) {
             if (s.getName().equals(name)) contains = true;            
         } else {
             Grouphref="../../../../ca/uhn/hl7v2/model/Group.html#Group">Group g = (Group) s;
             String[] names = g.getNames();
             for (int i = 0; i < names.length && !contains; i++) {
                 try {
                     contains = contains(g.get(names[i], 0), name, firstDescendentsOnly, upToFirstRequired);                
                     if (firstDescendentsOnly) break;
                     if (upToFirstRequired && g.isRequired(names[i])) break; 
                 } catch (HL7Exception e) {
                     throw new Error("HL7Exception due to bad index: " + e.getMessage());
                 }
             }
         }
         return contains;
     }
     
     /**
      * Tests whether the name of the given Index matches 
      * the name of the last child of the given group. 
      */
     public static boolean isLast(Position p) {
         String[] names = p.parent.getNames();
         return names[names.length-1].equals(p.index.name);
     }
     
     /**
      * Sets the next location to the next sibling of the given 
      * index.  
      */
     private void nextSibling(Position pos) {
         String[] names = pos.parent.getNames();
         int i = 0;
         for (; i < names.length && !names[i].equals(pos.index.name); i++) {}
         String nextName = names[i+1];
         
         this.next = new Position(pos.parent, nextName, 0);
     }
     
     /**
      * <p>Returns the next node in the message.  Sometimes the next node is 
      * ambiguous.  For example at the end of a repeating group, the next node 
      * may be the first segment in the next repetition of the group, or the 
      * next sibling, or an undeclared segment locally added to the group's end.  
      * Cases like this are disambiguated using getDirection(), which returns  
      * the name of the structure that we are "iterating towards".  
      * Usually we are "iterating towards" a segment of a certain name because we 
      * have a segment string that we would like to parse into that node. 
      * Here are the rules: </p>
      * <ol><li>If at a group, next means first child.</li>
      * <li>If at a non-repeating segment, next means next "position"</li>
      * <li>If at a repeating segment: if segment name matches 
      * direction then next means next rep, otherwise next means next "position".</li>
      * <li>If at a segment within a group (not at the end of the group), next "position" 
      * means next sibling</li>
      * <li>If at the end of a group: If name of group or any of its "first 
      * decendents" matches direction, then next position means next rep of group.  Otherwise 
      * if direction matches name of next sibling of the group, or any of its first 
      * descendents, next position means next sibling of the group.  Otherwise, next means a 
      * new segment added to the group (with a name that matches "direction").  </li>
      * <li>"First descendents" means first child, or first child of the first child, 
      * or first child of the first child of the first child, etc. </li> </ol>
      */
     public Structure next() {
         if (!hasNext()) {
             throw new NoSuchElementException("No more nodes in message");
         }
         try {
             this.currentStructure = next.parent.get(next.index.name, next.index.rep);
         } catch (HL7Exception e) {
             throw new NoSuchElementException("HL7Exception: " + e.getMessage());
         }
         clearNext();
         return this.currentStructure;
     }
     
     /** Not supported */
     public void remove() {
         throw new UnsupportedOperationException("Can't remove a node from a message");
     }
     
     public String getDirection() {
         return this.direction;
     }
     
     public void setDirection(String direction) {
         clearNext();
         this.direction = direction;
     }
     
     private void clearNext() {
         next = null;
     }
     
     /**
      * Returns the index of the given structure as a child of the 
      * given parent.  Returns null if the child isn't found. 
      */
     public static Index getIndex(Group parent, Structure child) {
         Index index = null;
         String[] names = parent.getNames();
         findChild :
         for (String name : names) {
             if (name.startsWith(child.getName())) {
                 try {
                     Structure[] reps = parent.getAll(name);
                     for (int j = 0; j < reps.length; j++) {
                         if (child.equals(reps[j])) {
                             index = new Index(name, j);
                             break findChild;
                         }
                     }
                 } catch (HL7Exception e) {
                     log.error(e.getMessage(), e);
                     throw new Error("Internal HL7Exception finding structure index: " + e.getMessage());
                 }
             }
         }
         return index;
     }
     
     /** 
      * An index of a child structure within a group, consisting of the name and rep of 
      * of the child.
      */
     public static class Index {
         public final String name;
         public final int rep;
         public Index(String name, int rep) {
             this.name = name;
             this.rep = rep;
         }
         
         /** @see Object#equals */
         public boolean equals(Object o) {
             boolean equals = false;
             if (o instanceof Index) {
                 Index i = (Index) o;
                 if (i.rep == rep && i.name.equals(name)) equals = true;
             }
             return equals;
         }
         
         /** @see Object#hashCode */
         public int hashCode() {
             return name.hashCode() + 700 * rep;
         }
         
         /** @see Object#toString */        
         public String toString() {
             return this.name + ":" + this.rep;
         }
     }
     
     /**
      * A structure position within a message. 
      */
     public static class Position {
         public final Group parent;
         public final Index index;
         public Position(Group parent, String name, int rep) {
             this.parent = parent;
             this.index = new Index(name, rep);
         }
         public Position(Group parent, Index i) {
             this.parent = parent;
             this.index = i;
         }
 
         /** @see Object#equals */
         public boolean equals(Object o) {
             boolean equals = false;
             if (o instanceof Position) {
                 Position p = (Position) o;
                 if (p.parent.equals(parent) && p.index.equals(index)) equals = true;
             }
             return equals;
         }
         
         /** @see Object#hashCode */
         public int hashCode() {
             return parent.hashCode() + index.hashCode();
         }
         
         public String toString() {
             return parent.getName() + ":" +
                     index.name +
                     "(" +
                     index.rep +
                     ")";
         }
     }
 }