package com.flexiblewebsolutions.xml.util;
   
   import java.util.ArrayList;
   import java.util.Iterator;
   
   import com.flexiblewebsolutions.util.ListUtils;
   
   /***
    * Pulls values from an xml file using a simple XML parser.
   * 
   * @author Donavon Buss
   */
  public class XMLStringParser
  {
      /***
       * Return the value for a single tag inside a xml block.
       * 
       * @param pString -
       *            XML string.
       * @param pTag -
       *            Name of tag to retrieve value for
       * @return Value of tag
       */
      public static String getValueForTag( StringBuffer pString, String pTag )
      {
          String startTag = "<" + pTag;
          String endTag = "</" + pTag + ">";
  
          String returnVal = null;
          int startIndex = pString.indexOf( startTag );
          if( startIndex != -1 )
          {
          	int endStartTag = pString.indexOf( ">", startIndex );
          	startTag = pString.substring( startIndex, endStartTag + 1 );
          	
              String fullTag = getEntireTag( pString, startIndex, endTag,
                      startTag );
  
              returnVal = fullTag.substring( startTag.length(), fullTag.length()
                      - endTag.length() );
              returnVal = ( removeTabChars( new StringBuffer( returnVal ) ) ).toString();
          }
          return ( returnVal );
      }
  
      /***
       * Retreive entire xml tag, ignoring embedded ending tags with same name
       * 
       * @param pXML
       *            XML String
       * @param pStartIndex
       *            Location in XML to begin looking for tag.
       * @param pEndTag
       *            Ending Tag
       * @param pStartTag
       *            Starting XML tag
       * @return Entire XML tag including start and end tag
       */
      public static String getEntireTag( StringBuffer pXML, int pStartIndex,
              String pEndTag, String pStartTag )
      {
          StringBuffer xml = removeNewlines( pXML );
  
          int startVal = pStartIndex + pStartTag.length();
          int endStartVal = pStartIndex + pStartTag.length();
          String tag = null;
  
          int possEndIndex = -1;
          int newStartIndex = -1;
          do
          {
              // start at opening tag, search starting from end of start tag
              possEndIndex = pXML.indexOf( pEndTag, endStartVal );
              // look for a new start tag to see if embedded tag w/ same name
              newStartIndex = pXML.indexOf( pStartTag, startVal );
              // set where next search will take place from
              endStartVal = possEndIndex + pEndTag.length();
              startVal = newStartIndex + pStartTag.length();
          }
          while( ( newStartIndex != -1 ) && ( possEndIndex > newStartIndex ) );
  
          tag = pXML.substring( pStartIndex, possEndIndex + pEndTag.length() );
          return ( tag );
      }
  
      /***
       * Retreive entire xml tag, ignoring embedded ending tags with same name.
       * End tag is determined.
       * 
       * @param pXML
       *            XML String
       * @param pStartIndex
       *            Location in XML to begin looking for tag.
       * @param pStartTag
       *            Starting XML tag
       * @return Entire XML tag including start and end tag
       */
      public static String getEntireTag( StringBuffer pXML, int pStartIndex,
              String pStartTag )
     {
         StringBuffer tempEndTag = new StringBuffer( pStartTag );
         tempEndTag.insert( 1, "/" );
         String endTag = tempEndTag.toString();
 
         return ( getEntireTag( pXML, pStartIndex, endTag, pStartTag ) );
     }
 
     /***
      * Remove tab characters from input
      * @param pXML XMl String
      * @return StringBuffer that has tab characters removed
      */
     private static StringBuffer removeTabChars( StringBuffer pXML )
     {
     	return( removeCharacter( pXML, '\t' ) );
     }
     
     /***
      * Remove new line characters from the xml string if they exist
      * 
      * @param pXML
      *            Xml String
      * @return XML String where new lines have been removed.
      */
     private static StringBuffer removeNewlines( StringBuffer pXML )
     {
     	return( removeCharacter( pXML, '\n' ) );
     }
     
     /***
      * Removes a character from the screen
      * @param pXML Xml String
      * @param pChar Character to remove
      * @return Xml String that is free from offending character
      */
     private static StringBuffer removeCharacter( StringBuffer pXML, char pChar )
     {
         StringBuffer returnXML = new StringBuffer();
         for( int i = 0; i < pXML.length(); i++ )
         {
             if( pXML.charAt( i ) != pChar )
             {
                 returnXML.append( pXML.charAt( i ) );
             }
         }
         return ( returnXML );
     }
 
     /***
      * Retrieves the tags nested within the top level of the XML string matching a tag name.
      * 
      * @param pXmlString XML string containing values.
      * @param pTag Name of tag to find values for.
      * @return Array of Tag values.
      */
     public static String[] getMatchingNestedTags( String pXmlString, String pTag )
     {
         ArrayList nestedVals = getNestedTags( pXmlString );
         String startTag = "<" + pTag + ">";
         String endTag = "</" + pTag + ">";
 
         ArrayList returnVals = new ArrayList();
         for( Iterator it = nestedVals.iterator(); it.hasNext(); )
         {
             String tag = (String) it.next();
             if( tag.startsWith( startTag ) )
             {
                 returnVals.add( tag );
             }
         }
 
         return ListUtils.convertToStringArray( returnVals );
     }
 
     /***
      * Retrieves all tags nested within the top level of the XML string.
      * 
      * @param pXmlString XML string containing values.
      * @return ArrayList of Tag Values.
      */
     private static ArrayList getNestedTags( String pXmlString )
     {
         StringBuffer xmlContents = removeNewlines( new StringBuffer( pXmlString ) );
         ArrayList nestedVals = new ArrayList();
 
         while( xmlContents.length() > 0 )
         {
             String thisStartTag = xmlContents.substring( 0,
                     xmlContents.indexOf( ">" ) + 1 );
             String firstEntry = getEntireTag( xmlContents, 0, thisStartTag );
             xmlContents.delete( 0, firstEntry.length() );
             nestedVals.add( firstEntry );
         }
 
         return ( nestedVals );
     }
 
     /***
      * Retrieves all tags nested within the tol level of the XML string.
      * 
      * @param pXmlString XML string containing values
      * @return String array of tag values.
      */
     public static String[] getAllNestedTags( String pXmlString )
     {
         ArrayList nestedTags = getNestedTags( pXmlString );
         return ListUtils.convertToStringArray( nestedTags );
     }
 }