/*
    * Copyright 2000-2004 The Apache Software Foundation.
    * 
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
    *      http://www.apache.org/licenses/LICENSE-2.0
    * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.jetspeed.services.webpage;
  
  // java.util
  import java.util.Properties;
  import java.util.Collection;
  
  // java.io
  import java.io.IOException;
  import java.io.FileNotFoundException;
  import java.io.FileInputStream;
  
  // javax.servlet
  import javax.servlet.http.*;
  import javax.servlet.RequestDispatcher;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletConfig;
  
  // velocity
  import org.apache.velocity.Template;
  import org.apache.velocity.context.Context;
  import org.apache.velocity.servlet.VelocityServlet;
  import org.apache.velocity.app.Velocity;
  import org.apache.velocity.exception.ResourceNotFoundException;
  import org.apache.velocity.exception.ParseErrorException;
  
  
  /***
    *
    * WebPageConsoleServlet is the main servlet entry point for the WebPage console. 
    *
    */
  
  public class WebPageConsoleServlet extends VelocityServlet
  {
  
      private String servletPath = null;
      private String proxyRoot = null;
      /*
       * Request Handler for a Velocity servlet. Includes the context.
       *
       * @param request Servlet request.
       * @param response Servlet response.
       * @context the velocity request context.
       * @exception IOException a servlet exception.
       * @exception ServletException a servlet exception.
       *     
       * @return The newly merged template.
       */
      public Template handleRequest( HttpServletRequest request, 
                                     HttpServletResponse response, 
                                     Context ctx )
      {
          if (servletPath == null)
          {
              servletPath = request.getServletPath();
              proxyRoot = getProxyHost(request);
          }
          
          boolean online = WebPageManager.isInit();
          if (online == false)
          {
              bootStrapProxy(request, response); // forward
          }
  
          String action = request.getParameter("action");
          String template;
          
          if (action == null)
              template = sessions(ctx);
          else if (action.equals("details"))
              template = elementSessions(ctx, request);
          else if (action.equals("test"))
              template = test(ctx, request);
          else if (action.equals("kill"))
              template = kill(ctx, request);
          else if (action.equals("killne"))
              template = killne(ctx);
          else if (action.equals("clear"))
              template = clear(ctx);
          else
              template = sessions(ctx);
                  
          
         Template outty = null;
         
         try
         {
             outty =  getTemplate(template);
         }
         catch( ParseErrorException pee )
         {
             System.out.println("WebPageConsoleServlet : parse error for template " + pee);
         }
         catch( ResourceNotFoundException rnfe )
         {
             System.out.println("WebPageConsoleServlet : template not found " + rnfe);
         }
         catch( Exception e )
         {
             System.out.println("Error " + e);
         }
         return outty;
 
     }
 
     /***  
      *  Set the log file to be off of the webapp root, and
      *  will do the same with the file loader paths
      *
      * @param config The Servlet configuration.
      * @return The Properties collection of Velocity properties.
      * @throws exceptions when failed to read the properties or log files
      */        
     protected Properties loadConfiguration(ServletConfig config)
     throws IOException, FileNotFoundException
     {
         /*
          *  get our properties file and load it
          */
 
         String propsFile = config.getInitParameter(INIT_PROPS_KEY);
 
         Properties p = new Properties();
 
         if ( propsFile != null )
         {
             String realPath = getServletContext().getRealPath(propsFile);
 
             if ( realPath != null )
             {
                 propsFile = realPath;
             }
 
             p.load( new FileInputStream(propsFile) );
         }
 
         /*
          *  first, normalize our velocity log file to be in the 
          *  webapp
          */
 
         String log = p.getProperty( Velocity.RUNTIME_LOG);
 
         if (log != null )
         {
             log = getServletContext().getRealPath( log );
 
             if (log != null)
             {
                 p.setProperty( Velocity.RUNTIME_LOG, log );
             }
         }
 
 
         /*
          *  now, if there is a file loader resource path, treat it the
          *  same way.
          */
 
         String path = p.getProperty( Velocity.FILE_RESOURCE_LOADER_PATH );
 
         if ( path != null)
         {
             path = getServletContext().getRealPath(  path );
 
             if ( path != null)
             {
                 p.setProperty( Velocity.FILE_RESOURCE_LOADER_PATH, path );
             }
         }
 
         return p;
     }  
 
     //////////////////////////////////////////////////////////////////////
 
     private String sessions(Context ctx)
     {
         // default Sessions screen
 
         Collection sessions = WebPageManager.getSessions();
         Collection targets = WebPageManager.getSites();
         boolean online = WebPageManager.isInit();
 
         ctx.put("sessions", sessions);
         ctx.put("targets", targets);  
         ctx.put("online", new Boolean(online));
         ctx.put("proxyError", WebPageManager.getErrorString());
         ctx.put("cmd", this);
         return "proxyConsole.vm";
     }
 
     //////////////////////////////////////////////////////////////////////
 
     private String elementSessions(Context ctx, HttpServletRequest request)
     {
         String sid = request.getParameter("id");
 
         if (sid == null)
         {
             return sessions(ctx);
         }
         // long id = Long.valueOf(sid).longValue();
         SessionMap map = WebPageManager.getSession(sid);
         if (map == null)
         {
             return sessions(ctx);
         }
 
         // default Sessions screen
         boolean online = WebPageManager.isInit();
     
         //Collection sessions = WebPageManager.getSessions();    
         //ctx.put("xxx_sessions", sessions );
 
         ctx.put("online", new Boolean(online));
         ctx.put("proxyError", WebPageManager.getErrorString());
         ctx.put("cmd", this);
         ctx.put("ne_sessions", map);
 
         return "neConsole.vm";  
     }
             
     //////////////////////////////////////////////////////////////////////
 
     private String kill(Context ctx, HttpServletRequest request)
     {
         // default Sessions screen
         boolean online = WebPageManager.isInit();
     
         Collection sessions = WebPageManager.getSessions();
         Collection elements = WebPageManager.getSites();
     
         ctx.put("xxx_sessions", sessions);
         ctx.put("elements", elements);  
         ctx.put("online", new Boolean(online));
         ctx.put("proxyError", WebPageManager.getErrorString());
         ctx.put("cmd", this);
         
         return "proxyConsole.vm";
     }
 
     //////////////////////////////////////////////////////////////////////
 
     private String killne(Context ctx)
     {
         return "proxyConsole.vm";
     }
 
     //////////////////////////////////////////////////////////////////////
 
     private String clear(Context ctx)
     {
         return "proxyConsole.vm";
     }
 
     //////////////////////////////////////////////////////////////////////
             
     private String test(Context ctx, HttpServletRequest request)
     {
         String id = request.getParameter("id");
         if (id == null)
         {
             return sessions(ctx);
         }
         SessionMap map = WebPageManager.getSession(id);
         if (map == null)
         {
             return sessions(ctx);
         }
         String ipa = request.getParameter("ipa");
         if (ipa == null)
         {
             return sessions(ctx);
         }
         SiteSession session = (SiteSession)map.get(ipa);
         if (session == null)
         {
             return sessions(ctx);
         }
 
         // default Sessions screen
         boolean online = WebPageManager.isInit();
     
         //Collection sessions = WebPageManager.getSessions();    
         //ctx.put("xxx_sessions", sessions );
 
         ctx.put("online", new Boolean(online));
         ctx.put("proxyError", WebPageManager.getErrorString());
         ctx.put("cmd", this);
         ctx.put("ne_sessions", map);
         //ctx.put("element", session.;
         ctx.put("nes", session);
 
         return "testConsole.vm";
     }
 
     //////////////////////////////////////////////////////////////////////
                   
     public String getRefresh()
     {
         return servletPath + "?action=refresh";
     }
 
     public String getClear()
     {
         return servletPath + "?action=clear";
     }
 
     public String getDetails()
     {
         return servletPath + "?action=details";
     }
 
     public String getTest()
     {
         return servletPath + "?action=test";
     }
 
     public String getKill()
     {
         return servletPath + "?action=kill";
     }
 
     public String getKillne()
     {
         return servletPath + "?action=killne";
     }
 
     public String getLogon()
     {
         String proxy = proxyRoot;
         Configuration config = Configuration.getInstance();
         proxy = proxy.concat("?logon-test=true&" + config.getSID() + "=");
         return proxy;
     }
 
     public String getProxyRoot()
     {
         return proxyRoot;
     }
 
     public String getWebapp()
     {
         Configuration config = Configuration.getInstance();
         return config.getWebapp();
         //return ProxyUtil.concatURLs(proxyRoot, config.getWebapp());
     }
 
     ////////////////////////////////////////////////////////////////////
 
     private String getProxyHost(HttpServletRequest request)
     {    
         StringBuffer root = new StringBuffer();
         String scheme = request.getScheme();
         root.append(scheme);
         root.append( "://");
         int port = request.getServerPort();
         root.append(request.getServerName());  
     
         if ( (port > 0) &&
              ((scheme.equals("http") && port != 80) ||
               (scheme.equals("https") && port != 443)
              )
            )
         {
             root.append(":");
             root.append(port);
         }
         root.append( Configuration.WPS_SERVLET );
         return root.toString();
     }
 
     //////////////////////////////////////////////////////////////
 
     void bootStrapProxy(HttpServletRequest request, 
                         HttpServletResponse response)
     {
 
         ServletContext ctx = getServletContext();
 
         try
         {
             RequestDispatcher dispatcher 
                                 = ctx.getRequestDispatcher(Configuration.WPS_SERVLET);
             
             dispatcher.forward(request, response);
         } 
         catch (Exception e) 
         {
         }
     }
 }