/*
    * $Source$
    * $Revision$
    *
    * Copyright (c) 1998, 1999, 2000 Semiotek Inc. All Rights Reserved.
    *
    * This software is the confidential intellectual property of
    * of Semiotek Inc.; it is copyrighted and licensed, not sold.
    * You may use it under the terms of the GNU General Public License,
   * version 2, as published by the Free Software Foundation. If you 
   * do not want to use the GPL, you may still use the software after
   * purchasing a proprietary developers license from Semiotek Inc.
   *
   * This software is provided "as is", with NO WARRANTY, not even the 
   * implied warranties of fitness to purpose, or merchantability. You
   * assume all risks and liabilities associated with its use.
   *
   * See the attached License.html file for details, or contact us
   * by e-mail at info@semiotek.com to get a copy.
   */
  
  package org.melati.test;
  
  import java.io.IOException;
  import java.util.Date;
  
  import javax.servlet.ServletConfig;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.melati.util.MelatiBugMelatiException;
  import org.webmacro.FastWriter;
  import org.webmacro.InitException;
  import org.webmacro.ResourceException;
  import org.webmacro.Template;
  import org.webmacro.WM;
  import org.webmacro.WebMacro;
  import org.webmacro.servlet.WebContext;
  
  /**
   * This example demonstrates using WebMacro in "standalone" mode. Instead of
   * subclassing from WMServlet you create and maintain your own WebMacro object
   * and you are free to subclass from another servlet. Also, this technique can
   * be used outside the servlet context.
   * <p>
   * The WebMacro master object is initialized when the servlet is initialized and
   * destroyed when the servlet is destroyed. There is some overhead involved in
   * creating the interface so you should prefer not to create one on every
   * request, although it is not too expensive.
   * <p>
   * This servlet can be compiled and installed as an ordinary servlet. You need
   * to ensure that your WebMacro.properties file is properly configured and
   * available on your CLASSPATH. When setting up WebMacro.properties make sure
   * that the TemplatePath is correctly set and that the template used by this
   * servlet, "standalone.wm", is available on that path.
   */
  public class WebmacroStandalone extends HttpServlet {
    private static final long serialVersionUID = 1L;
  
    /**
     * This is the core WebMacro interface which we use to create Contexts, load
     * Templates, and begin other WebMacro operations.
     */
    private WebMacro _wm = null;
  
    /**
     * The init() method will be called by your servlet runner whenever it wants
     * to instantiate a new copy of your servlet. We initialize WebMacro here so
     * as to avoid the expense of initializing it on every request.
     */
    public void init(ServletConfig sc) throws ServletException {
      try {
        if (_wm == null) {
          _wm = new WM();
        }
      } catch (InitException e) {
        throw new ServletException("Could not initialize WebMacro: " + e);
      }
    }
  
    /**
     * It's not strictly necessary to destroy the WebMacro object when you're done
     * with it--garbage collection will eventually get it--but it makes sure the
     * resources get freed. You really ought to do this, since it might be a lot
     * of resources.
     */
    public void destroy() {
      // It could of course be null already, but cheaper to re-null;
      // and you get better test coverage.
     _wm = null;
    }
  
    /**
     * We only implement the GET method in this servlet.
     * <p>
     * We create a WebContext object, populate it with some data, select a
     * template, and write the output of that template to the output stream. Note
    * that you need to pass the WebContext object to the template in order to
    * write it, you also need an output stream, in this case the
    * HttpServletResponse output stream is used.
    * <p>
    * If you were using WebMacro outside a servlet context you would not be able
    * to construct a WebContext object, since you would not have the
    * HttpServletRequest and HttpServletResponse objects which you need in order
    * to do that. WebContext is a subclass of Context, so outside of a servlet
    * just construct a TemplateContext object. You will obviously lose the
    * ability to talk about servlet specific things in your templates (such as
    * "Cookies") but otherwise it's the same.
    * <p>
    * There are a few exceptions you have to deal with. First, WebMacro may not
    * be able to locate the template you've requested in which case it'll throw a
    * NotFoundException. Second, the template will expect to find certain
    * information in the TemplateContext, and if you fail to provide that
    * information a ContextException will be thrown.
    */
   public void doGet(HttpServletRequest req, HttpServletResponse resp)
       throws IOException {
     String templateName = "org/melati/test/WebmacroStandalone.wm";
 
     WebContext context = new WebContext(_wm.getBroker(), req, resp);
 
     // fill up the context with our data
     context.put("Today", new Date());
     context.put("Number", new Long(23));
 
     // WebContext provides some utilities as well
     String other = context.getForm("other");
     if (other == null) {
       context.put("hello", "Hello again!"); // put this into the hash
     } else {
       context.put("hello", other); // else put this in
     }
     String templateNameFromForm = context.getForm("templateName");
     if (templateNameFromForm != null )
       templateName = templateNameFromForm;
     FastWriter fw = new FastWriter(_wm.getBroker(), resp.getOutputStream(),
         resp.getCharacterEncoding());
     // get the template we intend to execute
     Template template = null;
     try {
       template = _wm.getTemplate(templateName);
     } catch (ResourceException e) {
 
       fw.write("ERROR!  Could not locate template "
               + templateName
               + ", if you are not using a modified WebMacro.properties then it should be on the CLASSPATH.");
       e.printStackTrace();
       fw.close();
       return;
     }
     try {
       // write the template to the output, using our context
       template.write(fw.getOutputStream(), context);
     } catch (org.webmacro.ContextException e) {
        throw new MelatiBugMelatiException("You have misconfigured WebMacro.", e);
     } finally { 
       fw.close();
     }
   }
 
 }