/*
    * Copyright (C) 2005 by Arno Schumacher
    *
    * This file is part of net.sourceforge.servletspy
    *
    * net.sourceforge.servletspy is free software; you can redistribute
    * it and/or modify it under the terms of the GNU General Public 
    * License as published by the Free Software Foundation; either 
   * version 2, or (at your option) any later version.
   *
   * net.sourceforge.servletspy 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 General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA 
   */
  
  package net.sourceforge.servletspy.ctx;
  
  import java.io.ByteArrayOutputStream;
  import java.io.PrintWriter;
  import java.lang.reflect.InvocationTargetException;
  import java.util.HashMap;
  import java.util.Map;
  
  import net.sourceforge.servletspy.IContext;
  import net.sourceforge.servletspy.IContextHandler;
  import net.sourceforge.servletspy.Node;
  import net.sourceforge.servletspy.util.ClassUtil;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /***
   * @author arno schumacher
   */
  public final class Context implements IContext {
  
      /*** The logger. */
      private static final Log LOGGER = LogFactory.getLog(Context.class);
  
      /***
       * Calculates a default serialization result value.
       * 
       * @param subject
       *            The subject to serialize
       * @return The default value.
       */
      private static String determineDefaultValue(final Object subject) {
          
          if (subject == null) {
              return "";
          } else {
              return ClassUtil.getClassName( subject.getClass() );
          }
      }
  
      /*** Map holding already processed subjects, for cycle detection purpose. */
      private final Map introspected;
  
      /***
       * The result node, a container holding the serialization result and a set
       * of child nodes.
       */
      private Node node;
  
      /*** The object for which a node tree has to be calculated. */
      private Object subject;
  
      /*** The transformers responsible for generating the node tree. */
      private final IContextHandler[] transformers;
  
      /*** The index of the <i>current</i> transformer. */
      private int transformerIndex = -1;
  
      /***
       * Constructor.
       * 
       * @param name
       *            The name of the context.
       * @param pSubject
       *            The object to serialize.
       * @param parentContext
       *            The parent context.
       */
      private Context(final String name, final Object pSubject,
              final Context parentContext) {
          this.subject = pSubject;
          this.transformers = parentContext.transformers;
          this.introspected = new HashMap(parentContext.introspected);
          this.node = new Node(parentContext.node, name,
                  determineDefaultValue(pSubject));
      }
  
      /***
      * Constructor.
      * 
      * @param name
      *            The name of the context.
      * @param pSubject
      *            The object to serialize
      * @param pTransformers
      *            The chain of transformers responsible for the serialization
      *            task.
      */
     public Context(final String name, final Object pSubject,
             final IContextHandler[] pTransformers) {
         this.node = new Node(null, name, determineDefaultValue(pSubject));
         this.subject = pSubject;
         this.introspected = new HashMap();
         this.transformers = pTransformers;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see net.sourceforge.servletspy.IContext#add(java.lang.String,
      *      java.lang.Object)
      */
     public void add(final String name, final Object pSubject) {
         final Context ctx = new Context(name, pSubject, this);
         ctx.proceed();
         if (ctx.getNode() != null) {
             this.getNode().addChildNode(ctx.getNode());
         }
     }
 
     /***
      * Returns the map holding the already serialized subjects.
      * 
      * @return The map of the already serialized subjects.
      */
     public Map getIntrospectedMap() {
         return introspected;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see net.sourceforge.servletspy.IContext#getName()
      */
     public String getName() {
         if (getNode() == null) {
             throw new IllegalStateException();
         }
         return getNode().getName();
     }
 
     /***
      * Returns the node associated with this context.
      * 
      * @return The node.
      */
     public Node getNode() {
         return node;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see net.sourceforge.servletspy.IContext#getSubject()
      */
     public Object getSubject() {
         return subject;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see net.sourceforge.servletspy.IContext#getValue()
      */
     public String getValue() {
         return getNode() == null ? null : getNode().getValue();
     }
 
     private void handleException(final Throwable exception) {
         LOGGER.info("Caught exception:", exception);
         if (node != null) {
             ByteArrayOutputStream bytes = new ByteArrayOutputStream();
             PrintWriter writer = new PrintWriter(bytes, true);
             exception.printStackTrace(writer);
             if (node.getValue() == null || node.getValue().length() == 0) {
                 node.setValue(bytes.toString());
             } else {
                 node.setValue(node.getValue() + " : " + bytes.toString());
             }
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see net.sourceforge.servletspy.IContext#invalidate()
      */
     public void invalidate() {
         this.node = null;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see net.sourceforge.servletspy.IContext#proceed()
      */
     public void proceed() {
         transformerIndex++;
         try {
             if (transformerIndex < transformers.length && node != null) {
                 try {
                     node
                             .setDebugHint(ClassUtil.getSimpleClassName(transformers[transformerIndex].getClass())
                                     + " -- "
                                     + System.identityHashCode(getSubject()));
                     transformers[transformerIndex].handle(this);
                 } catch (InvocationTargetException e) {
                     final Throwable throwable = e.getTargetException();
                     handleException(throwable);
                 } catch (Exception e) {
                     handleException(e);
                 }
             }
         } finally {
             transformerIndex--;
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see net.sourceforge.servletspy.IContext#setSubject(java.lang.Object)
      */
     public void setSubject(final Object pSubject) {
         getIntrospectedMap().remove(this.subject);
         if (pSubject != null) {
             getIntrospectedMap().put(pSubject, this.getNode());
         }
         this.subject = pSubject;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see net.sourceforge.servletspy.IContext#setValue(java.lang.String)
      */
     public void setValue(final String value) {
         if (getNode() == null) {
             throw new IllegalStateException();
         }
         getNode().setValue(value);
     }
 }