//
   //  ========================================================================
   //  Copyright (c) 1995-2012 Sabre Holdings.
   //  ------------------------------------------------------------------------
   //  All rights reserved. This program and the accompanying materials
   //  are made available under the terms of the Eclipse Public License v1.0
   //  and Apache License v2.0 which accompanies this distribution.
   //
   //      The Eclipse Public License is available at
  //      http://www.eclipse.org/legal/epl-v10.html
  //
  //      The Apache License v2.0 is available at
  //      http://www.opensource.org/licenses/apache2.0.php
  //
  //  You may elect to redistribute this code under either of these licenses.
  //  ========================================================================
  //
  
  
  package org.eclipse.jetty.ant;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.MalformedURLException;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import org.eclipse.jetty.ant.types.Connector;
  import org.eclipse.jetty.ant.types.ContextHandlers;
  import org.eclipse.jetty.ant.utils.ServerProxy;
  import org.eclipse.jetty.ant.utils.TaskLog;
  import org.eclipse.jetty.security.LoginService;
  import org.eclipse.jetty.server.Handler;
  import org.eclipse.jetty.server.RequestLog;
  import org.eclipse.jetty.server.Server;
  import org.eclipse.jetty.server.ServerConnector;
  import org.eclipse.jetty.server.ShutdownMonitor;
  import org.eclipse.jetty.server.handler.ContextHandler;
  import org.eclipse.jetty.server.handler.ContextHandlerCollection;
  import org.eclipse.jetty.server.handler.DefaultHandler;
  import org.eclipse.jetty.server.handler.HandlerCollection;
  import org.eclipse.jetty.server.handler.RequestLogHandler;
  import org.eclipse.jetty.util.Scanner;
  import org.eclipse.jetty.util.resource.Resource;
  import org.eclipse.jetty.xml.XmlConfiguration;
  import org.xml.sax.SAXException;
  
  
  
  /**
   * A proxy class for interaction with Jetty server object. Used to have some
   * level of abstraction over standard Jetty classes.
   */
  public class ServerProxyImpl implements ServerProxy
  {
  
      /** Proxied Jetty server object. */
      private Server server;
      
      /** Temporary files directory. */
      private File tempDirectory;
      
      /** Collection of context handlers (web application contexts). */
      private ContextHandlerCollection contexts;
  
      /** Location of jetty.xml file. */
      private File jettyXml;
  
      /** List of connectors. */
      private List<Connector> connectors;
  
      /** Request logger. */
      private RequestLog requestLog;
  
      /** User realms. */
      private List<LoginService> loginServices;
  
      /** List of added web applications. */
      private List<AntWebAppContext> webApplications = new ArrayList<AntWebAppContext>();
  
      /** other contexts to deploy */
      private ContextHandlers contextHandlers;
  
      /** scan interval for changed files */
      private int scanIntervalSecs;
  
      /** port to listen for stop command */
      private int stopPort;
  
      /** security key for stop command */
      private String stopKey;
  
      /** wait for all jetty threads to exit or continue */
      private boolean daemon;
  
  
      private boolean configured = false;
  
 
     
     /**
      * WebAppScannerListener
      *
      * Handle notifications that files we are interested in have changed
      * during execution.
      * 
      */
     public static class WebAppScannerListener implements Scanner.BulkListener
     {     
         AntWebAppContext awc;
 
         public WebAppScannerListener (AntWebAppContext awc)
         {
             this.awc = awc;
         }
 
         public void filesChanged(List<String> changedFileNames)
         {
             boolean isScanned = false;
             try
             {
                 Iterator<String> itor = changedFileNames.iterator();
                 while (!isScanned && itor.hasNext())
                 {
                     isScanned = awc.isScanned(Resource.newResource(itor.next()).getFile());
                 }
                 if (isScanned)
                 {
                     awc.stop();
                     awc.start();
                 }
             }
             catch (Exception e)
             {
                 TaskLog.log(e.getMessage());
             }
         }
 
     }
 
 
     /**
      * Default constructor. Creates a new Jetty server with a standard connector
      * listening on a given port.
      */
     public ServerProxyImpl ()
     {
         server = new Server();
         server.setStopAtShutdown(true);
     }
 
    
     public void addWebApplication(AntWebAppContext webApp)
     {
        webApplications.add(webApp);
     }
 
     public int getStopPort()
     {
         return stopPort;
     }
 
     public void setStopPort(int stopPort)
     {
         this.stopPort = stopPort;
     }
 
     public String getStopKey()
     {
         return stopKey;
     }
 
     public void setStopKey(String stopKey)
     {
         this.stopKey = stopKey;
     }
 
     public File getJettyXml()
     {
         return jettyXml;
     }
 
     public void setJettyXml(File jettyXml)
     {
         this.jettyXml = jettyXml;
     }
 
     public List<Connector> getConnectors()
     {
         return connectors;
     }
 
     public void setConnectors(List<Connector> connectors)
     {
         this.connectors = connectors;
     }
 
     public RequestLog getRequestLog()
     {
         return requestLog;
     }
 
     public void setRequestLog(RequestLog requestLog)
     {
         this.requestLog = requestLog;
     }
 
     public List<LoginService> getLoginServices()
     {
         return loginServices;
     }
 
     public void setLoginServices(List<LoginService> loginServices)
     {
         this.loginServices = loginServices;
     }
 
     public List<AntWebAppContext> getWebApplications()
     {
         return webApplications;
     }
 
     public void setWebApplications(List<AntWebAppContext> webApplications)
     {
         this.webApplications = webApplications;
     }
 
     
     public File getTempDirectory()
     {
         return tempDirectory;
     }
 
 
     public void setTempDirectory(File tempDirectory)
     {
         this.tempDirectory = tempDirectory;
     }
 
 
     /**
      * @see org.eclipse.jetty.ant.utils.ServerProxy#start()
      */
     public void start()
     {
         try
         {
             configure();
             
             configureWebApps();
             
             server.start();
          
             System.setProperty("jetty.ant.server.port","" + ((ServerConnector)server.getConnectors()[0]).getLocalPort());
             
             String host = ((ServerConnector)server.getConnectors()[0]).getHost();
             
             if (host == null)
             {
                 System.setProperty("jetty.ant.server.host", "localhost");
             }
             else
             {
                 System.setProperty("jetty.ant.server.host", host);
             }
             
             startScanners();
             
             TaskLog.log("Jetty AntTask Started");
 
             if (!daemon)
                 server.join();
         }
         catch (InterruptedException e)
         {
             new RuntimeException(e);
         }
         catch (Exception e)
         {
             e.printStackTrace();
             new RuntimeException(e);
         }
     }
 
 
 
   
     /**
      * @see org.eclipse.jetty.ant.utils.ServerProxy#getProxiedObject()
      */
     public Object getProxiedObject()
     {
         return server;
     }
 
 
     /**
      * @return the daemon
      */
     public boolean isDaemon()
     {
         return daemon;
     }
 
 
     /**
      * @param daemon the daemon to set
      */
     public void setDaemon(boolean daemon)
     {       
         this.daemon = daemon;
     }
 
 
     /**
      * @return the contextHandlers
      */
     public ContextHandlers getContextHandlers()
     {
         return contextHandlers;
     }
 
 
     /**
      * @param contextHandlers the contextHandlers to set
      */
     public void setContextHandlers (ContextHandlers contextHandlers)
     {
         this.contextHandlers = contextHandlers;
     }
 
 
     public int getScanIntervalSecs()
     {
         return scanIntervalSecs;
     }
 
 
     public void setScanIntervalSecs(int scanIntervalSecs)
     {
         this.scanIntervalSecs = scanIntervalSecs;
     }
     
 
     /**
      * Configures Jetty server before adding any web applications to it.
      */
     private void configure()
     {
         if (configured)
             return;
         
         configured = true;
 
         if(stopPort>0 && stopKey!=null)
         {
             ShutdownMonitor monitor = ShutdownMonitor.getInstance();
             monitor.setPort(stopPort);
             monitor.setKey(stopKey);
             monitor.setExitVm(false);
         }
         
         if (tempDirectory != null && !tempDirectory.exists())
             tempDirectory.mkdirs();
         
         // Applies external configuration via jetty.xml
         applyJettyXml();
 
         // Configures connectors for this server instance.
         if (connectors != null)
         {
             for (Connector c:connectors)
             {
                 ServerConnector jc = new ServerConnector(server);
 
                 jc.setPort(c.getPort());
                 jc.setIdleTimeout(c.getMaxIdleTime());
 
                 server.addConnector(jc);
             }
         }
 
         // Configures login services
         if (loginServices != null)
         {
             for (LoginService ls:loginServices)
             {
                 server.addBean(ls);
             }
         }
 
         // Does not cache resources, to prevent Windows from locking files
         Resource.setDefaultUseCaches(false);
 
         // Set default server handlers
         configureHandlers();
     }
     
     
     /**
      * 
      */
     private void configureHandlers()
     {
         RequestLogHandler requestLogHandler = new RequestLogHandler();
         if (requestLog != null)
             requestLogHandler.setRequestLog(requestLog);
 
         contexts = (ContextHandlerCollection) server
                 .getChildHandlerByClass(ContextHandlerCollection.class);
         if (contexts == null)
         {
             contexts = new ContextHandlerCollection();
             HandlerCollection handlers = (HandlerCollection) server
                     .getChildHandlerByClass(HandlerCollection.class);
             if (handlers == null)
             {
                 handlers = new HandlerCollection();
                 server.setHandler(handlers);
                 handlers.setHandlers(new Handler[] { contexts, new DefaultHandler(),
                         requestLogHandler });
             }
             else
             {
                 handlers.addHandler(contexts);
             }
         }
         
         //if there are any extra contexts to deploy
         if (contextHandlers != null && contextHandlers.getContextHandlers() != null)
         {
             for (ContextHandler c:contextHandlers.getContextHandlers())
                 contexts.addHandler(c);
         }
     }
 
 
 
     
     /**
      * Applies jetty.xml configuration to the Jetty server instance.
      */
     private void applyJettyXml()
     {
         if (jettyXml != null && jettyXml.exists())
         {
             TaskLog.log("Configuring jetty from xml configuration file = "
                     + jettyXml.getAbsolutePath());
             XmlConfiguration configuration;
             try
             {
                 configuration = new XmlConfiguration(Resource.toURL(jettyXml));
                 configuration.configure(server);
             }
             catch (MalformedURLException e)
             {
                 throw new RuntimeException(e);
             }
             catch (SAXException e)
             {
                 throw new RuntimeException(e);
             }
             catch (IOException e)
             {
                 throw new RuntimeException(e);
             }
             catch (Exception e)
             {
                 throw new RuntimeException(e);
             }
         }
     }
 
     
     /**
      * Starts web applications' scanners.
      */
     private void startScanners() throws Exception
     {
         for (AntWebAppContext awc:webApplications)
         {
             if (scanIntervalSecs <= 0)
                 return;
 
             List<File> scanList = awc.getScanFiles();
  
             TaskLog.log("Web application '" + awc + "': starting scanner at interval of "
                     + scanIntervalSecs + " seconds.");
             Scanner.Listener changeListener = new WebAppScannerListener(awc);
             Scanner scanner = new Scanner();
             scanner.setScanInterval(scanIntervalSecs);
             scanner.addListener(changeListener);
             scanner.setScanDirs(scanList);
             scanner.setReportExistingFilesOnStartup(false);
             scanner.start();
         }  
     }
     
     
     /**
      * 
      */
     private void configureWebApps()
     {
         for (AntWebAppContext awc:webApplications)
         {
             awc.setAttribute(AntWebAppContext.BASETEMPDIR, tempDirectory);
             if (contexts != null)
                 contexts.addHandler(awc);
         }
     }
     
 }