package net.logAnalyzer.handlers;
   
   import java.io.FileNotFoundException;
   import java.io.IOException;
   import java.util.Hashtable;
   import java.util.Vector;
   
   import net.logAnalyzer.analysis.LAAnalyzer;
   import net.logAnalyzer.converters.LAConverter;
  import net.logAnalyzer.converters.UnknownOrLiteralConverterException;
  import net.logAnalyzer.patternParser.PatternParser;
  import net.logAnalyzer.patternParser.PatternParsingException;
  import net.logAnalyzer.utils.FilesSetReader;
  
  /***
   * This class defines a template for log file handlers. A log file handler is
   * used to apply filters and analyzers on a log file. Filters dans analyzers can
   * be added before and/or after log file parsing.
   * 
   * @author Karim REFEYTON
   * @version 0.1
   */
  public abstract class AbstractLogHandler implements LALogHandler {
      /***
       * Analyzers to apply.
       */
      private LAAnalyzer[] analyzers = null;
  
      /***
       * Converters defined in the log4j pattern used to parse the
       * {@link FilesSetReader} returned by {@link #getReader()}.
       */
      private LAConverter[] converters = null;
  
      /***
       * Index of converters. The hashtable keys are the
       * {@link LAConverter#getLiteral()}, as "%p" for a log4j priority column.
       */
      private Hashtable convertersIndex = null;
  
      /***
       * Message converter.
       * <p>
       * Message converter is a special converter used to concat the current
       * messageLabel text with the extra lines unparsed.
       * 
       * @see #parse()
       * @see LAMessage#extendsMessage(String)
       */
      private LAConverter messageConverter = null;
  
      /***
       * Number of lines to read from the log file to parse a log messageLabel.
       */
      private int linesToRead = 1;
  
      /***
       * Reader from input.
       */
      private FilesSetReader reader = null;
  
      /***
       * Number of records to parse; <tt>0</tt> for no limitation.
       */
      private int maxRecords = 0;
  
      /***
       * <tt>true</tt> if the handler is currently parsing the log.
       */
      private boolean parsing = false;
  
      /***
       * Last exception thrown by the parsing or analysis processes.
       */
      private Exception lastException = null;
  
      /***
       * Constructs a log handler for the specified input files parsed with the
       * specified converters.
       * 
       * @param input
       *            Log file(s) to parse.
       * @param pattern
       *            Pattern used to parse file.
       * @throws NoConverterException
       *             If no converter is specified.
       * @throws FileNotFoundException
       *             If file handled by <tt>input</tt> not found.
       */
      public AbstractLogHandler(FilesSetReader input, String pattern)
              throws FileNotFoundException, NoConverterException {
          this.reader = input;
          this.converters = parsePattern(pattern);
  
          if (this.converters == null || this.converters.length == 0) {
              throw new NoConverterException();
          }
          // Saves index for non literal columns for quick access
          this.convertersIndex = new Hashtable();
         for (int i = 0; i < this.converters.length; i++) {
             if (!this.converters[i].isLiteral()) {
                 this.convertersIndex.put(this.converters[i].getLiteral(),
                         new Integer(i));
             }
             if (this.converters[i].isMessage()) {
                 messageConverter = this.converters[i];
             }
         }
     }
 
     /***
      * Adds new analyzers to the log handler.
      * 
      * @param newAnalyzers
      *            Analyzers to add.
      */
     public final void setAnalyzers(LAAnalyzer[] newAnalyzers) {
         int nbAnalyzers = 0;
         if (analyzers == null) {
             // Instanciates analyzers array
             analyzers = new LAAnalyzer[newAnalyzers.length];
         } else {
             // Extends analyzers array
             LAAnalyzer[] oldAnalyzers = analyzers;
             nbAnalyzers = oldAnalyzers.length;
             analyzers = new LAAnalyzer[nbAnalyzers + newAnalyzers.length];
             for (int i = 0; i < nbAnalyzers; i++) {
                 analyzers[i] = oldAnalyzers[i];
             }
         }
         // Adds new analyzers
         for (int i = 0; i < newAnalyzers.length; i++) {
             analyzers[i + nbAnalyzers] = newAnalyzers[i];
         }
     }
 
     /***
      * Returns log analyzers added to the handler with
      * {@link #setAnalyzers(LAAnalyzer[])}.
      * 
      * @return Log analyzers.
      */
     public final LAAnalyzer[] getAnalyzers() {
         return this.analyzers;
     }
 
     /***
      * Returns pattern converters.
      * 
      * @return Pattern converters.
      */
     public final LAConverter[] getConverters() {
         return this.converters;
     }
 
     /***
      * Returns the converter at the specified index.
      * 
      * @param index
      *            Converter index.
      * @return Converter or <tt>null</tt> if unknown.
      */
     public final LAConverter getConverter(int index) {
         return this.converters[index];
     }
 
     /***
      * Returns the converter identified by the specified literal.
      * 
      * @param literal
      *            Converter literal.
      * @return Converter or <tt>null</tt> if unknown.
      * @see #getConverter(int)
      * @see #getConverterIndex(String)
      * @throws UnknownOrLiteralConverterException
      *             If the literal does not identify a non literal converter.
      */
     public final LAConverter getConverter(String literal)
             throws UnknownOrLiteralConverterException {
         return getConverter(getConverterIndex(literal));
     }
 
     /***
      * Returns the index of the converter identified by the specified literal.
      * 
      * @param literal
      *            Converter literal.
      * @return Converter or <tt>null</tt> if unknown.
      * @see #getConverter(int)
      * @throws UnknownOrLiteralConverterException
      *             If the literal does not identify a non literal converter.
      */
     public final int getConverterIndex(String literal)
             throws UnknownOrLiteralConverterException {
         Integer index = (Integer) this.convertersIndex.get(literal);
         if (index == null) {
             throw new UnknownOrLiteralConverterException(literal);
         }
         return index.intValue();
     }
 
     /***
      * Returns the current messageLabel converter used to extend messageLabel text with
      * unparsed lines.
      * 
      * @return Message converter.
      * @see #parse()
      * @see LAMessage#extendsMessage(String)
      */
     public final LAConverter getMessageConverter() {
         return messageConverter;
     }
 
     /***
      * Returns the last exception thrown by the parsing process.
      * 
      * @return Last exception or <tt>null</tt> parsing was succesfull.
      */
     public final Exception getLastException() {
         return lastException;
     }
 
     /***
      * Returns the length of the parsed file.
      * 
      * @return Length.
      * @see FilesSetReader#length()
      */
     protected final long getFileLength() {
         long length = 0;
         if (reader != null) {
             length = reader.length();
         }
         return length;
     }
 
     /***
      * Returns the current position in the parsed file.
      * 
      * @return Pointer.
      */
     protected final long getFilePointer() {
         long pointer = 0;
         if (reader != null) {
             try {
                 pointer = reader.getFilePointer();
             } catch (IOException e) {
                 pointer = 0;
             }
         }
         return pointer;
     }
 
     /***
      * Returns the number of records to parse; <tt>0</tt> for no limitation.
      * 
      * @return maxRecords Number of records.
      */
     public final int getMaxRecords() {
         return this.maxRecords;
     }
 
     /***
      * Number of records to parse; <tt>0</tt> for no limitation.
      * 
      * @param maxRecords
      *            Number of records.
      */
     public final void setMaxRecords(int maxRecords) {
         if (maxRecords < 0) {
             this.maxRecords = 0;
         } else {
             this.maxRecords = maxRecords;
         }
     }
 
     /***
      * Returns the done percentage of the parsed file. If the handler is not
      * parsing, returns <tt>0</tt>.
      * 
      * @return Done percentage.
      */
     public final int getPercentDone() {
         int percentage = 0;
         final int total = 100;
         if (isParsing()) {
             if (maxRecords != 0) {
                 percentage = total * getSize() / maxRecords;
             } else {
                 percentage = (int) (total * getFilePointer() / getFileLength());
             }
             if (percentage > total) {
                 percentage = total;
             }
         }
         return percentage;
     }
 
     /***
      * Returns the messageLabel at the specified position.
      * 
      * @param index
      *            Physical index of the messageLabel in the log file.
      * @return Message.
      */
     public final LAMessage getMessage(int index) {
         return loadMessage(index);
     }
 
     /***
      * Returns the messages between specified positions. Uses
      * {@link #getMessage(int)}to read messageLabel from the log file.
      * 
      * @param start
      *            start physicial index (included in the result).
      * @param end
      *            end physical index (included in the result).
      * @return messages.
      */
     public final LAMessage[] getMessages(int start, int end) {
         int size = getSize();
         // The start physical indx must be greater or equal than zero
         if (start < 0) {
             // Starts at the first messageLabel
             start = 0;
         }
         // The end physical index must be lower than the size of the log.
         if (end >= size) {
             // Stops at the last messageLabel
             end = size - 1;
         }
         // An empty interval returns an empty result
         if (end < start) {
             return null;
         }
         LAMessage[] messages = new LAMessage[end - start];
         for (int i = start; i <= end; i++) {
             messages[i - start] = loadMessage(i);
         }
         return messages;
     }
 
     /***
      * Returns the current reader.
      * 
      * @return Current reader.
      */
     protected final FilesSetReader getReader() {
         return reader;
     }
 
     /***
      * Returns the real number of messages in the log, not only in cache in case
      * of a load on demand parsed log.
      * 
      * @return physical number of messages.
      */
     public abstract int getSize();
 
     /***
      * Returns <tt>true</tt> if the handler is currently parsing the log.
      * 
      * @return <tt>true</tt> if parsing; <tt>false</tt> otherwise.
      */
     public final boolean isParsing() {
         return this.parsing;
     }
 
     /***
      * Loads the messageLabel at the specified index.
      * 
      * @param index
      *            Index of the messageLabel to load.
      * @return Message.
      */
     protected abstract LAMessage loadMessage(int index);
 
     /***
      * Parses the log content of the {@link FilesSetReader} returned by
      * {@link #getReader()}. Calls, in order :
      * <ul>
      * <li>{@link #initParsing()}</li>
      * <li>{@link #readNextLine()}</li>
      * <li>{@link #parseMessage(String, LAConverter[])}</li>
      * <li>{@link #saveMessage(LAMessage, long)}</li>
      * <li>{@link LAAnalyzer#analyze(LAMessage, LALogHandler)}on each
      * {@link LAAnalyzer};</li>
      * <li>{@link #releaseParsing()}</li>
      * </ul>
      * <p>
      * Because a {@link LALogHandler} is a {@link Runnable}, for a threaded
      * parsing you must start it in a new {@link Thread} :
      * 
      * <pre>
      * handler.addLogHandlerListener(myLALogHandlerListener);
      * Thread handlerThread = new Thread(handler);
      * handlerThread.start();
      * </pre>
      * 
      * </p>
      * 
      * @throws ParsingException
      *             If can't parse messageLabel.
      * @see LALogHandler#parse()
      */
     public final void parse() throws ParsingException {
         try {
             // Makes intializations
             initParsing();
             // Parses messageLabel
             String unparsedmessage = null;
             LAMessage message = null;
             LAMessage previousMessage = null;
             int count = 0;
             long pointer = 0;
             long previousPointer = 0;
             // Loop on messages for parsing
             // count must reach maxRecords to take care of multi-line messages
             pointer = reader.getFilePointer();
 
             int percent = 0;
             int newPercent = 0;
             while ((maxRecords <= 0 || count < maxRecords)
                     && (unparsedmessage = readNextLine()) != null) {
                 // Read the next lines if needed
                 String extraLine = null;
                 for (int i = 1; i < linesToRead
                         && (extraLine = readNextLine()) != null; i++) {
                     unparsedmessage += '\n' + extraLine;
                 }
                 // Computes percent done and fires event if needed
                 newPercent = getPercentDone();
                 if (newPercent - percent >= 1) {
                     percent = newPercent;
                     fireStepParsing();
                 }
                 // Parses messageLabel
                 try {
                     message = parseMessage(unparsedmessage, converters);
                     // Does not save the messageLabel but the previous to allow
                     // messageLabel extension when a line content can't be parsed
                     // (like when an exception stakc is traced).
                     if (previousMessage != null
                             && (maxRecords <= 0 || count < maxRecords)) {
                         // Saves messageLabel only if is not exceeding the max
                         processMessage(previousMessage, previousPointer);
                         count++;
                     }
                     // A new messageLabel is added
                     previousMessage = message;
                     previousPointer = pointer;
                 } catch (ParsingException pe) {
                     // The first messageLabel is ignored if it can not be parsed
                     if (count > 0 && previousMessage != null) {
                         // If the message can't be parsed, perhaps because the
                         // messageLabel is multi-line, so the first unparsed line
                         // must be
                         // added to the previous messageLabel
                         reader.seek(pointer);
                         previousMessage.extendsMessage(readNextLine());
                     }
                 }
                 pointer = reader.getFilePointer();
             }
             // If only one messageLabel was read, saves the messageLabel
             if (previousMessage == null && message != null) {
                 processMessage(message, pointer);
             }
         } catch (Exception e) {
             lastException = e;
             throw new ParsingException(e);
         } finally {
             // Makes releases
             try {
                 releaseParsing();
             } catch (IOException ioe) {
                 // NOP
                 parsing = false;
             }
         }
     }
 
     /***
      * Produces a converter array parsing the specified pattern.
      * 
      * @param pattern
      *            Pattern to parse.
      * @return Converters resulting to the parsing.
      */
     private LAConverter[] parsePattern(String pattern) {
         try {
             PatternParser parser = new PatternParser(pattern);
             LAConverter[] parserConverters = parser.parse();
             linesToRead = parser.getLinesToRead();
             return parserConverters;
         } catch (PatternParsingException ppe) {
             ppe.printStackTrace(System.err);
             System.exit(1);
             return null;
         }
     }
 
     /***
      * Apply analyzers on the messageLabel and saves it if required.
      * 
      * @param message
      *            Message to analysis and to save.
      * @param pointer
      *            File pointer at the start of the messageLabel.
      */
     private void processMessage(LAMessage message, long pointer) {
         // Applies analyzers
         if (analyzers != null && analyzers.length > 0) {
             for (int i = 0; i < analyzers.length; i++) {
                 analyzers[i].analyze(message, this);
             }
         }
         // Saves messageLabel
         saveMessage(message, pointer);
     }
 
     /***
      * Parses a string messageLabel in a {@link LAMessage}using
      * {@link LAConverter#parse(StringBuffer, LALogHandler)}method.
      * 
      * @param message Messate to parse.
      * @param convertersToUse Converters used to parse the messageLabel.
      * @return Parsed messageLabel.
      * @throws ParsingException
      *             If can't parse messageLabel.
      */
     protected final LAMessage parseMessage(String message,
             LAConverter[] convertersToUse) throws ParsingException {
         // Creates columns and values
         Object[] values = new Object[convertersToUse.length];
 
         // Parses messageLabel
         StringBuffer toParse = new StringBuffer(message);
         for (int i = 0; i < convertersToUse.length; i++) {
             values[i] = convertersToUse[i].parse(toParse, this);
         }
         return new LAMessage(this, values);
     }
 
     /***
      * Reads a line form the input. Could be called many times by
      * {@link LAConverter#parse(StringBuffer, LALogHandler)}to read the messageLabel
      * and the next lines. This is usefull when the messageLabel is written on more
      * than one line (for example when the result of
      * {@link Throwable#printStackTrace()}is added to the logged messageLabel}.
      * 
      * @return Next line from the handled log.
      * @throws IOException If an error occures.
      */
     protected final String readNextLine() throws IOException {
         String line = null;
         if (maxRecords == 0 || getSize() <= maxRecords) {
             line = reader.readLine();
         }
         return line;
     }
 
     /***
      * Saves the messageLabel after parsing.
      * 
      * @param message
      *            Parsed messageLabel.
      * @param pointer
      *            File pointer to the start of the messageLabel.
      */
     protected abstract void saveMessage(LAMessage message, long pointer);
 
     /***
      * Makes the intialization before parsing. Calls
      * {@link LAAnalyzer#initAnalyze(LALogHandler)} on each analyzer. If
      * overwritten, you must call it with <tt>super.initParsing()</tt>. Calls
      * {@link #fireStartParsing()}.
      * @throws IOException If an error occures.
      */
     protected void initParsing() throws IOException {
         // Resets parsing info
         parsing = true;
         lastException = null;
         reader.seek(0);
         // Initializes analyzers
         if (analyzers != null && analyzers.length > 0) {
             for (int i = 0; i < analyzers.length; i++) {
                 analyzers[i].initAnalyze(this);
             }
         }
         fireStartParsing();
     }
 
     /***
      * Makes the releases after parsing. Calls
      * {@link LAAnalyzer#releaseAnalyze(LALogHandler)}on each analyzer.If
      * overwritten, you must call it with <tt>super.releaseParsing()</tt>.
      * Calls {@link #fireEndParsing()}.
      * @throws IOException If an error occures.
      */
     protected void releaseParsing() throws IOException {
         // releases analyzers
         if (analyzers != null && analyzers.length > 0) {
             for (int i = 0; i < analyzers.length; i++) {
                 analyzers[i].releaseAnalyze(this);
             }
         }
         // Sets parsing info before close the reader because closing the reader
         // might throw an exception.
         parsing = false;
         fireEndParsing();
     }
 
     /***
      * Called by running the handler in a thread. Calls {@link #parse()}.<br>
      * Example :
      * 
      * <pre>
      * Thread thread = new Thread(handler);
      * thread.start();
      * </pre>
      * 
      * @see java.lang.Runnable#run()
      */
     public final void run() {
         try {
             parse();
         } catch (ParsingException pe) {
             lastException = pe;
             // Stop parsing
             try {
                 releaseParsing();
             } catch (IOException ioe) {
                 parsing = false;
             }
         } finally {
             parsing = false;
         }
     }
 
     /***
      * Listeners for log handler events.
      *  @see LALogHandlerListener
      */
     private Vector logHandlerListeners = new Vector();
 
     /***
      * Adds a listener.
      * 
      * @param listener
      *            Lister to add.
      * @see LALogHandler#addLogHandlerListener(LALogHandlerListener)
      */
     public final void addLogHandlerListener(LALogHandlerListener listener) {
         if (!logHandlerListeners.contains(listener)) {
             logHandlerListeners.add(listener);
         }
     }
 
     /***
      * Removes a listener.
      * 
      * @param listener
      *            Lister to remove.
      * @see LALogHandler#removeLogHandlerListener(LALogHandlerListener)
      */
     public final void removeLogHandlerListener(LALogHandlerListener listener) {
         logHandlerListeners.remove(listener);
     }
 
     /***
      * Fires a start parsing event.
      */
     public final void fireStartParsing() {
         for (int i = 0; i < logHandlerListeners.size(); i++) {
             ((LALogHandlerListener) logHandlerListeners.get(i))
                     .startParsing(this);
         }
     }
 
     /***
      * Fires a step parsing event.
      */
     public final void fireStepParsing() {
         for (int i = 0; i < logHandlerListeners.size(); i++) {
             ((LALogHandlerListener) logHandlerListeners.get(i))
                     .stepParsing(this);
         }
     }
 
     /***
      * Fires an end parsing event.
      */
     public final void fireEndParsing() {
         for (int i = 0; i < logHandlerListeners.size(); i++) {
             ((LALogHandlerListener) logHandlerListeners.get(i))
                     .endParsing(this);
         }
     }
 }