package org.webslinger.container;

 import java.io.File;

 import java.io.IOException;

 import java.io.PrintStream;

 import java.lang.ref.Reference;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.servlet.Filter;

 import javax.servlet.RequestDispatcher;

 import javax.servlet.Servlet;

 import javax.servlet.ServletException;

 import javax.servlet.http.HttpServletRequest;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import org.xml.sax.SAXException;

 import org.apache.commons.vfs.FileContent;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileSystemManager;

 import org.webslinger.PathContext;

 import org.webslinger.Root;

 import org.webslinger.Webslinger;

 import org.webslinger.WebslingerClassLoader;

 import org.webslinger.WebslingerFilter;

 import org.webslinger.WebslingerFilterServlet;

 import org.webslinger.WebslingerServletContext;

 import org.webslinger.WebslingerServletContextFactory;

 import org.apache.commons.collections.iterators.IteratorEnumeration;

 import org.webslinger.commons.vfs.CommonsVfsRollingWriter;

 import org.webslinger.commons.vfs.VFSUtil;

 import org.webslinger.commons.vfs.cow.COWEntry;

 import org.webslinger.commons.vfs.cow.COWFileSystem;

 import org.webslinger.commons.vfs.virtual.VirtualFileSystem;

 import org.webslinger.io.GenericRollingWriterFactory;

 import org.webslinger.io.IOUtil;

 import org.webslinger.io.RollingWriter;

 import org.webslinger.io.RollingWriterFactory;

 import org.webslinger.lang.ConcurrentCache;

 import org.webslinger.lang.ConcurrentFreezingCache;

 import org.webslinger.lang.Freezer;

 import org.webslinger.lang.ObjectWrapper;

 import org.webslinger.modules.ModuleState;

 import org.webslinger.rules.CompiledRules;

 import org.webslinger.rules.CSSRulesTTLCachedObject;

 import org.webslinger.servlet.webxml.ConfiguredFilter;

 import org.webslinger.servlet.webxml.ConfiguredServlet;

 import org.webslinger.servlet.webxml.FilterMapping;

 import org.webslinger.servlet.webxml.WebXml;

 import org.webslinger.util.MimeTypeLookup;

 import org.webslinger.util.TTLObject;

 import org.webslinger.xml.XmlUtil;

 public class WebslingerContainer implements Root {

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

     public static final String DEFAULT_MIME_TYPE = "application/x-webslinger-default";

     static {

         TTLObject.setDefaultTTLForClass(PathParsingTTLObject.class, 1000);

         TTLObject.setDefaultTTLForClass(ConfigTTLObject.class, 1000);

         TTLObject.setDefaultTTLForClass(ExtensionListTTLObject.class, 1000);

     }

     protected final WebslingerServletContextFactory factory;

     protected final ConcurrentFreezingCache<FileObject, String, FileInfo> fileInfoCache = new ConcurrentFreezingCache<FileObject, String, FileInfo>(WebslingerContainer.class, "fileInfoCache", null, ConcurrentCache.SOFT, FileFreezer) {

         protected FileInfo createValue(Object id, String path) {

             return new CommonsVfsFileInfo(WebslingerContainer.this, (FileObject) id);

         }

     };

     protected final ConcurrentCache<String, PathParsingTTLObject> lookForFilterCache = new ConcurrentCache<String, PathParsingTTLObject>(WebslingerContainer.class, "lookForFilterCache", null, ConcurrentCache.SOFT) {

         protected PathParsingTTLObject createValue(String key) {

             return new PathParsingTTLObject(key, true);

         }

     };

     protected final ConcurrentCache<String, PathParsingTTLObject> fullPathCache = new ConcurrentCache<String, PathParsingTTLObject>(WebslingerContainer.class, "fullPathCache", null, ConcurrentCache.SOFT) {

         protected PathParsingTTLObject createValue(String key) {

             return new PathParsingTTLObject(key, false);

         }

     };

     protected final WebslingerClassLoader wcl;

     protected final FileObject root;

     protected final FileObject www;

     protected final ConfigTTLObject config;

     protected final TTLObject<String[]> extensionList;

     protected final HashMap<String, ServletRequestDispatcher> webXmlServlets = new HashMap<String, ServletRequestDispatcher>();

     protected final HashMap<String, WebslingerFilter> webXmlFilters = new HashMap<String, WebslingerFilter>();

     protected final WebXml webXml;

     protected final CSSRulesTTLCachedObject rules;

     protected final RollingWriterFactory logFactory;

     protected WebslingerServletContext context;

     public WebslingerContainer(WebslingerServletContextFactory factory, FileObject root, WebXml webXml) throws IOException {

         wcl = new WebslingerClassLoader(getClass().getClassLoader(), root);

         this.factory = factory;

         FileSystemManager fsm = root.getFileSystem().getFileSystemManager();

         this.root = root;

         FileObject www = root.resolveFile("www");

         www.createFolder();

         this.www = fsm.createFileSystem("wsvfs", www);

         config = new ConfigTTLObject(this.www.resolveFile("/WEB-INF/Config"));

         this.webXml = webXml;

         String extensionList = webXml.getParameters().get("webslingerExtensionList");

         if (extensionList != null) {

             final String[] extensionListSplit = extensionList != null ? extensionList.split("[, \r\n]") : new String[0];

             this.extensionList = new TTLObject<String[]>() {

                 public long getTTL() {

                     return 600000;

                 }

                 protected String[] load(String[] old) {

                     return extensionListSplit;

                 }

             };

         } else {

             this.extensionList = new ExtensionListTTLObject();

         }

         rules = new CSSRulesTTLCachedObject(WebslingerContainer.this, WebslingerContainer.this.www.resolveFile("/WEB-INF/rules.css"));

         logFactory = new LogWriterFactory("'.'yyyy-MM-dd");

     }

     public WebslingerClassLoader getClassLoader() {

         return wcl;

     }

     public WebslingerServletContext getWebslingerServletContext() {

         return context;

     }

     public WebslingerServletContextFactory getFactory() {

         return factory;

     }

     public void initializeRequest(WebslingerServletContext context, HttpServletRequest request) {

         getFactory().initializeRequest(context, request);

     }

     public String[] getConfigStringSplit(String name) throws IOException {

         String value = getConfigString(name);

         if (value == null) return new String[0];

         return value.split("[, ]");

     }

     public String getConfigString(String name) throws IOException {

         Object value = getConfigItem(name);

         if (value instanceof String) return (String) value;

         if (value == null) return null;

         return value.toString();

     }

     public Object getConfigItem(String name) throws IOException {

         FileObject config = this.config.getObject();

         return config.exists() ? config.getContent().getAttribute(name) : null;

     }

     public RollingWriterFactory getLogFactory() {

         return logFactory;

     }

     public WebXml getWebXml() {

         return webXml;

     }

     public CompiledRules getRules() throws IOException {

         try {

             return (CompiledRules) rules.getObject();

         } catch (Exception e) {

             return IOUtil.checkException(e);

         }

     }

     public String getDefaultMimeType() {

         return DEFAULT_MIME_TYPE;

     }

     public Object start() {

         return null;

     }

     public void finish(Object data) {

     }

     public void init(WebslingerServletContext context) throws IOException, ServletException {

         this.context = context;

         ClassLoader loader = getClassLoader();

         webXml.init(loader);

         for (ConfiguredServlet configuredServlet: webXml.getServlets()) {

             try {

                 Class servletClass = Class.forName(configuredServlet.getClassName(), true, loader);

                 Servlet servlet = (Servlet) servletClass.newInstance();

                 javax.servlet.ServletConfig servletConfig = new ServletConfigImpl(context, configuredServlet.getParameters(), configuredServlet.getName());

                 servlet.init(servletConfig);

                 webXmlServlets.put(configuredServlet.getName(), new ServletRequestDispatcher(servlet));

             } catch (ServletException e) {

                 throw e;

             } catch (Error e) {

                 log("Couldn't load servlet " + configuredServlet.getName(), e);

             } catch (RuntimeException e) {

                 log("Couldn't load servlet " + configuredServlet.getName(), e);

             } catch (Exception e) {

                 throw new ServletException(e.getMessage(), e);

             }

         }

         for (ConfiguredFilter configuredFilter: webXml.getFilters()) {

             try {

                 Class filterClass = Class.forName(configuredFilter.getClassName(), true, loader);

                 Filter filter = (Filter) filterClass.newInstance();

                 javax.servlet.FilterConfig filterConfig = new FilterConfigImpl(context, configuredFilter.getParameters(), configuredFilter.getName());

                 if (!(filter instanceof WebslingerFilter)) {

                     filter = new WebslingerFilterServlet(filter);

                 }

                 filter.init(filterConfig);

                 webXmlFilters.put(configuredFilter.getName(), (WebslingerFilter) filter);

             } catch (ServletException e) {

                 throw e;

             } catch (Error e) {

                 log("Couldn't load filter " + configuredFilter.getName(), e);

             } catch (RuntimeException e) {

                 log("Couldn't load filter " + configuredFilter.getName(), e);

             } catch (Exception e) {

                 throw new ServletException(e.getMessage(), e);

             }

         }

     }

     public WebslingerFilter getServletFilter(String name) {

         return webXmlFilters.get(name);

     }

     public String[] getExtensionList() throws IOException {

         try {

             return extensionList.getObject();

         } catch (Exception e) {

             return IOUtil.checkException(e);

         }

     }

     public RequestDispatcher getNamedDispatcher(String name) {

         return webXmlServlets.get(name);

     }

     public FilterMapping[] getFilterMappings() {

         return webXml.getFilterMappings();

     }

     public FileObject getRoot() {

         return root;

     }

     public FileObject getWWW() {

         return www;

     }

     public FileObject getFile(String path) throws IOException {

         return getWWW().resolveFile(path);

     }

     public void destroy() {

     }

     public String getInitParameter(String name) {

         return webXml.getParameters().get(name);

     }

     public Enumeration<String> getInitParameterNames() {

         return new IteratorEnumeration(webXml.getParameters().keySet().iterator());

     }

     public String getMimeType(String extension) {

         return webXml.getMimeType(extension);

     }

     public String findExtensionByMimeType(String mimeType) throws IOException {

         return webXml.getPrimaryExtension(mimeType);

     }

     public Collection<String> findMimeTypes(String attrName, Object value) throws IOException {

         ArrayList<String> mimeTypes = new ArrayList<String>();

         for (FileObject mimeCategory: getWWW().resolveFile("/WEB-INF/DefaultMimeAttributes").getChildren()) {

             for (FileObject mimeFile: mimeCategory.getChildren()) {

                 if (value.equals(findMimeAttributeInternal(mimeFile, attrName))) {

                     mimeTypes.add(mimeCategory.getName().getBaseName() + '/' + mimeFile.getName().getBaseName());

                 }

             }

         }

         return mimeTypes;

     }

     public Collection<String> findExtensionsForType(String type) throws IOException {

         return findExtensions("type", type);

     }

     public Collection<String> findExtensions(String attrName, Object value) throws IOException {

         ArrayList<String> extensions = new ArrayList<String>();

         Iterator<String> it = findMimeTypes(attrName, value).iterator();

         while (it.hasNext()) {

             String mimeType = it.next();

             String[] mimeExtensions = webXml.getExtensions(mimeType);

             if (mimeExtensions != null) {

                 for (String ext: mimeExtensions) {

                     extensions.add(ext);

                 }

             }

         }

         return extensions;

     }

     protected Object findMimeAttributeInternal(FileObject defaultsFile, String attrName) throws IOException {

         if (defaultsFile.exists()) {

             FileContent content = defaultsFile.getContent();

             if (content.attributeExists(attrName)) return content.getAttribute(attrName);

         }

         defaultsFile = defaultsFile.getParent();

         if (defaultsFile.exists()) {

             FileContent content = defaultsFile.getContent();

             if (content.attributeExists(attrName)) return content.getAttribute(attrName);

         }

         return null;

     }

     public Object findMimeAttribute(String mimeType, String attrName) throws IOException {

         return findMimeAttributeInternal(getWWW().resolveFile("/WEB-INF/DefaultMimeAttributes/" + mimeType), attrName);

     }

     public void log(String msg) {

         logger.info("WS: " + msg);

     }

     public void log(String msg, Throwable t) {

         logger.log(Level.INFO, msg, t);

     }

     public boolean isFilter(FileObject file) throws IOException {

         return file.exists() ? file.getContent().attributeExists("is-filter") : false;

     }

     public FileInfo getFileInfo(FileObject file) throws IOException {

         try {

             return fileInfoCache.get(file);

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

             throw (InternalError) new InternalError(e.getMessage()).initCause(e);

         }

     }

     protected static final Freezer<FileObject, String> FileFreezer = new Freezer<FileObject, String>() {

         public String freeze(FileObject file) {

             return file.getName().getPath();

         }

     };

     public PathContext resolve(String path) throws IOException {

         return resolve(path, true);

     }

     public PathContext resolve(String path, boolean lookForFilter) throws IOException {

         ConcurrentCache<String, PathParsingTTLObject> cache = lookForFilter ? lookForFilterCache : fullPathCache;

         try {

             return cache.get(path).getObject();

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

             throw (InternalError) new InternalError(e.getMessage()).initCause(e);

         }

     }

     protected final class ConfigTTLObject extends TTLObject<FileObject> {

         protected final FileObject config;

         protected ConfigTTLObject(FileObject config) {

             this.config = config;

         }

         protected FileObject load(FileObject old) throws IOException {

             config.refresh();

             return config;

         }

     }

     protected final class PathParsingTTLObject extends TTLObject<PathContext> {

         protected final boolean lookForFilter;

         protected final String path;

         protected PathParsingTTLObject(String path, boolean lookForFilter) {

             this.path = path;

             this.lookForFilter = lookForFilter;

         }

         protected PathContext load(PathContext old) throws IOException {

             return _parse(getWWW(), getWWW(), path, lookForFilter);

         }

     }

     public PathContext resolve(PathContext context, PathContext relative, String path, boolean lookForFilter) throws IOException {

         if (path.startsWith("/")) return resolve(path, lookForFilter);

         return _parse(context.getInfo().getServletFile(), relative.getInfo().getServletFile(), path, lookForFilter);

     }

     public PathContext parse(FileObject start, FileObject relative, String path, boolean lookForFilter) throws IOException {

         return _parse(start, relative, path, lookForFilter);

     }

     private PathContext _parse(FileObject start, FileObject relative, String path, boolean lookForFilter) throws IOException {

         FileObject ptr;

         if (start.getType().hasChildren()) {

             ptr = start;

         } else {

             ptr = start.getParent();

         }

         //new Exception("parse(" + start + ", " + relative + ", " + path + ")").printStackTrace();

         //System.err.println("parse(" + start + ", " + relative + ", " + path + "), ptr=" + ptr);

         char[] pathChars = path.toCharArray();

         int mode = 0;

         int nameStart = -1;

         int i;

 OUTER:

         for (i = 0; i < pathChars.length; i++) {

             char c = pathChars[i];

             //System.err.println("mode=" + mode + ", i=" + i + ", c='" + c + "', ptr=" + ptr);

             switch (mode) {

                 case 0:

                     switch (c) {

                         case '/':       // absolute path

                             ptr = ptr.getFileSystem().getRoot();

                             mode = 10;

                             break;

                         case '.':       // possible leading './' or '../'

                             mode = 5;

                             break;

                         default:

                             nameStart = i;

                             mode = 40;

                     }

                     break;

                 case 5:

                     switch (c) {

                         case '/':       // found leading './'

                             if (relative.getType().hasChildren()) {

                                 ptr = relative;

                             } else {

                                 ptr = relative.getParent();

                             }

                             mode = 10;

                             break;

                         case '.':       // possible '../'

                             mode = 30;

                             break;

                         default:

                             nameStart = i - 1;

                             mode = 40;

                     }

                     break;

                 case 10:

                     switch (c) {

                         case '/':       // '/', ignore

                             break;

                         case '.':       // possible './' or '../'

                             mode = 20;

                             break;

                         default:

                             nameStart = i;

                             mode = 40;

                     }

                     break;

                 case 20:

                     switch (c) {

                         case '/':       // './', ignore

                             mode = 10;

                             break;

                         case '.':       // possible '../'

                             mode = 30;

                             break;

                         default:

                             nameStart = i - 1;

                             mode = 40;

                     }

                     break;

                 case 30:

                     switch (c) {

                         case '/':       // found '../'

                             ptr = ptr.getParent();

                             mode = 10;

                             break;

                         default:

                             nameStart = i - 2;

                             mode = 40;

                     }

                     break;

                 case 40:

                     switch (c) {

                         case '/':

                             mode = 10;

                             //System.err.println("path[" + path + "], nameStart=" + nameStart + ", i=" + i);

                             String name = path.substring(nameStart, i);

                             //System.err.println("name[" + name + "]");

                             ptr = ptr.resolveFile(name);

                             if (!lookForFilter) break;

                             VFSUtil.refresh(ptr);

                             if (isFilter(ptr)) {

                                 // A filter on a file or directory

                                 i++;

                                 break OUTER;

                             }

                             String[] extensions = getExtensionList();

                             if (extensions == null || extensions.length == 0) {

                                 break;

                             }

                             FileObject base;

                             if (ptr.getType().hasChildren()) {

                                 name = "index";

                                 base = ptr;

                             } else {

                                 base = ptr.getParent();

                                 VFSUtil.refresh(base);

                             }

                             if (!base.exists()) break;

                             FileObject[] children = base.getChildren();

                             if (children == null) break;

                             for (String extension: extensions) {

                                 String toMatch = name + extension;

                                 for (FileObject child: children) {

                                     if (child.getName().getBaseName().equals(toMatch)) {

                                         VFSUtil.refresh(child);

                                         if (!child.getType().hasChildren()) {

                                             if (isFilter(child)) {

                                                 ptr = child;

                                                 i++;

                                                 break OUTER;

                                             }

                                         }

                                     }

                                 }

                             }

                     }

                     break;

             }

         }

         PathInfo pathInfo = new GivenPathInfo(path.substring(i == pathChars.length ? i : i - 1));

         switch (mode) {

             case 10:

                 if (isFilter(ptr) && pathInfo.getPathInfo().length() == 0) pathInfo = new DefaultPathInfo(ptr);

                 break;

             case 0:

             case 20:

                 break;

             case 30:

                 ptr = ptr.getParent();

                 break;

             case 40:

                 String name = path.substring(nameStart);

                 ptr = ptr.resolveFile(name);

                 if (isFilter(ptr) && pathInfo.getPathInfo().length() == 0) pathInfo = new DefaultPathInfo(ptr);

                 break;

         }

         //System.err.println("ptr=" + ptr + ", pathInfo=\"" + path.substring(i) + "\"");

         return new PathContext(getFileInfo(ptr), pathInfo);

     }

     protected class LogWriterFactory extends GenericRollingWriterFactory {

         private final FileObject logDir;

         private final String pattern;

         public LogWriterFactory(String pattern) throws IOException {

             this.logDir = getRoot().resolveFile("/Var/Log");

             this.pattern = pattern;

         }

         protected RollingWriter newRollingWriter(String name) {

             if (!name.startsWith("org.webslinger.")) return null;

             name = name.substring(15);

             return new CommonsVfsRollingWriter(logDir, name.replaceAll("\\.", "/") + ".log", pattern);

         }

     }

     protected class ExtensionListTTLObject extends TTLObject<String[]> {

         protected String[] load(String[] old) throws IOException {

             return getConfigStringSplit("extension-list");

         }

     }

 }