package org.webslinger;

 import java.io.ByteArrayInputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.ObjectOutputStream;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.util.ArrayList;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.concurrent.Callable;

 import java.util.concurrent.Future;

 import java.util.concurrent.TimeUnit;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import java.util.logging.LogRecord;

 import javax.servlet.Filter;

 import javax.servlet.FilterChain;

 import javax.servlet.FilterConfig;

 import javax.servlet.ServletContext;

 import javax.servlet.ServletContextEvent;

 import javax.servlet.ServletContextListener;

 import javax.servlet.ServletException;

 import javax.servlet.ServletRequest;

 import javax.servlet.ServletRequestEvent;

 import javax.servlet.ServletRequestListener;

 import javax.servlet.ServletResponse;

 import javax.servlet.http.HttpServletRequest;

 import javax.servlet.http.HttpServletResponse;

 import javax.servlet.http.HttpSession;

 import org.apache.bsf.BSFException;

 import org.webslinger.commons.vfs.FileConvertor;

 import org.webslinger.commons.vfs.VFSUtil;

 import org.webslinger.container.WebslingerContainer;

 import org.webslinger.servlet.FakeHttpServletRequest;

 import org.webslinger.servlet.FakeHttpServletResponse;

 import org.webslinger.servlet.FakeServletRequest;

 import org.webslinger.servlet.FakeServletResponse;

 import org.webslinger.io.Charsets;

 import org.webslinger.io.IOUtil;

 import org.webslinger.lang.ExecutionPool;

 import org.webslinger.lang.ThreadSingletonState;

 import org.webslinger.util.TTLObject;

 import org.webslinger.rules.Action;

 import org.webslinger.rules.AbstractListValue;

 import org.webslinger.rules.AbstractSingleValue;

 import org.webslinger.rules.AbstractValue;

 import org.webslinger.rules.CompiledRules;

 import org.webslinger.rules.CSSAction;

 import org.webslinger.rules.CSSRules;

 import org.webslinger.rules.CSSSelector;

 import org.webslinger.rules.Rules;

 import org.webslinger.servlet.webxml.FilterMapping;

 import org.webslinger.vfs.VFSDelegate;

 public class WebslingerInvoker {

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

     private static ThreadLocal<WebslingerInvoker> invokerLocal = new ThreadLocal<WebslingerInvoker>();

     public WebslingerContainer getContainer() {

         return webslingerServletContext.getContainer();

     }

     public WebslingerServletContext getWebslingerServletContext() {

         return webslingerServletContext;

     }

     protected final ArrayList<Webslinger> webslingers = new ArrayList<Webslinger>();

     protected final CompiledRules compiledRules;

     protected final WebslingerServletContext webslingerServletContext;

     protected final VFSDelegate<?, Object, ?> vfsDelegate;

     protected final ThreadSingletonState threadStateInitializer = new ThreadSingletonState() {

         public void start() {

         }

         public void finish() {

             WebslingerInvoker.this.reset();

         }

     };

     protected final ArrayList<Map<String, Object>> jsonHub;

     protected Webslinger current;

     protected boolean wrapperFound;

     protected String themeName;

     protected String themePath;

     protected Plan plan;

     WebslingerInvoker(WebslingerServletContext webslingerServletContext) throws IOException {

         this.webslingerServletContext = webslingerServletContext;

         compiledRules = webslingerServletContext.getContainer().getRules();

         vfsDelegate = webslingerServletContext.getVFSDelegate();

         ExecutionPool.addAtExit(threadStateInitializer);

         jsonHub = new ArrayList<Map<String, Object>>();

     }

     private WebslingerInvoker(WebslingerInvoker parent) throws IOException {

         webslingers.addAll(parent.webslingers);

         compiledRules = parent.compiledRules;

         webslingerServletContext = parent.webslingerServletContext;

         vfsDelegate = parent.vfsDelegate;

         wrapperFound = parent.wrapperFound;

         themeName = parent.themeName;

         themePath = parent.themePath;

         ExecutionPool.addAtExit(threadStateInitializer);

         jsonHub = parent.jsonHub;

     }

     public static WebslingerInvoker getGlobalInvoker() throws IOException {

         return invokerLocal.get();

     }

     public String getThemePath() {

         return themePath;

     }

     void sendJSONEvent(String topic, Object data) {

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

         msg.put("topic", topic);

         msg.put("data", data);

         jsonHub.add(msg);

     }

     List<Map<String, Object>> getJSONHub() {

         return jsonHub;

     }

     public void reset() {

         themeName = null;

         themePath = null;

         wrapperFound = false;

     }

     public Map<String, Object> findContext() {

         // Don't need to check stackPtr > 0, as we are *always* called

         // from another resource

         return current == null ? null : current.getContext();

     }

     public String getText(PathContext pc) throws IOException, ServletException {

         return VFSUtil.getString(pc.getFile());

     }

     public Future runAsync(long delay, final PathContext pc, final Map<String, Object> context, final String command, final Object payload) throws IOException, ServletException {

         // top-level invocation

         if (false) {

         ByteArrayOutputStream bytes = new ByteArrayOutputStream();

         try {

             new ObjectOutputStream(bytes).writeObject(context);

         } catch (IOException e) {

             LogRecord logRecord = new LogRecord(Level.WARNING, "Couldn't serialize object, for possible saving to disk");

             //logRecord.setThrown(e);

             logger.log(logRecord);

         }

         }

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

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

         final WebslingerInvoker sub = new WebslingerInvoker(this);

         return ExecutionPool.schedule(

             new Callable<Object>() {

                 public Object call() throws Exception {

                     try {

                         return sub.invoke(pc, null, request, response, context, command, payload);

                     } catch (Exception e) {

                         LogRecord logRecord = new LogRecord(Level.SEVERE, "Exception during async call");

                         logRecord.setThrown(e);

                         logger.log(logRecord);

                         throw e;

                     } catch (Error e) {

                         LogRecord logRecord = new LogRecord(Level.SEVERE, "Error during async call");

                         logRecord.setThrown(e);

                         logger.log(logRecord);

                         throw e;

                     }

                 }

             },

             delay,

             TimeUnit.MILLISECONDS

         );

     }

     private Webslinger captureInit(PathContext pc, HttpServletRequest request, HttpServletResponse response, Writer writer, Map<String, Object> context, String command, Object payload) throws IOException, ServletException {

         response = new FakeHttpServletResponse(new FakeServletResponse(writer));

         request = new FakeHttpServletRequest(webslingerServletContext, new FakeServletRequest(webslingerServletContext, pc), response, pc);

         return initRequest(newWebslinger(Action.CAPTURE, pc, request, response, context, command, payload));

     }

     public void capture(PathContext pc, PathContext template, HttpServletRequest request, HttpServletResponse response, Writer writer, Map<String, Object> context, String command, Object payload) throws IOException, ServletException {

         boolean oldWrapperFound = wrapperFound;

         wrapperFound = false;

         try {

             invoke(captureInit(pc, request, response, writer, context, command, payload), template).run();

         } finally {

             wrapperFound = oldWrapperFound;

         }

     }

     public void capture(PathContext pc, HttpServletRequest request, HttpServletResponse response, Writer writer, Map<String, Object> context, String command, Object payload, PathContext... templates) throws IOException, ServletException {

         boolean oldWrapperFound = wrapperFound;

         wrapperFound = false;

         try {

             invoke(captureInit(pc, request, response, writer, context, command, payload), templates).run();

         } finally {

             wrapperFound = oldWrapperFound;

         }

     }

     Object runDirect(PathContext pc, HttpServletRequest request, HttpServletResponse response, Map<String, Object> context, String command, Object payload) throws IOException, ServletException {

         if (logger.isLoggable(Level.FINE)) logger.fine("runDirect(" + pc + ")");

         Webslinger webslinger = newWebslinger(Action.CONTENT, pc, request, response, context, command, payload);

         initRequest(webslinger);

         pushFrame(webslinger);

         try {

             return invokeContent(webslinger);

         } finally {

             popFrame();

         }

     }

     private Webslinger newWebslinger(Action action, PathContext pc, Map<String, Object> context, String command, Object payload, Writer writer) throws IOException, ServletException {

         if (logger.isLoggable(Level.FINE)) logger.fine("runDirect(" + pc + ")");

         HttpServletRequest request;

         HttpServletResponse response;

         if (current == null) {

             response = new FakeHttpServletResponse(new FakeServletResponse(writer));

             request = new FakeHttpServletRequest(webslingerServletContext, new FakeServletRequest(webslingerServletContext, pc), response, pc);

         } else {

             request = getWebslingerServletContext().alterPaths(pc, current.getRequest());

             response = getWebslingerServletContext().alterPaths(pc, request, current.getResponse(), writer);

         }

         return newWebslinger(action, pc, request, response, context, command, payload);

     }

     Object runDirect(PathContext pc, Map<String, Object> context, String command, Object payload) throws IOException, ServletException {

         Webslinger webslinger = newWebslinger(Action.CONTENT, pc, context, command, payload, new StringWriter());

         initRequest(webslinger);

         pushFrame(webslinger);

         try {

             return invokeContent(webslinger);

         } finally {

             popFrame();

         }

     }

     public Webslinger initRequest(PathContext pc, Map<String, Object> context, String command, Object payload, Writer writer) throws IOException, ServletException {

         Webslinger webslinger = newWebslinger(Action.CONTENT, pc, context, command, payload, writer);

         initRequest(webslinger);

         if (logger.isLoggable(Level.FINE)) logger.fine("invoke(" + pc + ")");

         return webslinger;

     }

     public Object run(PathContext pc, PathContext template, Map<String, Object> context, String command, Object payload, Writer writer) throws IOException, ServletException {

         return invoke(initRequest(pc, context, command, payload, writer), template).run();

     }

     public Object run(PathContext pc, Map<String, Object> context, String command, Object payload, Writer writer, PathContext... templates) throws IOException, ServletException {

         return invoke(initRequest(pc, context, command, payload, writer), templates).run();

     }

     protected CSSAction[] findActions(Webslinger current, Action action, boolean all) throws IOException, ServletException {

         // FIXME: use specificity

         return compiledRules != null ? compiledRules.findActions(action, current.getRequest(), current, all) : new CSSAction[0];

     }

     protected CSSAction[] findActions(ServletRequest request, Action action, boolean all) throws IOException, ServletException {

         // FIXME: use specificity

         return compiledRules != null ? compiledRules.findActions(action, request, current, all) : new CSSAction[0];

     }

     protected void showActions(ServletRequest request, CSSAction[] actions) throws IOException, ServletException {

         CompiledRules.showActions(actions, request, current);

     }

     protected Object getFirstValue(ServletRequest request, CSSAction[] actions) throws IOException, ServletException {

         return CompiledRules.getFirstValue(actions, request, current);

     }

     protected <T> T convertTo(ConvertHelper<T> helper, ServletRequest request, Object id) throws IOException {

         try {

             CSSAction[] actions = findActions(request, Action.TRANSFORM, false);

             if (actions == null) return helper.noConvert(id);

             String convertorName = (String) getFirstValue(request, actions);

             if (convertorName == null) return helper.noConvert(id);

             FileConvertor convertor = FileConvertor.getConvertor(convertorName);

             if (convertor == null) return helper.noConvert(id);

             String data = vfsDelegate.getString(id);

             return helper.convert(convertor.convert(id, id.toString(), vfsDelegate.getString(id), null));

         } catch (ServletException e) {

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

         }

     }

     protected interface ConvertHelper<T> {

         T noConvert(Object id) throws IOException;

         T convert(String data) throws IOException;

     }

     private final ConvertHelper<InputStream> StreamConvert = new ConvertHelper<InputStream>() {

         public InputStream noConvert(Object id) throws IOException {

             return vfsDelegate.openInput(id);

         }

         public InputStream convert(String data) throws IOException {

             return new ByteArrayInputStream(IOUtil.getBytes(data, Charsets.UTF8));

         }

     };

     private final ConvertHelper<String> StringConvert = new ConvertHelper<String>() {

         public String noConvert(Object id) throws IOException {

             return vfsDelegate.getString(id);

         }

         public String convert(String data) throws IOException {

             return data;

         }

     };

     public InputStream convertToStream(ServletRequest request, Object id) throws IOException {

         return convertTo(StreamConvert, request, id);

     }

     public String convertToString(ServletRequest request, Object id) throws IOException {

         return convertTo(StringConvert, request, id);

     }

     public void pushFrame(Webslinger webslinger) {

         webslinger.setParent(current);

         current = webslinger;

     }

     public Webslinger popFrame() {

         try {

             return current;

         } finally {

             current = current.getParent();

         }

     }

     public Webslinger peekFrame() {

         return current;

     }

     private Webslinger newWebslinger(Action type, Webslinger base, PathContext pc) throws IOException, ServletException {

         if (pc == null) return null;

         return setCaller(new Webslinger(type, base, pc));

     }

     private Webslinger[] newWebslinger(Action type, Webslinger base, PathContext... pc) throws IOException, ServletException {

         List<Webslinger> webslingers = new ArrayList<Webslinger>(pc.length);

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

             if (pc[i] == null) continue;

             webslingers.add(setCaller(new Webslinger(type, base, pc[i])));

         }

         return webslingers.toArray(new Webslinger[webslingers.size()]);

     }

     private Webslinger newWebslinger(Action type, PathContext pc, HttpServletRequest request, HttpServletResponse response, Map<String, Object> context, String command, Object payload) throws IOException, ServletException {

         return setCaller(new Webslinger(type, webslingerServletContext, this, pc, request, response, context, command, payload));

     }

     private Webslinger newWebslinger(Action type, Webslinger base, PathContext pc, Map<String, Object> context, String command, Object payload) throws IOException, ServletException {

         return setCaller(new Webslinger(type, webslingerServletContext, this, pc, base.getRequest(), base.getResponse(), context, command, payload));

     }

     private Webslinger setCaller(Webslinger webslinger) {

         if (current != null) webslinger.setCaller(current);

         return webslinger;

     }

     protected Webslinger initRequest(Webslinger webslinger) throws IOException {

         HttpServletRequest request = webslinger.getRequest();

         HttpServletResponse response = webslinger.getResponse();

         PathContext pc = webslinger.getPathContext();

         if (themeName == null) {

             if (request instanceof HttpServletRequest) {

                 HttpSession session = ((HttpServletRequest) request).getSession(false);

                 if (session != null) {

                     themeName = (String) session.getAttribute("THEME");

                 } else {

                     themeName = null;

                 }

             } else {

                 themeName = null;

             }

             if (themeName == null) themeName = compiledRules != null ? compiledRules.rules.getDefaultTheme() : "Default";

             themePath = "/Theme/" + themeName;

         }

         request.setAttribute("THEME", themeName);

         request.setAttribute("THEMEPATH", themePath);

         String contentType = (String) pc.getAttribute("content-type");

         String charset = (String) pc.getAttribute("charset");

         if (contentType != null) response.setContentType(contentType);

         if (charset != null) response.setCharacterEncoding(charset);

         webslinger.getContext().put("ThemePath", themePath);

         return webslinger;

     }

     public Webslinger initRequest(PathContext pc, HttpServletRequest request, HttpServletResponse response, Map<String, Object> context, String command, Object payload) throws IOException, ServletException {

         Webslinger webslinger = newWebslinger(Action.CONTENT, pc, request, response, context, command, payload);

         initRequest(webslinger);

         return webslinger;

     }

     public Object invoke(final PathContext pc, final PathContext template, final HttpServletRequest request, final HttpServletResponse response, Map<String, Object> context, String command, Object payload) throws IOException, ServletException {

         if (logger.isLoggable(Level.FINE)) logger.fine("invoke(" + pc + ")");

         return invoke(initRequest(pc, request, response, context, command, payload), template).run();

     }

     private Plan invoke(Webslinger webslinger, PathContext template) throws IOException, ServletException {

         return new Plan(webslinger).addTemplates(webslinger).addTemplates(newWebslinger(Action.TEMPLATE, webslinger, template)).checkForWrapper(webslinger);

     }

     private Plan invoke(Webslinger webslinger, PathContext... templates) throws IOException, ServletException {

         return new Plan(webslinger).addTemplates(webslinger).addTemplates(newWebslinger(Action.TEMPLATE, webslinger, templates)).checkForWrapper(webslinger);

     }

     public Plan getPlan() {

         return plan;

     }

     protected void runTriggerValue(Webslinger webslinger, Object triggerValue) throws IOException, ServletException {

         if (logger.isLoggable(Level.FINE)) logger.fine("runTriggerValue(" + webslinger + ", " + triggerValue);

         PathContext trigger = triggerValue instanceof PathContext ? (PathContext) triggerValue : webslinger.resolvePath((String) triggerValue);

         Webslinger triggerWebslinger = newWebslinger(Action.TRIGGER, webslinger, trigger, webslinger.getContext(), "trigger", webslinger);

         new Plan(webslinger).addTemplates(triggerWebslinger).run();

     }

     protected Object invokeContent(final Webslinger webslinger) throws IOException, ServletException {

         if (logger.isLoggable(Level.FINE)) logger.fine("invokeContent(" + webslinger + ")");

         CSSAction[] triggerActions = findActions(webslinger, Action.TRIGGER, true);

         if (triggerActions != null) {

             ServletRequest request = webslinger.getRequest();

             for (CSSAction action: triggerActions) {

                 AbstractValue value = action.getValue();

                 if (value instanceof AbstractListValue) {

                     Object[] triggerValues = ((AbstractListValue) value).getValue(request, webslinger);

                     if (triggerValues != null) {

                         for (Object v: triggerValues) {

                             runTriggerValue(webslinger, v);

                         }

                     }

                 } else {

                     Object triggerValue = ((AbstractSingleValue) value).getValue(request, webslinger);

                     if (triggerValue != null) runTriggerValue(webslinger, triggerValue);

                 }

             }

         }

         WebslingerInvoker old = invokerLocal.get();

         invokerLocal.set(this);

         try {

             return webslinger.getTypeHandler().run(webslinger);

         } finally {

             invokerLocal.set(old);

         }

     }

     private final StringBuilder prefix = new StringBuilder();

     public class Plan {

         protected final Webslinger reason;

         protected final Plan parent;

         protected final List<Webslinger> plan = new ArrayList<Webslinger>();

         protected int index;

         protected Plan(Webslinger reason) {

             this.parent = WebslingerInvoker.this.plan;

             this.reason = reason;

         }

         protected Plan(Plan reason) {

             this.parent = WebslingerInvoker.this.plan;

             this.reason = reason.reason;

             plan.addAll(reason.plan.subList(0, reason.index));

             index = plan.size();

         }

         public Plan add(Webslinger webslinger) {

             plan.add(index++, webslinger);

             return this;

         }

         public Plan addTemplates(PathContext template) throws IOException, ServletException {

             if (template == null) return this;

             if (index == 0) throw new InternalError("plan is empty");

             return addTemplates(newWebslinger(Action.TEMPLATE, plan.get(index - 1), template));

         }

         public Plan addTemplates(PathContext... templates) throws IOException, ServletException {

             if (templates == null || templates.length == 0) return this;

             if (index == 0) throw new InternalError("plan is empty");

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

                 addTemplates(newWebslinger(Action.TEMPLATE, plan.get(index - 1), templates[i]));

             }

             return this;

         }

         public Plan addTemplates(Webslinger ptr) throws IOException, ServletException {

             return addAll(ptr, Action.TEMPLATE);

         }

         private final Plan addAll(Webslinger ptr, Action action) throws IOException, ServletException {

             if (ptr == null) return this;

             plan.add(index++, ptr);

             CSSAction[] actions = findActions(ptr, action, false);

             if (actions == null) return this;

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

                 AbstractValue value = actions[i].getValue();

                 if (value == null) break;

                 if (value instanceof AbstractListValue) {

                     Object[] values = ((AbstractListValue) value).getValue(ptr.getRequest(), ptr);

                     if (values != null) {

                         for (Object v: values) {

                             PathContext template = v instanceof PathContext ? (PathContext) v : ptr.resolvePath((String) v);

                             addAll(newWebslinger(action, ptr, template), action);

                         }

                     }

                 } else {

                     Object v = ((AbstractSingleValue) value).getValue(ptr.getRequest(), ptr);

                     if (v != null) {

                         PathContext template = v instanceof PathContext ? (PathContext) v : ptr.resolvePath((String) v);

                         addAll(newWebslinger(action, ptr, template), action);

                     }

                 }

             }

             return this;

         }

         public Plan addTemplates(Webslinger... templates) throws IOException, ServletException {

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

                 Webslinger ptr = templates[i];

                 addAll(ptr, Action.TEMPLATE);

             }

             return this;

         }

         public Plan checkForWrapper(Webslinger webslinger) throws IOException, ServletException {

             if (!wrapperFound) {

                 CSSAction[] actions = findActions(webslinger, Action.WRAP, false);

                 if (actions != null) {

                     wrapperFound = true;

                     PathContext pc = (PathContext) CompiledRules.getFirstValue(actions, webslinger.getRequest(), webslinger);

                     if (pc != null) return addTemplates(newWebslinger(Action.WRAP, webslinger, pc));

                 }

             }

             return this;

         }

         public Object run() throws IOException, ServletException {

             if (index == 0) throw new InternalError("plan is empty");

             index--;

             Plan oldPlan = WebslingerInvoker.this.plan;

             try {

                 WebslingerInvoker.this.plan = this;

                 Webslinger webslinger = plan.get(index);

                 pushFrame(webslinger);

                 try {

                     return invokeContent(webslinger);

                 } finally {

                     popFrame();

                 }

             } finally {

                 index++;

                 WebslingerInvoker.this.plan = oldPlan;

             }

         }

         public Object run(Writer writer) throws IOException, ServletException {

             if (index == 0) throw new InternalError("plan is empty");

             index--;

             try {

                 Webslinger webslinger = plan.get(index);

                 pushFrame(webslinger);

                 try {

                     HttpServletResponse oldResponse = webslinger.pushResponse(writer);

                     try {

                         return invokeContent(webslinger);

                     } finally {

                         webslinger.popResponse(oldResponse);

                     }

                 } finally {

                     popFrame();

                 }

             } finally {

                 index++;

             }

         }

         public PathContext findSection(String name) throws IOException {

             int i = index;

             Webslinger sectionWebslinger = null;

             String foundSection = null;

             while (i >= 0) {

                 Webslinger webslinger = plan.get(i);

                 String tmpSection = (String) webslinger.getFileAttribute("section-" + name);

                 if (tmpSection != null) {

                     foundSection = tmpSection;

                     sectionWebslinger = webslinger;

                 }

                 i--;

             }

             return foundSection == null ? null : sectionWebslinger.resolvePath(foundSection);

         }

         public void merge(Plan reason, PathContext pc, Map<String, Object> context, Writer writer, AlterPlan alterPlan) throws IOException {

             PlanCreator creator = new PlanCreator<Plan>() {

                 protected Plan createPlan(Plan reason) {

                     return new Plan(reason);

                 }

             };

             merge(creator, reason, pc, context, writer, alterPlan);

         }

         public void merge(Webslinger reason, PathContext pc, Map<String, Object> context, Writer writer, AlterPlan alterPlan) throws IOException {

             PlanCreator creator = new PlanCreator<Webslinger>() {

                 protected Plan createPlan(Webslinger reason) {

                     return new Plan(reason);

                 }

             };

             merge(creator, reason, pc, context, writer, alterPlan);

         }

         protected <T> void merge(PlanCreator<T> creator, T reason, PathContext pc, Map<String, Object> context, Writer writer, AlterPlan alterPlan) throws IOException {

             if (context == null) context = findContext();

             HttpServletRequest request;

             HttpServletResponse response;

             if (current == null) {

                 response = new FakeHttpServletResponse(new FakeServletResponse(writer));

                 request = new FakeHttpServletRequest(webslingerServletContext, new FakeServletRequest(webslingerServletContext, pc), response, pc);

             } else {

                 request = getWebslingerServletContext().alterPaths(pc, current.getRequest());

                 response = getWebslingerServletContext().alterPaths(pc, request, current.getResponse(), writer);

             }

             if (logger.isLoggable(Level.FINE)) logger.fine("invoke(" + pc + ")");

             try {

                 Webslinger webslinger = newWebslinger(Action.CONTENT, pc, request, response, context, "merge", null);

                 Plan oldPlan = WebslingerInvoker.this.plan;

                 try {

                     WebslingerInvoker.this.plan = creator.createPlan(reason).addTemplates(webslinger);

                     if (alterPlan != null) alterPlan.alterPlan(WebslingerInvoker.this.plan);

                     WebslingerInvoker.this.plan.run();

                 } finally {

                     WebslingerInvoker.this.plan = oldPlan;

                 }

             } catch (ServletException e) {

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

             }

         }

         public String toString() {

             return "Plan(" + index + ":" + plan + ")";

         }

         public Webslinger getReason() {

             return reason;

         }

         public Webslinger getCurrentWebslinger() {

             return plan.get(index);

         }

         public Webslinger getNextWebslinger() {

             return plan.get(index - 1);

         }

     }

     public abstract static class AlterPlan {

         protected abstract void alterPlan(Plan plan) throws IOException, ServletException;

     }

     protected abstract static class PlanCreator<T> {

         protected abstract Plan createPlan(T reason);

     }

 }