/*
    Copyright (C) 2006 Grid Systems, S.A.
   
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
   
    This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
  
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
  package com.gridsystems.nextgrid.components;
  
  import java.awt.Color;
  import java.awt.EventQueue;
  import java.util.Date;
  import java.util.Formatter;
  
  import javax.swing.text.BadLocationException;
  import javax.swing.text.JTextComponent;
  import javax.swing.text.SimpleAttributeSet;
  import javax.swing.text.StyleConstants;
  
  import nextgrid.api.pem.DiscoveryEvent;
  import nextgrid.api.pem.DiscoveryListener;
  import nextgrid.api.pem.ProcessEvent;
  import nextgrid.api.pem.ProcessListener;
  
  /**
   * <p>POMListener that writes event logs into a Swing JTextComponent.</p>
   *
   * <p>This is an example of how end-user applications can interact with the
   * workflow enaction process.</p>
   *
   * @author Rodrigo Ruiz
   */
  public class SwingEventLogger implements DiscoveryListener, ProcessListener {
  
    /**
     * Serial version UUID.
     */
    private static final long serialVersionUID = -355090363868006684L;
  
    /**
     * Listener names.
     */
    private static final String[] CATEGORIES = {
      "DISCOVERY",
      " PROCESS "
    };
  
    /**
     * Category index.
     */
    private static final int DISCOVERY = 0;
  
    /**
     * Category index.
     */
    private static final int PROCESS = 1;
  
    /**
     * Attributes used for formatting the log output.
     */
    private static final SimpleAttributeSet[] ATTRIBS = {
      new SimpleAttributeSet(), new SimpleAttributeSet()
    };
  
    /**
     * Index of the last added paragraph.
     * <p>
     * This integer is also used to determine which style must be used (even/odd).
     * <p>
     * It is safe to use it unsynchronised, as long as it is used only from the
     * AWT event dispatch thread.
     */
    private static int pIndex;
  
    static {
      StyleConstants.setBackground(ATTRIBS[0], Color.decode("0xFFFFCC"));
      StyleConstants.setBackground(ATTRIBS[1], Color.WHITE);
      StyleConstants.setFontFamily(ATTRIBS[0], "Courier");
      StyleConstants.setFontFamily(ATTRIBS[1], "Courier");
      StyleConstants.setSpaceAbove(ATTRIBS[0], 2.0f);
      StyleConstants.setSpaceBelow(ATTRIBS[0], 2.0f);
      StyleConstants.setSpaceAbove(ATTRIBS[1], 2.0f);
      StyleConstants.setSpaceBelow(ATTRIBS[1], 2.0f);
    }
  
    /**
     * Text component to write logs to.
     */
    private final JTextComponent tc;
 
   /**
    * Set to true for ignoring discovery events.
    */
   private boolean filterDiscoveryEvents;
 
   /**
    * Set to true for ignoring process events.
    */
   private boolean filterProcessEvents;
 
   /**
    * Set to false for filtering events from descendant nodes.
    */
   private boolean listen = true;
 
   /**
    * Creates a new instance.
    *
    * @param tc Text component
    */
   public SwingEventLogger(JTextComponent tc) {
     this.tc = tc;
   }
 
   /**
    * Gets the managed text component.
    *
    * @return The managed text component
    */
   public final JTextComponent getTextComponent() {
     return this.tc;
   }
 
   /**
    * Gets the "discovery events filtered" flag value.
    *
    * @return The flag value
    */
   public final boolean isDiscoveryFiltered() {
     return this.filterDiscoveryEvents;
   }
 
   /**
    * Gets the "process events filtered" flag value.
    *
    * @return The flag value
    */
   public final boolean isProcessFiltered() {
     return this.filterProcessEvents;
   }
 
   /**
    * Sets the "discovery events filtered" flag value.
    *
    * @param filtered The new flag value
    */
   public final void setDiscoveryFiltered(boolean filtered) {
     this.filterDiscoveryEvents = filtered;
   }
 
   /**
    * Sets the "process events filtered" flag value.
    *
    * @param filtered The new flag value
    */
   public final void setProcessFiltered(boolean filtered) {
     this.filterProcessEvents = filtered;
   }
 
   /**
    * {@inheritDoc}
    */
   public final void discovererSelected(DiscoveryEvent event) {
     if (!filterDiscoveryEvents) {
       log(event.getTimestamp(), CATEGORIES[DISCOVERY],
         "Discoverer selected",
         "Process Name : " + event.getProcess().getName(),
         "Discoverer   : " + event.getDiscoverer()
       );
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public final void discoveryFailed(DiscoveryEvent event) {
     if (!filterDiscoveryEvents) {
       log(event.getTimestamp(), CATEGORIES[DISCOVERY],
         "Discovery failed",
         "Process Name : " + event.getProcess().getName(),
         "Message      : " + event.getException().getMessage()
       );
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public final void discoveryFinished(DiscoveryEvent event) {
     if (!filterDiscoveryEvents) {
       log(event.getTimestamp(), CATEGORIES[DISCOVERY],
         "Discovery finished",
         "Process Name : " + event.getProcess().getName()
       );
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public final void discoveryStarting(DiscoveryEvent event) {
     if (!filterDiscoveryEvents) {
       log(event.getTimestamp(), CATEGORIES[DISCOVERY],
         "Discovery started",
         "Process Name : " + event.getProcess().getName()
       );
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public final boolean isListeningToDescendants() {
     return this.listen;
   }
 
   /**
    * Sets the "listens to descendant events" flag value.
    *
    * @param doListen The new flag value
    */
   public final void setListeningToDescendants(boolean doListen) {
     this.listen  = doListen;
   }
 
   /**
    * {@inheritDoc}
    */
   public final void processEvaluated(ProcessEvent event) {
     if (!filterProcessEvents) {
       log(event.getTimestamp(), CATEGORIES[PROCESS],
         "Evaluation done",
         "Process Name : " + event.getProcess().getName()
       );
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public final void processFinished(ProcessEvent event) {
     if (!filterProcessEvents) {
       log(event.getTimestamp(), CATEGORIES[PROCESS],
         "Execution finished",
         "Process Name : " + event.getProcess().getName()
       );
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public final void processFailed(ProcessEvent event) {
     if (!filterProcessEvents) {
       log(event.getTimestamp(), CATEGORIES[PROCESS], "Execution failed",
         "Process Name : " + event.getProcess().getName(),
         "Exception    : " + event.getException());
 
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public final void processSelected(ProcessEvent event) {
     if (!filterProcessEvents) {
       log(event.getTimestamp(), CATEGORIES[PROCESS],
         "Process selected",
         "Process Name : " + event.getProcess().getName()
       );
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public final void processStarted(ProcessEvent event) {
     if (!filterProcessEvents) {
       log(event.getTimestamp(), CATEGORIES[PROCESS],
         "Execution started",
         "Process Name : " + event.getProcess().getName()
       );
     }
   }
 
   /**
    * Logs some lines.
    *
    * @param ts       Event timestamp
    * @param category An event category name
    * @param text     Text lines to log
    */
   public final void log(long ts, String category, String... text) {
     EventQueue.invokeLater(new Worker(new Date(ts), category, text));
   }
 
   /**
    * Logs some lines.
    *
    * @param d        Event timestamp
    * @param category An event category name
    * @param text     Text lines to log
    */
   public final void log(Date d, String category, String... text) {
     EventQueue.invokeLater(new Worker(d, category, text));
   }
 
   /**
    * Append worker.
    */
   private class Worker implements Runnable {
     /** Timestamp. */
     private final Date d;
 
     /** Log category name. */
     private final String category;
 
     /** Lines to log. */
     private final String[] lines;
 
     /**
      * Creates a new instance.
      *
      * @param d         A timestamp
      * @param category  Category name
      * @param lines     Lines to log
      */
     public Worker(Date d, String category, String[] lines) {
       this.d = d;
       this.category = category;
       this.lines = lines;
     }
 
     /**
      * {@inheritDoc}
      */
     public void run() {
       Formatter f = new Formatter();
       f.format("%tT [%s]", d, category);
       String prefix = f.toString();
       String spaces = "                         ".substring(0, prefix.length());
 
       f = new Formatter();
       for (int i = 0; i < lines.length; i++) {
         f.format("%s %-100s%n", (i == 0) ? prefix : spaces, lines[i]);
       }
 
       try {
         if (tc == null) {
           System.out.println(f.toString());
         } else {
 
           SimpleAttributeSet attr = ATTRIBS[pIndex % 2];
 
           int len = tc.getDocument().getLength();
 
           tc.getDocument().insertString(len, f.toString(), attr);
 
           pIndex++;
         }
       } catch (BadLocationException e) {
         // This should never happen
         throw new RuntimeException(e);
       }
     }
   }
 }