package net.logAnalyzer.patternParser;
   
   import java.util.Vector;
   
   import net.logAnalyzer.config.ConfigurationManager;
   import net.logAnalyzer.converters.LAConverter;
   import net.logAnalyzer.converters.NewLineConverter;
   
   /***
   * This class parses a log4j PatternLayout pattern.
   * <p>
   * The pattern could contain log4j basic converters, but also custom converters.
   * </p>
   * <p>
   * Each pattern is declared in the <tt>&lt;logana:converters&gt;</tt> section
   * of the configuration file loaded by
   * {@link net.logAnalyzer.config.ConfigurationManager}.
   * </p>
   * 
   * @author Karim REFEYTON
   * @version 0.1
   */
  public class PatternParser {
      protected static final char CONVERTER_PREFIX = '%';
  
      protected static final char OPENED_BRAKET = '{';
  
      protected static final char CLOSED_BRAKET = '}';
  
      private int linesToRead = 1;
  
      /***
       * Pattern to analyse.
       */
      private String pattern = null;
  
      /***
       * Default constructor.
       * 
       * @param pattern
       *            Pattern to analysis.
       */
      public PatternParser(String pattern) {
          this.pattern = pattern;
      }
  
      static final int STATE_LOOKING = 0;
      static final int STATE_CONVERTER = 1;
      static final int STATE_OPENBRAKET = 2;
      static final int STATE_OPTION = 3;
      /***
       * Parses the pattern char by char. The pattern is transformed as a column
       * list.
       */
      public LAConverter[] parse() throws PatternParsingException {
          // Converters
          Vector converters = new Vector();
          // Current converter
          LAConverter converter = null;
          // Buffer following current position
          StringBuffer buffer = new StringBuffer();
          // Buffer for literals
          StringBuffer literal = new StringBuffer();
          // Buffer for converter
          String letter = null;
          // Buffer for options
          StringBuffer option = new StringBuffer();
          // Defines parsing states
          int state = STATE_LOOKING;
          // Parses pattern
          int patternLength = pattern.length();
          for (int i = 0; i < patternLength; i++) {
              // Reads the current character
              char c = pattern.charAt(i);
              switch (state) {
              case STATE_LOOKING:
                  // Looking for '%' or literal
                  if (c == CONVERTER_PREFIX) {
                      // Creates the buffer
                      buffer.append(c);
                      // Continues to the next state
                      state = STATE_CONVERTER;
                  } else {
                      // Extends the current literal
                      literal.append(c);
                  }
                  break;
              case STATE_CONVERTER:
                  // Reading converter char
                  if (c == CONVERTER_PREFIX) {
                      // Extends the current literal with the escaped special
                      // character CONVERTER_PREFIX
                      literal.append(c);
                      // Returns to the first state
                      buffer.setLength(0);
                      state = STATE_LOOKING;
                  } else {
                      // Saves the converter letter
                      letter = Character.toString(c);
                     // Extends the buffer
                     buffer.append(c);
                     // Continues to the next state
                     state = STATE_OPENBRAKET;
                 }
                 break;
             case STATE_OPENBRAKET:
                 // Looking for "{" or literal
                 if (c == '{') {
                     // Extends the buffer
                     buffer.append(c);
                     // Continues to the next state
                     state = STATE_OPTION;
                 } else {
                     try {
                         // Creates the converter without option
                         converter = ConfigurationManager.getInstance()
                                 .createConverter(letter);
                         // Adds the literal if not empty
                         addLiteral(converters, literal.toString());
                         // Adds the converter
                         addConverter(converters, converter);
                         // Unparses the current character
                         i--;
                         // Continues to the next state
                         letter = null;
                         literal.setLength(0);
                         buffer.setLength(0);
                         state = STATE_LOOKING;
                     } catch (PatternParsingException ppe) {
                         // The converter is unknown so its a literal
                         // Extends the current literal
                         literal.append(buffer);
                         buffer.setLength(0);
                         // Unparses the current character
                         i--;
                         // Returns to the first state
                         state = STATE_LOOKING;
                     }
                 }
                 break;
             case STATE_OPTION:
                 // Looking for '}' or option
                 if (c == CLOSED_BRAKET) {
                     try {
                         // Creates the converter with its option
                         converter = ConfigurationManager.getInstance()
                                 .createConverter(letter, option.toString());
                         // Adds the literal if not empty
                         addLiteral(converters, literal.toString());
                         // Adds the converter
                         addConverter(converters, converter);
                         // Continues to the next state
                         letter = null;
                         literal.setLength(0);
                         buffer.setLength(0);
                         option.setLength(0);
                         state = STATE_LOOKING;
                     } catch (PatternParsingException ppe) {
                         // The converter is unknown so its a literal
                         // Extends the current literal
                         literal.append(buffer).append(CLOSED_BRAKET);
                         // Returns to the first state
                         buffer.setLength(0);
                         option.setLength(0);
                         state = STATE_LOOKING;
                     }
                 } else if (c == CONVERTER_PREFIX && i < patternLength - 1
                         && pattern.charAt(i + 1) != CONVERTER_PREFIX) {
                     // There is no option but a literal beginning with the
                     // opened braket and terminated closed to a converter
                     try {
                         // Creates the converter without option
                         converter = ConfigurationManager.getInstance()
                                 .createConverter(letter);
                         // Adds the literal if not empty
                         addLiteral(converters, literal.toString());
                         // Adds the converter
                         addConverter(converters, converter);
                         // Unparses the current character
                         i--;
                         // Continues to the next state
                         letter = null;
                         literal.setLength(0);
                         literal.append(buffer);
                         buffer.setLength(0);
                         option.setLength(0);
                         state = STATE_LOOKING;
                     } catch (PatternParsingException ppe) {
                         // The converter is unknown so its a literal
                         // Extends the current literal
                         literal.append(buffer);
                         // Unparses the current character
                         i--;
                         // Returns to the first state
                         buffer.setLength(0);
                         option.setLength(0);
                         state = STATE_LOOKING;
                     }
                 } else if (c == CONVERTER_PREFIX && i < patternLength - 1
                         && pattern.charAt(i + 1) == CONVERTER_PREFIX) {
                     // Extends the current literal with the escaped special
                     // character CONVERTER_PREFIX
                     literal.append(CONVERTER_PREFIX);
                     // Returns to the first state
                     buffer.setLength(0);
                     option.setLength(0);
                     state = STATE_LOOKING;
                 } else {
                     // Extends the current option
                     option.append(c);
                     buffer.append(c);
                 }
                 break;
              default:
             }
         }
         // Adds the ending literal if not empty
         addLiteral(converters, literal.toString());
 
         // Controls if literal and non literal converters are alternated
         // boolean expectLiteral = true;
         // for (int i = 0; i < converters.size(); i++) {
         // LAConverter converter = (LAConverter) converters.get(i);
         // if (i > 0
         // && ((converter.isLiteral() && !expectLiteral) || (!converter
         // .isLiteral() && expectLiteral))) {
         // // throws new Parse
         // }
         // // expectLiteral
         // }
 
         LAConverter[] conv = new LAConverter[converters.size()];
         return (LAConverter[]) converters.toArray(conv);
     }
 
     /***
      * Constructs a converter from the converterChar parsed in the pattern.
      * 
      * @param converters
      *            Converters.
      * @param converter
      *            LAConverter to add in the converters list.
      */
     private void addConverter(Vector converters, LAConverter converter) {
         if (converters.size() > 0) {
             LAConverter previous = (LAConverter) converters.get(converters
                     .size() - 1);
             previous.setNext(converter);
         }
         converters.add(converter);
         if (converter instanceof NewLineConverter) {
             linesToRead++;
         }
     }
 
     /***
      * Constructs a literal converter to handle the last parsed string.
      * 
      * @param converters
      *            Converters.
      * @param literal
      *            Literal parsed in the pattern.
      * @throws PatternParsingException
      *             If can't create a literal converter.
      */
     private void addLiteral(Vector converters, String literal)
             throws PatternParsingException {
         if (literal != null && literal.length() > 0) {
             LAConverter converter = ConfigurationManager.getInstance()
                     .createLiteralConverter(literal);
             if (converters.size() > 0) {
                 LAConverter previous = (LAConverter) converters.get(converters
                         .size() - 1);
                 previous.setNext(converter);
             }
             converters.add(converter);
         }
     }
 
     /***
      * Returns the number of lines to read from the log file to parse a log
      * messageLabel. For example, if a log4j pattern contains a %n converter inside
      * (not at the end), the number of lines is 2.
      * 
      * @return The number of line to read in a log file.
      */
     public int getLinesToRead() {
         return linesToRead;
     }
 }