package org.webslinger;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.PrintWriter;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.net.MalformedURLException;

 import java.net.SocketException;

 import java.net.URL;

 import java.net.HttpURLConnection;

 import java.security.Principal;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Enumeration;

 import java.util.EnumMap;

 import java.util.EventListener;

 import java.util.EventObject;

 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.concurrent.Callable;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.concurrent.ExecutionException;

 import java.util.concurrent.Future;

 import java.util.concurrent.atomic.AtomicInteger;

 import javax.imageio.spi.ServiceRegistry;

 import javax.servlet.Filter;

 import javax.servlet.FilterChain;

 import javax.servlet.FilterConfig;

 import javax.servlet.RequestDispatcher;

 import javax.servlet.Servlet;

 import javax.servlet.ServletConfig;

 import javax.servlet.ServletContext;

 import javax.servlet.ServletContextEvent;

 import javax.servlet.ServletContextListener;

 import javax.servlet.ServletException;

 import javax.servlet.ServletOutputStream;

 import javax.servlet.ServletRequest;

 import javax.servlet.ServletRequestEvent;

 import javax.servlet.ServletRequestListener;

 import javax.servlet.ServletRequestWrapper;

 import javax.servlet.ServletResponse;

 import javax.servlet.ServletResponseWrapper;

 import javax.servlet.http.Cookie;

 import javax.servlet.http.HttpServletRequest;

 import javax.servlet.http.HttpServletResponse;

 import javax.servlet.http.HttpSession;

 import org.apache.bsf.BSFException;

 import org.apache.commons.vfs.FileContent;

 import org.apache.commons.vfs.FileName;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileSystem;

 import org.apache.commons.vfs.FileSystemException;

 import org.apache.commons.vfs.FileType;

 import org.apache.commons.vfs.provider.DelegateFileObject;

 import org.apache.commons.vfs.provider.local.LocalFile;

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

 import org.webslinger.commons.fileupload.AbstractCommonsVfsFileItem;

 import org.webslinger.commons.fileupload.CommonsVfsFileItemFactory;

 import org.webslinger.commons.vfs.VFSUtil;

 import org.webslinger.commons.vfs.flat.FlatFileObject;

 import org.webslinger.commons.vfs.util.FileObjectAttributeTTLObject;

 import org.webslinger.container.CommonsVfsFileInfo;

 import org.webslinger.container.GivenPathInfo;

 import org.webslinger.container.CommonsVfsFileInfo;

 import org.webslinger.container.WebslingerContainer;

 import org.webslinger.container.StringFileInfo;

 import org.webslinger.io.ThreadLocalRollingWriterFactory;

 import static org.webslinger.lang.ClassUtil.NULL;

 import org.webslinger.lang.ConcurrentCache;

 import org.webslinger.lang.ExecutionPool;

 import org.webslinger.lang.ThreadSingletonState;

 import org.webslinger.io.IOUtil;

 import org.webslinger.servlet.EmbeddedHttpSessionManager;

 import org.webslinger.servlet.FakeHttpServletRequest;

 import org.webslinger.servlet.FakeHttpServletResponse;

 import org.webslinger.servlet.FakeResource;

 import org.webslinger.servlet.FakeServletContext;

 import org.webslinger.servlet.FakeServletRequest;

 import org.webslinger.servlet.FakeServletResponse;

 import org.webslinger.servlet.HttpSessionData;

 import org.webslinger.servlet.HttpSessionStore;

 import org.webslinger.servlet.HttpSessionId;

 import org.webslinger.servlet.HttpSessionIdManager;

 import org.webslinger.servlet.OverrideHttpSessionRequest;

 import org.webslinger.servlet.OverrideHttpSessionResponse;

 import org.webslinger.servlet.WrappedHttpServletRequest;

 import org.webslinger.servlet.WrappedHttpServletResponse;

 import org.webslinger.servlet.webxml.ConfiguredFilter;

 import org.webslinger.servlet.webxml.ConfiguredServlet;

 import org.webslinger.servlet.webxml.FilterMapping;

 import org.webslinger.util.GeneratedResult;

 import org.webslinger.util.TTLCachedObject;

 import org.webslinger.util.TTLObject;

 import org.webslinger.vfs.VFSDelegate;

 import org.webslinger.vfs.TypeVFSDelegate;

 import org.webslinger.vfs.GeneratedStringVFSDelegate;

 import org.xml.sax.SAXException;

 public class WebslingerServletContext implements FakeServletContext {

     static {

         TTLObject.setDefaultTTLForClass(InitTTLCachedObject.class, 1000);

         TTLObject.setDefaultTTLForClass(FileObjectFilters.class, 60000);

         TTLObject.setDefaultTTLForClass(FileObjectAttributeSplitTTLObject.class, 60000);

         TTLObject.setDefaultTTLForClass(TriggerListCache.class, 1000);

         TTLObject.setDefaultTTLForClass(PathContextFilters.class, 60000);

         TTLObject.setDefaultTTLForClass(RequestEventsRequestListener.class, 60000);

     }

     public static final String WEBSLINGER_SESSION_COOKIE_NAME = "WEBSLINGERSESSIONID";

     public static final String WEBSLINGER_SESSION_PARAMETER_NAME = "WEBSLINGERSESSIONID";

     public static final String DEFAULT_TYPE = "binary";

     public static final String SESSION_KEY = WebslingerServletContext.class.getName() + ":sessions";

     protected final String id;

     protected final WebslingerContainer container;

     protected final HashMap<String, Object> attributes = new HashMap<String, Object>();

     protected final ConcurrentHashMap<String, TypeHandler> typeHandlers = new ConcurrentHashMap<String, TypeHandler>();

     protected final Map<DispatcherType, ChainCache> chains = new EnumMap<DispatcherType, ChainCache>(DispatcherType.class);

     protected final ConcurrentCache<PathContext, WebslingerFilter> filters = new ConcurrentCache<PathContext, WebslingerFilter>(WebslingerServletContext.class, "filters", null, ConcurrentCache.SOFT) {

         protected WebslingerFilter createValue(PathContext pc) {

             return createWebslingerFilter(pc);

         }

     };

     protected final ConcurrentHashMap<String, TTLObject<Object>> initMap = new ConcurrentHashMap<String, TTLObject<Object>>();

     protected final ServletRequestListener requestEventsListener;

     protected final EmbeddedHttpSessionManager sessionManager;

     protected final ConcurrentCache<FileName, EventListenerList> servletListenerCache = new ConcurrentCache<FileName, EventListenerList>(WebslingerServletContext.class, "servletListenerCache", null, ConcurrentCache.SOFT) {

         private final ServletRequestListenerFactory factory = new ServletRequestListenerFactory();

         protected EventListenerList createValue(FileName name) throws Exception {

             return new EventListenerList(factory, getWWW().getFileSystem().resolveFile(name), "servlet-request-listeners");

         }

     };

     protected static final ThreadLocal<WebslingerInvoker> invokerLocal = new ThreadLocal<WebslingerInvoker>();

     protected static final ThreadLocal<WebslingerServletContext> contextLocal = new ThreadLocal<WebslingerServletContext>();

     protected final TypeVFSDelegate vfsDelegate;

     protected final CommonsVfsFileItemFactory fileItemFactory;

     protected final ThreadSingletonState threadStateInitializer = new ThreadSingletonState() {

         protected Object data;

         public void start() {

             data = getContainer().start();

             contextLocal.set(WebslingerServletContext.this);

         }

         public void finish() {

             getContainer().finish(data);

             invokerLocal.set(null);

             contextLocal.set(null);

         }

     };

     public static WebslingerServletContext getCurrentWebslingerServletContext() {

         return contextLocal.get();

     }

     public WebslingerServletContext(String id, WebslingerContainer container) throws WebslingerException {

         this.id = id;

         sessionManager = new EmbeddedHttpSessionManager(id);

         chains.put(DispatcherType.REQUEST, new ChainCache("filters", DispatcherType.REQUEST));

         chains.put(DispatcherType.FORWARD, new ChainCache("forward-filters", DispatcherType.FORWARD));

         chains.put(DispatcherType.INCLUDE, new ChainCache("include-filters", DispatcherType.INCLUDE));

         this.container = container;

         try {

             requestEventsListener = new RequestEventsRequestListener();

             fileItemFactory = new CommonsVfsFileItemFactory(getContainer().getRoot().resolveFile("/Var/Upload"));

         } catch (IOException e) {

             throw new WebslingerException("creating classloader", e);

         }

         TypeVFSDelegate.Resolver typeVFSDelegateResolver = new TypeVFSDelegate.Resolver() {

             public Object resolve(String name) throws IOException {

                 return WebslingerServletContext.this.resolve(name);

             }

         };

         try {

             vfsDelegate = new TypeVFSDelegate(typeVFSDelegateResolver);

             CommonsVfsFileInfo.CommonsVfsFileInfoVFSDelegate<Object> commonsVfsDelegate = new CommonsVfsFileInfo.CommonsVfsFileInfoVFSDelegate<Object>(vfsDelegate);

             vfsDelegate.addVFSDelegate(CommonsVfsFileInfo.class, commonsVfsDelegate);

             vfsDelegate.addVFSDelegate(StringFileInfo.class, new StringFileInfo.StringFileInfoVFSDelegate<Object>(vfsDelegate));

             vfsDelegate.addVFSDelegate(PathContext.class, new PathContext.PathContextVFSDelegate<Object>(vfsDelegate));

             vfsDelegate.addVFSDelegate(Webslinger.class, new Webslinger.WebslingerVFSDelegate<Object>(vfsDelegate));

             vfsDelegate.addVFSDelegate(GeneratedStringVFSDelegate.GeneratedString.class, new GeneratedStringVFSDelegate<Object>(vfsDelegate));

         } catch (Exception e) {

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

         }

     }

     public void service(String path) throws IOException, ServletException {

         service(getRequestDispatcher(path));

     }

     public void service(String path, Map<String, Object> context) throws IOException, ServletException {

         service(getRequestDispatcher(path, context));

     }

     protected void service(WebslingerRequestDispatcher dispatcher) throws IOException, ServletException {

         HttpServletResponse response = new FakeHttpServletResponse(new FakeServletResponse(new StringWriter()));

         PathContext pc = dispatcher.getPathContext();

         HttpServletRequest request = new FakeHttpServletRequest(this, new FakeServletRequest(this, pc), response, pc);

         service(request, response, dispatcher);

     }

     private static final AtomicInteger vmKey = new AtomicInteger();

     private static final ConcurrentHashMap<String, VMData> vmData = new ConcurrentHashMap<String, VMData>();

     private static final class VMData {

         protected final Map<String, Object> context;

         protected Object result;

         protected VMData(Map<String, Object> context) {

             this.context = context;

         }

     }

     public static Object invokeInVM(String hostName, int port, String path, Map<String, Object> context) throws IOException {

         VMData data = new VMData(context);

         String key = Integer.toString(vmKey.incrementAndGet());

         HttpURLConnection connection = (HttpURLConnection) new URL("http://127.0.0.1:" + port + "/" + path).openConnection();

         connection.setRequestProperty("VM-Key", key);

         connection.setRequestMethod("GET");

         connection.setRequestProperty("Host", hostName);

         connection.setRequestProperty("Content-Type", "rpc/in-vm");

         try {

             vmData.put(key, data);

             connection.connect();

             IOUtil.dump(connection.getInputStream(), true);

             return data.result;

         } finally {

             vmData.remove(key);

         }

     }

     public void service(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {

         String vmKey = request.getHeader("VM-Key");

         boolean normalRequest =

             !"rpc/in-vm".equals(request.getContentType()) ||

             !"127.0.0.1".equals(request.getLocalAddr()) ||

             vmKey == null ||

             !vmData.containsKey(vmKey);

         if (normalRequest) {

             HttpServletRequest[] requestHolder = new HttpServletRequest[] {request};

             HttpServletResponse[] responseHolder = new HttpServletResponse[] {response};

             wrapSession(requestHolder, responseHolder);

             service(requestHolder[0], responseHolder[0], getRequestDispatcher(requestHolder[0].getPathInfo()));

         } else {

             VMData data = vmData.get(vmKey);

             PathContext pc = resolve(request.getPathInfo());

             StringWriter sw = new StringWriter();

             HttpServletRequest fakeRequest = alterPaths(pc, request);

             HttpServletResponse fakeResponse = alterPaths(pc, request, response);

             data.result = run(pc, fakeRequest, fakeResponse, data.context);

         }

     }

     protected void wrapSession(HttpServletRequest[] request, HttpServletResponse[] response) throws ServletException, IOException {

         String idExtractor = (String) getConfigItem("org.webslinger.servlet.HttpSessionIdManager");

         final HttpSessionIdManager sessionIdManager;

         if (idExtractor != null) {

             final PathContext pc = resolve(idExtractor);

             sessionIdManager = new HttpSessionIdManager() {

                 public HttpSessionId extractHttpSessionId(HttpServletRequest[] request, HttpServletResponse[] response) {

                     Map<String, Object> context = new HashMap<String, Object>();

                     context.put("sessionRequest", request[0]);

                     context.put("sessionResponse", response[0]);

                     Map<String, Object> result = (Map<String, Object>) runDirectNoThrow("HttpSessionIdManager.extractHttpSessionId", pc, context, "extractHttpSessionId", null);

                     if (result == null) return null;

                     if (result.containsKey("sessionRequest")) request[0] = (HttpServletRequest) result.get("sessionRequest");

                     if (result.containsKey("sessionResponse")) response[0] = (HttpServletResponse) result.get("sessionResponse");

                     return (HttpSessionId) result.get("sessionId");

                 }

                 public HttpSessionId createHttpSessionId() {

                     Map<String, Object> context = new HashMap<String, Object>();

                     return (HttpSessionId) runDirectNoThrow("HttpSessionIdManager.createHttpSessionId", pc, context, "createHttpSessionId", null);

                 }

                 public void setHttpSessionId(HttpServletRequest request, HttpServletResponse response, HttpSessionId id) {

                     Map<String, Object> context = new HashMap<String, Object>();

                     context.put("sessionRequest", request);

                     context.put("sessionResponse", response);

                     context.put("sessionId", id);

                     runDirectNoThrow("HttpSessionIdManager.setHttpSessionId", pc, context, "setHttpSessionId", null);

                 }

                 public String encodeURL(String path, HttpSessionId id) {

                     Map<String, Object> context = new HashMap<String, Object>();

                     context.put("sessionPath", path);

                     context.put("sessionId", id);

                     return (String) runDirectNoThrow("HttpSessionIdManager.encodeURL", pc, context, "encodeURL", null);

                 }

                 public String encodeRedirectURL(String path, HttpSessionId id) {

                     Map<String, Object> context = new HashMap<String, Object>();

                     context.put("sessionPath", path);

                     context.put("sessionId", id);

                     return (String) runDirectNoThrow("HttpSessionIdManager.encodeURL", pc, context, "encodeRedirectURL", null);

                 }

             };

         } else {

             sessionIdManager = sessionManager;

         }

         final HttpSessionStore httpSessionStore;

         String sessionStore = (String) getConfigItem("org.webslinger.servlet.HttpSessionStore");

         if (sessionStore != null) {

             final PathContext pc = resolve(sessionStore);

             httpSessionStore = new HttpSessionStore() {

                 public HttpSessionData getSessionData(HttpServletRequest request, HttpSessionId id, boolean create) {

                     Map<String, Object> context = new HashMap<String, Object>();

                     context.put("sessionRequest", request);

                     context.put("sessionId", id);

                     context.put("create", create);

                     return (HttpSessionData) runDirectNoThrow("HttpSessionStore.getSessionData", pc, context, "getSessionData", null);

                 }

             };

         } else {

             httpSessionStore = sessionManager;

         }

         HttpSessionId sessionId = sessionIdManager.extractHttpSessionId(request, response);

         OverrideHttpSessionRequest newRequest = new OverrideHttpSessionRequest(request[0], this, sessionIdManager, httpSessionStore, sessionId);

         OverrideHttpSessionResponse newResponse = new OverrideHttpSessionResponse(response[0], newRequest);

         request[0] = newRequest;

         response[0] = newResponse;

     }

     protected void service(HttpServletRequest request, HttpServletResponse response, final WebslingerRequestDispatcher dispatcher) throws IOException, ServletException {

         start();

         try {

             //final HttpServletRequest wsRequest = new WebslingerHttpServletRequest(context, pathContext, request);

             WebslingerFilterChain lastChain = new WebslingerFilterChain() {

                 public void doComet(CometEventType eventType, ServletRequest request, ServletResponse response) throws IOException, ServletException {

                     dispatcher.comet(eventType, request, response);

                 }

                 public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {

                     dispatcher.forward(request, response);

                 }

                 public PathContext getPathContext() {

                     return dispatcher.getPathContext();

                 }

                 public Map<String, Object> getContext() {

                     return dispatcher.getContext();

                 }

             };

             try {

                 getFilterChain(dispatcher.getPathContext(), lastChain).doFilter(request, response);

             } catch (Throwable t) {

                 Throwable cause = t.getCause();

                 while (cause != null) {

                     t = cause;

                     cause = t.getCause();

                 }

                 throw t;

             }

             //RequestDispatcher dispatcher = context.getRequestDispatcher(pathContext);

             //dispatcher.forward(wsRequest, response);

             response.flushBuffer();

         } catch (SocketException e) {

         } catch (Error e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (IOException e) {

             throw e;

         } catch (ServletException e) {

             throw e;

         } catch (Throwable e) {

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

         } finally {

             ExecutionPool.runAtExit();

         }

     }

     public void initializeRequest(HttpServletRequest request) {

         getContainer().initializeRequest(this, request);

     }

     public WebslingerClassLoader getClassLoader() {

         return getContainer().getClassLoader();

     }

     public void start() {

         ExecutionPool.addAtExit(threadStateInitializer);

     }

     public VFSDelegate<Object, Object, ?> getVFSDelegate() {

         return vfsDelegate;

     }

     public WebslingerContainer getContainer() {

         return container;

     }

     public WebslingerInvoker getInvoker() throws IOException {

         WebslingerInvoker invoker = invokerLocal.get();

         if (invoker == null) {

             invoker = new WebslingerInvoker(this);

             invokerLocal.set(invoker);

         }

         return invoker;

     }

     public void runStartup() throws IOException, ServletException {

         Iterator<WebslingerStartup> it1 = ServiceRegistry.lookupProviders(WebslingerStartup.class, getClassLoader());

         List<Future> futures = new ArrayList<Future>();

         while (it1.hasNext()) {

             futures.addAll(it1.next().start(this));

         }

         Iterator<Future> it2 = futures.iterator();

         while (it2.hasNext()) {

             try {

                 try {

                     it2.next().get();

                 } catch (ExecutionException e) {

                     throw e.getCause();

                 }

             } catch (RuntimeException e) {

                 throw e;

             } catch (IOException e) {

                 throw e;

             } catch (ServletException e) {

                 throw e;

             } catch (Throwable e) {

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

             }

         }

     }

     public void init() throws IOException, ServletException {

         try {

             getContainer().init(this);

             start();

             try {

                 runStartup();

             } finally {

                 ExecutionPool.runAtExit();

             }

         } catch (IOException e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (ServletException e) {

             throw e;

         } catch (Exception e) {

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

         }

     }

     public AbstractCommonsVfsFileItem createFileItem(String fieldName, String contentType, boolean isFormField, String fileName) {

         return (AbstractCommonsVfsFileItem) fileItemFactory.createItem(fieldName, contentType, isFormField, fileName);

     }

     public FileObject getWWW() {

         return getContainer().getWWW();

     }

     public FileObject getFile(String path) throws IOException {

         return getWWW().resolveFile(path);

     }

     public void destroy() {

         getContainer().destroy();

     }

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

         return getContainer().getConfigStringSplit(name);

     }

     public String getConfigString(String name) throws IOException {

         return getContainer().getConfigString(name);

     }

     public Object getConfigItem(String name) throws IOException {

         return getContainer().getConfigItem(name);

     }

     protected static final class WebslingerFilterChainCascade implements WebslingerFilterChain {

         private final WebslingerFilter filter;

         private final WebslingerFilterChain next;

         protected WebslingerFilterChainCascade(WebslingerFilter filter, WebslingerFilterChain next) {

             this.filter = filter;

             this.next = next;

         }

         public void doComet(CometEventType eventType, ServletRequest request, ServletResponse response) throws IOException, ServletException {

             filter.doComet(eventType, request, response, next);

         }

         public final void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {

             filter.doFilter(request, response, next);

         }

         public PathContext getPathContext() {

             return next.getPathContext();

         }

         public Map<String, Object> getContext() {

             return next.getContext();

         }

         public String toString() {

             return "WebslingerFilterChain(" + filter + ", " + next + ")";

         }

     }

     public static abstract class FileObjectAttributeSplitTTLObject<T> extends FileObjectAttributeTTLObject<T, String> {

         public FileObjectAttributeSplitTTLObject(FileObject file, String attributeName, Class<T> resultType) {

             super(file, attributeName, resultType, String.class);

         }

         protected String[] splitAttribute(String attributeValue) throws IOException {

             if (!file.exists()) return null;

             VFSUtil.refresh(file);

             return attributeValue.split("[, \r\n]+");

         }

     }

     protected WebslingerFilter[] getFilterList(FileObject file, String[] filterNames, DispatcherType dispatcherType) throws IOException {

         ArrayList<WebslingerFilter> filters = new ArrayList<WebslingerFilter>();

         String path = file.getName().getPath();

         String ext = file.getName().getExtension();

         for (FilterMapping mapping: getContainer().getFilterMappings()) {

             String urlPattern = mapping.getUrlPattern();

             WebslingerFilter filter = getContainer().getServletFilter(mapping.getFilterName());

             System.err.println("name[" + mapping.getFilterName() + "] filter=" + filter + ", pattern[" + urlPattern + "], path[" + path + "]");

             if (filter == null) continue;

             if (!mapping.getDispatcherType().contains(dispatcherType)) continue;

             if (urlPattern != null) {

                 if (urlPattern.equals(path)) {

                 } else if (urlPattern.equals("/*")) {

                 } else if (urlPattern.endsWith("/*")) {

                     int patternLength = urlPattern.length() - 2;

                     if (!urlPattern.regionMatches(0, path, 0, patternLength)) continue;

                     if (path.length() == patternLength) {

                     } else if (path.charAt(patternLength) == '/') {

                     } else {

                         continue;

                     }

                 } else if (urlPattern.startsWith("*.")) {

                     if (urlPattern.length() <= 2) continue;

                     if (!urlPattern.regionMatches(2, ext, 0, urlPattern.length() - 2)) continue;

                 }

                 System.err.println("adding filter: " + filter);

                 filters.add(filter);

             }

         }

         try {

             for (String filterName: filterNames) {

                 filters.add(getFilter(parse(file, filterName)));

             }

         } catch (ServletException e) {

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

         }

         //System.err.println(file + " -> filters=" + filters);

         return filters.toArray(new WebslingerFilter[filters.size()]);

     }

     protected class FileObjectFilters extends FileObjectAttributeSplitTTLObject<WebslingerFilter[]> {

         private final DispatcherType dispatcherType;

         protected FileObjectFilters(FileObject file, String attributeName, DispatcherType dispatcherType) {

             super(file, attributeName, WebslingerFilter[].class);

             this.dispatcherType = dispatcherType;

         }

         protected WebslingerFilter[] parseAttribute(String attributeValue) throws IOException {

             String[] filterNames = splitAttribute(attributeValue);

             if (filterNames == null) return null;

             return getFilterList(file, filterNames, dispatcherType);

         }

         public String toString() {

             return "PathContextFilters(" + file + ", " + attributeName + ", " + dispatcherType + ")";

         }

     }

     protected class PathContextFilters extends TTLObject<WebslingerFilter[]> {

         private final PathContext pc;

         private final String attributeName;

         private final DispatcherType dispatcherType;

         protected PathContextFilters(PathContext pc, String attributeName, DispatcherType dispatcherType) {

             this.pc = pc;

             this.attributeName = attributeName;

             this.dispatcherType = dispatcherType;

         }

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

             String[] filterNames = pc.getSplitAttribute(attributeName);

             if (filterNames == null) return null;

             return getFilterList(pc.getFile(), filterNames, dispatcherType);

         }

         public String toString() {

             return "PathContextFilters(" + pc + ", " + attributeName + ", " + dispatcherType + ")";

         }

     }

     protected WebslingerFilter createWebslingerFilter(final PathContext pc) {

             WebslingerFilter filter = new WebslingerFilter() {

                 protected FilterConfig config;

                 protected Object initObject;

                 public void init(FilterConfig config) throws ServletException {

                     this.config = config;

                     try {

                         initObject = runDirect(pc, null, "filter-init", config);

                     } catch (IOException e) {

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

                     }

                 }

                 public void destroy() {

                     HashMap<String, Object> context = new HashMap<String, Object>();

                     context.put("FilterInit", initObject);

                     runDirectNoThrow("", pc, context, "filter-destroy", null);

                 }

                 public void doComet(CometEventType eventType, ServletRequest request, ServletResponse response, WebslingerFilterChain chain) throws IOException, ServletException {

                     //System.err.println("Filter{" + pc + "}(" + request + ", " + response + ", " + chain + ")");

                     Map<String, Object> context = new HashMap<String, Object>();

                     context.put("FilterChain", chain);

                     context.put("FilterInit", initObject);

                     WebslingerServletContext.this.run(pc, (HttpServletRequest) request, (HttpServletResponse) response, context, "comet", eventType);

                 }

                 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

                     //System.err.println("Filter{" + pc + "}(" + request + ", " + response + ", " + chain + ")");

                     Map<String, Object> context = new HashMap<String, Object>();

                     context.put("FilterChain", chain);

                     context.put("FilterInit", initObject);

                     WebslingerServletContext.this.run(pc, (HttpServletRequest) request, (HttpServletResponse) response, context, "filter", null);

                 }

                 public String toString() {

                     return "Filter{" + pc + "}";

                 }

             };

             FilterConfig filterConfig = new FilterConfig() {

                 public String getFilterName() {

                     return pc.getServletPath();

                 }

                 public String getInitParameter(String name) {

                     throw new UnsupportedOperationException();

                 }

                 public Enumeration getInitParameterNames() {

                     throw new UnsupportedOperationException();

                 }

                 public ServletContext getServletContext() {

                     return WebslingerServletContext.this;

                 }

             };

             try {

                 filter.init(filterConfig);

             } catch (ServletException e) {

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

             }

             return filter;

     }

     // FIXME: call destroy/init when file is reloaded

     protected WebslingerFilter getFilter(final PathContext pc) throws ServletException {

         try {

             return filters.get(pc);

         } catch (RuntimeException e) {

             throw e;

         } catch (ServletException e) {

             throw e;

         } catch (Exception e) {

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

         }

     }

     protected class ChainCache extends ConcurrentCache<Object, TTLObject<WebslingerFilter[]>> {

         private final String attributeName;

         private final DispatcherType dispatcherType;

         protected ChainCache(String attributeName, DispatcherType dispatcherType) {

             super(WebslingerServletContext.class, "ChainCache", dispatcherType.toString(), ConcurrentCache.SOFT);

             this.attributeName = attributeName;

             this.dispatcherType = dispatcherType;

         }

         public TTLObject<WebslingerFilter[]> get(Object key) throws IOException {

             try {

                 return super.get(key);

             } catch (IOException e) {

                 throw e;

             } catch (RuntimeException e) {

                 throw e;

             } catch (Exception e) {

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

             }

         }

         protected TTLObject<WebslingerFilter[]> createValue(Object value) throws Exception {

             if (value instanceof PathContext) return new PathContextFilters((PathContext) value, attributeName, dispatcherType);

             if (value instanceof FileName) return new FileObjectFilters(getWWW().getFileSystem().resolveFile((FileName) value), attributeName, dispatcherType);

             throw new InternalError("Can't handle(" + value + ")");

         }

     }

     public WebslingerFilterChain getFilterChain(PathContext pc, WebslingerFilterChain chain) throws IOException {

         return new RequestFilterChain(pc, getFilterChain(pc, chain, DispatcherType.REQUEST));

     }

     WebslingerFilterChain getFilterChain(PathContext pc, WebslingerFilterChain chain, DispatcherType dispatcherType) throws IOException {

         //System.err.println("pc=" + pc);

         //System.err.println("file=" + file);

         ChainCache dispatcherChains = chains.get(dispatcherType);

         PathContextFilters pcf = (PathContextFilters) dispatcherChains.get(pc);

         WebslingerFilter[] filters = pcf.getObject();

         if (filters != null) {

             for (WebslingerFilter filter: filters) {

                 chain = new WebslingerFilterChainCascade(filter, chain);

             }

         }

         FileObject file = pc.getFile();

         FileSystem fs = file.getFileSystem();

         FileName name = file.getName().getParent();

         while (name != null) {

             FileObjectFilters fofc = (FileObjectFilters) dispatcherChains.get(name);

             //System.err.println("fofc=" + fofc);

             filters = fofc.getObject();

             //System.err.println("perFileChains=" + perFileChains);

             if (filters != null) {

                 for (WebslingerFilter filter: filters) {

                     chain = new WebslingerFilterChainCascade(filter, chain);

                 }

             }

             name = name.getParent();

         }

         return chain;

     }

     //protected void notifyEventChain(Map listenerCache, EventListenerFactory factory, EventListenerCaller caller, String attributeName, FileObject ptr, EventObject event) throws IOException {

     public class RequestFilterChain implements WebslingerFilterChain {

         private final PathContext pc;

         private final WebslingerFilterChain chain;

         protected RequestFilterChain(PathContext pc, WebslingerFilterChain chain) {

             this.pc = pc;

             this.chain = chain;

         }

         public PathContext getPathContext() {

             return pc;

         }

         public Map<String, Object> getContext() {

             return null;

         }

         public void doComet(CometEventType eventType, ServletRequest request, ServletResponse response) throws IOException, ServletException {

             ServletRequestEvent sre = new ServletRequestEvent(WebslingerServletContext.this, request);

             ThreadLocalRollingWriterFactory.setRollingWriterFactory(container.getLogFactory());

             try {

                 request.setAttribute("RequestPath", pc);

                 requestEventsListener.requestInitialized(sre);

                 notifyEventChain(servletListenerCache, SERVLET_REQUEST_LISTENER_CONTEXT_INITIALIZED, pc.getFile().getName(), sre);

                 chain.doComet(eventType, request, response);

             } catch (RuntimeException e) {

                 throw e;

             } finally {

                 notifyEventChain(servletListenerCache, SERVLET_REQUEST_LISTENER_CONTEXT_DESTROYED, pc.getFile().getName(), sre);

                 requestEventsListener.requestDestroyed(sre);

                 getInvoker().reset();

                 ThreadLocalRollingWriterFactory.setRollingWriterFactory(null);

             }

         }

         public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {

             ServletRequestEvent sre = new ServletRequestEvent(WebslingerServletContext.this, request);

             ThreadLocalRollingWriterFactory.setRollingWriterFactory(container.getLogFactory());

             try {

                 request.setAttribute("RequestPath", pc);

                 requestEventsListener.requestInitialized(sre);

                 notifyEventChain(servletListenerCache, SERVLET_REQUEST_LISTENER_CONTEXT_INITIALIZED, pc.getFile().getName(), sre);

                 chain.doFilter(request, response);

             } catch (RuntimeException e) {

                 throw e;

             } finally {

                 notifyEventChain(servletListenerCache, SERVLET_REQUEST_LISTENER_CONTEXT_DESTROYED, pc.getFile().getName(), sre);

                 requestEventsListener.requestDestroyed(sre);

                 getInvoker().reset();

                 ThreadLocalRollingWriterFactory.setRollingWriterFactory(null);

             }

         }

     }

     protected interface EventListenerCaller {

         void notifyListener(EventListener listener, EventObject event);

     }

     public interface EventListenerFactory {

         EventListener getListener(PathContext pc) throws IOException;

         void destroy(EventListener listener);

     }

     protected class EventListenerList extends FileObjectAttributeSplitTTLObject<EventListener[]> {

         protected final EventListenerFactory factory;

         protected EventListenerList(EventListenerFactory factory, FileObject file, String attributeName) {

             super(file, attributeName, EventListener[].class);

             this.factory = factory;

         }

         protected EventListener[] parseAttribute(String attributeValue) throws IOException {

             String[] listenerNames = splitAttribute(attributeValue);

             if (listenerNames == null) return null;

             EventListener[] listeners = new EventListener[listenerNames.length];

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

                 listeners[i] = factory.getListener(parse(file, listenerNames[i]));

             }

             return listeners;

         }

     }

     protected final EventListenerFactory SERVLET_CONTEXT_LISTENER_FACTORY = new EventListenerFactory() {

         protected final HashMap<String, EventListener> listenerCache = new HashMap<String, EventListener>();

         public EventListener getListener(PathContext pc) throws IOException {

             EventListener listener = listenerCache.get(pc.getFile().getName().getPath());

             if (listener == null) {

                 listener = new WebslingerServletContextListener(pc);

                 listenerCache.put(pc.getFile().getName().getPath(), listener);

             }

             return listener;

         }

         public void destroy(EventListener listener) {

         }

     };

     protected static final EventListenerCaller SERVLET_CONTEXT_LISTENER_CONTEXT_DESTROYED = new EventListenerCaller() {

         public void notifyListener(EventListener listener, EventObject event) {

             ((ServletContextListener) listener).contextDestroyed((ServletContextEvent) event);

         }

     };

     protected static final EventListenerCaller SERVLET_CONTEXT_LISTENER_CONTEXT_INITIALIZED = new EventListenerCaller() {

         public void notifyListener(EventListener listener, EventObject event) {

             ((ServletContextListener) listener).contextInitialized((ServletContextEvent) event);

         }

     };

     protected final class WebslingerServletContextListener implements ServletContextListener {

         private final PathContext pc;

         protected WebslingerServletContextListener(PathContext pc) {

             this.pc = pc;

         }

         public void contextDestroyed(ServletContextEvent event) {

             runEvent("destroyed", event);

         }

         protected final void runEvent(String name, ServletContextEvent event) {

             runDirectNoThrow("ServletContextListener." + name, pc, null, "context-listener-" + name, event);

         }

         public void contextInitialized(ServletContextEvent event) {

             runEvent("initialized", event);

         }

     }

     protected final class ServletRequestListenerFactory implements EventListenerFactory {

         protected final HashMap<String, EventListener> listenerCache = new HashMap<String, EventListener>();

         public EventListener getListener(PathContext pc) throws IOException {

             EventListener listener = listenerCache.get(pc.getFile().getName().getPath());

             if (listener == null) {

                 listener = new WebslingerServletRequestListener(pc);

                 listenerCache.put(pc.getFile().getName().getPath(), listener);

             }

             return listener;

         }

         public void destroy(EventListener listener) {

         }

     }

     protected static final EventListenerCaller SERVLET_REQUEST_LISTENER_CONTEXT_DESTROYED = new EventListenerCaller() {

         public void notifyListener(EventListener listener, EventObject event) {

             ((ServletRequestListener) listener).requestDestroyed((ServletRequestEvent) event);

         }

     };

     protected static final EventListenerCaller SERVLET_REQUEST_LISTENER_CONTEXT_INITIALIZED = new EventListenerCaller() {

         public void notifyListener(EventListener listener, EventObject event) {

             ((ServletRequestListener) listener).requestInitialized((ServletRequestEvent) event);

         }

     };

     protected final class WebslingerServletRequestListener implements ServletRequestListener {

         private final PathContext pc;

         protected WebslingerServletRequestListener(PathContext pc) {

             this.pc = pc;

         }

         public void requestDestroyed(ServletRequestEvent event) {

             runEvent("destroyed", event);

         }

         protected final void runEvent(String name, ServletRequestEvent event) {

             runDirectNoThrow("ServletContextListener." + name, pc, null, "request-listener-" + name, event);

         }

         public void requestInitialized(ServletRequestEvent event) {

             runEvent("initialized", event);

         }

     }

     protected void notifyEventChain(ConcurrentCache<FileName, EventListenerList> listenerCache, EventListenerCaller caller, FileName name, EventObject event) throws IOException {

         FileName parent = name.getParent();

         if (parent != null) notifyEventChain(listenerCache, caller, parent, event);

         EventListenerList listenerList;

         try {

             listenerList = listenerCache.get(name);

         } catch (RuntimeException e) {

             throw e;

         } catch (IOException e) {

             throw e;

         } catch (Exception e) {

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

         }

         EventListener[] listeners = listenerList.getObject();

         if (listeners == null) return;

         for (EventListener listener: listeners) {

             caller.notifyListener(listener, event);

         }

     }

     protected final class RequestEventsRequestListener extends TTLObject<PathContext[]> implements ServletRequestListener {

         private final FileObject initEventsDir;

         protected RequestEventsRequestListener() throws IOException {

             initEventsDir = getFile("/WEB-INF/Events/System/Request");

         }

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

             VFSUtil.refresh(initEventsDir);

             if (!initEventsDir.exists()) return null;

             FileObject[] children = initEventsDir.getChildren();

             ArrayList<PathContext> pcs = new ArrayList<PathContext>(children.length);

             for (FileObject child: children) {

                 if (child.isHidden()) continue;

                 if (child.getName().getBaseName().startsWith(".")) continue;

                 pcs.add(resolve(child.getName().getPath()));

             }

             return pcs.toArray(new PathContext[pcs.size()]);

         }

         public void requestDestroyed(ServletRequestEvent event) {

             runEvent("destroyed", event);

         }

         protected final void runEvent(String name, ServletRequestEvent event) {

             try {

                 PathContext[] pcs = (PathContext[]) getObject();

                 if (pcs == null) return;

                 for (PathContext pc: pcs) {

                     HttpServletResponse response = new FakeHttpServletResponse(new FakeServletResponse(new StringWriter()));

                     runDirectNoThrow("ServletContextListener." + name, pc, null, "request-listener-" + name, event);

                 }

             } catch (IOException e) {

                 log("ServletContextListener." + name, e);

             }

         }

         public void requestInitialized(ServletRequestEvent event) {

             runEvent("initialized", event);

         }

     }

     // /--------------------\

     // | ServletContext api |

     // \--------------------/

     public ServletContext getContext(String path) {

         return null;

     }

     public int getMajorVersion() {

         return 2;

     }

     public int getMinorVersion() {

         return 4;

     }

     public String getMimeType(String path) {

         try {

             return getFile(path).getContent().getContentInfo().getContentType();

         } catch (Exception e) {

             log("getMimeType(" + path + ")", e);

             return null;

         }

     }

     public Set getResourcePaths(String path) {

         HashSet<String> paths = new HashSet<String>();

         try {

             FileObject[] children = getFile(path).getChildren();

             for (FileObject child: children) {

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

                     paths.add(child.getName().getPath() + '/');

                 } else {

                     paths.add(child.getName().getPath());

                 }

             }

         } catch (Exception e) {

             log("getResourcePaths(" + path + ")", e);

         }

         return paths;

     }

     public URL getResource(String url) throws MalformedURLException {

         try {

             FileObject file = getWWW().resolveFile(url);

             while (file != null) {

                 if (file instanceof DelegateFileObject) {

                     file = ((DelegateFileObject) file).getDelegateFile();

                 } else if (file instanceof FlatFileObject) {

                     file = ((FlatFileObject) file).getRealFile();

                 } else {

                     break;

                 }

             }

             if (file == null) return null;

             return file.getURL();

         } catch (FileSystemException e) {

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

         }

     }

     public InputStream getResourceAsStream(String path) {

         try {

             FileObject file = getFile(path);

             if (file.exists()) return file.getContent().getInputStream();

         } catch (Exception e) {

             log("getResourceAsStream(" + path + ")", e);

         }

         return null;

     }

     public WebslingerRequestDispatcher getRequestDispatcher(FakeResource resource) {

         return getRequestDispatcher((PathContext) resource);

     }

     public WebslingerRequestDispatcher getRequestDispatcher(PathContext pc) {

         return getRequestDispatcher(pc, new HashMap<String, Object>());

     }

     public WebslingerRequestDispatcher getRequestDispatcher(PathContext pc, Map<String, Object> context) {

         //System.err.println("getRequestDispatcher(" + pc + ")");

         try {

             return new WebslingerRequestDispatcher(this, pc, context);

         } catch (Exception e) {

             log("getRequestDispatcher(" + pc + ")", e);

         }

         System.err.println("returning null");

         return null;

     }

     public WebslingerRequestDispatcher getRequestDispatcher(String path) {

         return getRequestDispatcher(path, new HashMap<String, Object>());

     }

     public WebslingerRequestDispatcher getRequestDispatcher(String path, Map<String, Object> context) {

         //System.err.println("getRequestDispatcher(" + path + ")");

         try {

             return getRequestDispatcher(resolve(path), context);

         } catch (Exception e) {

             log("getRequestDispatcher(" + path + ")", e);

         }

         System.err.println("returning null");

         return null;

     }

     public WebslingerRequestDispatcher getRequestDispatcher(PathContext pc, String path) {

         return getRequestDispatcher(pc, path, new HashMap<String, Object>());

     }

     public WebslingerRequestDispatcher getRequestDispatcher(PathContext pc, String path, Map<String, Object> context) {

         //System.err.println("getRequestDispatcher(" + pc + ", " + path + ")");

         try {

             return getRequestDispatcher(resolve(pc, path), context);

         } catch (Exception e) {

             log("getRequestDispatcher(" + path + ")", e);

         }

         System.err.println("returning null");

         return null;

     }

     public RequestDispatcher getNamedDispatcher(String name) {

         return getContainer().getNamedDispatcher(name);

     }

     /** @deprecated */

     public Servlet getServlet(String name) throws ServletException {

         // NOTE: always return null

         return null;

     }

     /** @deprecated */

     public Enumeration getServlets() {

         // FIXME: empty enumeration

         return null;

     }

     /** @deprecated */

     public Enumeration getServletNames() {

         // FIXME: empty enumeration

         return null;

     }

     public void log(String msg) {

         getContainer().log(msg);

     }

     /** @deprecated */

     public void log(Exception e, String msg) {

         log(msg, e);

     }

     public void log(String msg, Throwable t) {

         getContainer().log(msg, t);

     }