package org.webslinger.servlet.webxml;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import java.util.TreeSet;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.servlet.Filter;

 import javax.servlet.Servlet;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import org.apache.commons.vfs.FileObject;

 import org.w3c.dom.Element;

 import org.w3c.dom.Document;

 import org.w3c.dom.Node;

 import org.w3c.dom.Text;

 import org.webslinger.util.MimeTypeLookup;

 import org.webslinger.util.MimeTypes;

 import org.webslinger.util.MimeTypes.MimeTypeEntry;

 import org.webslinger.xml.XmlUtil;

 import org.xml.sax.SAXException;

 public class WebXml extends Parameterized implements MimeTypeLookup {

     private static final Logger logger = Logger.getLogger(WebXml.class.getName());

     public static final DocumentBuilderFactory domBuilderFactory = DocumentBuilderFactory.newInstance();

     protected String icon;

     protected String displayName;

     protected String description;

     protected boolean distributable;

     protected ConfiguredFilter[] filters = new ConfiguredFilter[0];

     protected String[] listeners = new String[0];

     protected ConfiguredServlet[] servlets = new ConfiguredServlet[0];

     protected int sessionTimeout;

     protected final List<String> welcomeFiles = new ArrayList<String>();

     protected FilterMapping[] filterMappings = new FilterMapping[0];

     protected final MimeTypes mimeTypes;

     public WebXml() throws IOException {

         mimeTypes = new MimeTypes();

         mimeTypes.load(getClass().getClassLoader().getResources("org/webslinger/mime.types"));

     }

     public WebXml(MimeTypes mimeTypes) throws IOException {

         this.mimeTypes = mimeTypes;

     }

     public WebXml(Document doc) throws IOException {

         this(doc.getDocumentElement());

     }

     public WebXml(MimeTypes mimeTypes, Document doc) throws IOException {

         this(mimeTypes, doc.getDocumentElement());

     }

     public WebXml(Element element) throws IOException {

         this();

         parse(element);

     }

     public WebXml(MimeTypes mimeTypes, Element element) throws IOException {

         this(mimeTypes);

         parse(element);

     }

     public WebXml(FileObject file) throws IOException, ParserConfigurationException, SAXException {

         this();

         parse(file);

     }

     public WebXml(MimeTypes mimeTypes, FileObject file) throws IOException, ParserConfigurationException, SAXException {

         this(mimeTypes);

         parse(file);

     }

     public String getMimeType(String extension) {

         return mimeTypes.getMimeType(extension);

     }

     public String[] getExtensions(String mimeType) {

         return mimeTypes.getExtensions(mimeType);

     }

     public String getPrimaryExtension(String mimeType) {

         return mimeTypes.getPrimaryExtension(mimeType);

     }

     public String getIcon() {

         return icon;

     }

     public String getDisplayName() {

         return displayName;

     }

     public String getDescription() {

         return description;

     }

     public boolean getDistributable() {

         return distributable;

     }

     public ConfiguredFilter[] getFilters() {

         return filters;

     }

     public FilterMapping[] getFilterMappings() {

         return filterMappings;

     }

     public String[] getListeners() {

         return listeners;

     }

     public ConfiguredServlet[] getServlets() {

         return servlets;

     }

     public int getSessionTimeout() {

         return sessionTimeout;

     }

 /*

 <web-app version="2.3">

  <icon/>?

  <display-name/>?

  <description/>?

  <distributable/>?

  (<container-param><param-name>debug</param-name><param-value>0</param-value></container-param>)*

  (<filter/>)*

  (<filter-mapping><filter-name>ssi</filter-name><url-pattern>*.shtml</url-pattern></filter-mapping>)*

  (<listener/>)*

  (<servlet/>)*

  (<servlet-mapping><servlet-name>default</servlet-name><url-pattern>/</url-pattern></servlet-mapping>)*

  <session-config>

   <session-timeout>30</session-timeout>

  </session-config>

  <mime-mapping>

   <extension>abs</extension>

   <mime-type>audio/x-mpeg</mime-type>

  </mime-mapping>

  <welcome-file-list>

   <welcome-file>index.html</welcome-file>

   <welcome-file>index.htm</welcome-file>

   <welcome-file>index.jsp</welcome-file>

  </welcome-file-list>

  (<error-page>

    (<error-code/>|<exception-type/>)

    <location/>

   </error-page>)*

  (<taglib/>)*

  (<resource-env-ref/>)*

  (<resource-ref/>)*

  (<security-constraint/>)*

  <login-config/>?

  (<security-role/>)*

  (<env-entry/>)*

  (<ejb-ref/>)*

  (<ejb-local-ref/>)*

 </web-app>

 */

     public void parse(FileObject file) throws IOException, ParserConfigurationException, SAXException {

         if (file.exists()) {

             DocumentBuilder domBuilder = domBuilderFactory.newDocumentBuilder();

             Document doc = domBuilder.parse(file.getContent().getInputStream(), file.getName().toString());

             parse(doc.getDocumentElement());

         }

     }

     public void parse(Element element) {

         TreeSet<ConfiguredFilter> filters = new TreeSet<ConfiguredFilter>();

         TreeSet<ConfiguredServlet> servlets = new TreeSet<ConfiguredServlet>();

         TreeSet<String> listeners = new TreeSet<String>();

         List<FilterMapping> filterMappings = new ArrayList<FilterMapping>();

         Node node = element.getFirstChild();

         while (node != null) {

             if (node instanceof Element) {

                 String nodeName = node.getNodeName();

                 if ("icon".equals(nodeName)) {

                     icon = XmlUtil.getNodeSubText(node);

                 } else if ("display-name".equals(nodeName)) {

                     displayName = XmlUtil.getNodeSubText(node);

                 } else if ("description".equals(nodeName)) {

                     description = XmlUtil.getNodeSubText(node);

                 } else if ("distributable".equals(nodeName)) {

                     distributable = true;

                 } else if ("context-param".equals(nodeName)) {

                     parseParameter(node);

                 } else if ("filter".equals(nodeName)) {

                     ConfiguredFilter configuredFilter = new ConfiguredFilter((Element) node);

                     filters.remove(configuredFilter);

                     filters.add(configuredFilter);

                 } else if ("filter-mapping".equals(nodeName)) {

                     filterMappings.add(new FilterMapping((Element) node));

                 } else if ("listener".equals(nodeName)) {

                     parseListener(listeners, node);

                 } else if ("servlet".equals(nodeName)) {

                     ConfiguredServlet configuredServlet = new ConfiguredServlet((Element) node);

                     servlets.remove(configuredServlet);

                     servlets.add(configuredServlet);

                 } else if ("session-config".equals(nodeName)) {

                     parseSessionConfig(node);

                 } else if ("mime-mapping".equals(nodeName)) {

                     parseMimeMapping(node);

                 } else if ("welcome-file-list".equals(nodeName)) {

                     parseWelcomeFileList(node);

                 }

             }

             node = node.getNextSibling();

         }

         this.filters = filters.toArray(new ConfiguredFilter[filters.size()]);

         this.listeners = listeners.toArray(new String[listeners.size()]);

         this.servlets = servlets.toArray(new ConfiguredServlet[servlets.size()]);

         this.filterMappings = filterMappings.toArray(new FilterMapping[filterMappings.size()]);

     }

     public void init(ClassLoader loader) {

         verifyConfiguredClasses("servlet", servlets, Servlet.class, loader);

         verifyConfiguredClasses("filter", filters, Filter.class, loader);

     }

     protected void parseListener(Collection<String> listeners, Node node) {

         node = node.getFirstChild();

         String listenerClassName = null;

         while (node != null) {

             if (node instanceof Element) {

                 String nodeName = node.getNodeName();

                 if ("listener-class".equals(nodeName)) {

                     listenerClassName = XmlUtil.getNodeSubText(node);

                 }

             }

             node = node.getNextSibling();

         }

         if (listenerClassName != null) listeners.add(listenerClassName);

     }

     protected void parseSessionConfig(Node node) {

         node = node.getFirstChild();

         while (node != null) {

             if (node instanceof Element) {

                 String nodeName = node.getNodeName();

                 if ("session-timeout".equals(nodeName)) {

                     sessionTimeout = Integer.parseInt(XmlUtil.getNodeSubText(node));

                 }

             }

             node = node.getNextSibling();

         }

     }

     protected void parseMimeMapping(Node node) {

         node = node.getFirstChild();

         String extension = null;

         String mimeType = null;

         while (node != null) {

             if (node instanceof Element) {

                 String nodeName = node.getNodeName();

                 if ("extension".equals(nodeName)) {

                     extension = XmlUtil.getNodeSubText(node);

                 } else if ("mime-type".equals(nodeName)) {

                     mimeType = XmlUtil.getNodeSubText(node);

                 }

             }

             node = node.getNextSibling();

         }

         MimeTypeEntry entry = mimeTypes.addMimeType(mimeType);

         entry.addExtension(extension);

         entry.setPrimaryExtension(extension);

     }

     protected void parseWelcomeFileList(Node node) {

         node = node.getFirstChild();

         while (node != null) {

             if (node instanceof Element) {

                 String nodeName = node.getNodeName();

                 if ("welcome-file".equals(nodeName)) {

                     welcomeFiles.add(XmlUtil.getNodeSubText(node));

                 }

             }

             node = node.getNextSibling();

         }

     }

     protected <T> void verifyConfiguredClasses(String label, Configured[] configuredItems, Class<T> implClass, ClassLoader loader) {

         for (Configured configured: configuredItems) {

             try {

                 Class<?> clz = Class.forName(configured.getClassName(), true, loader);

                 if (!implClass.isAssignableFrom(clz)) {

                     logger.log(Level.SEVERE, "Not a " + label + ": " + clz);

                 }

             } catch (ClassNotFoundException e) {

                 logger.log(Level.SEVERE, "Could not find " + configured.getClassName() + " for servlet " + configured.getName(), e);

             }

         }

     }

 }