/// <summary>
		/// Invokes the next handler.
		/// </summary>
		/// <param name="context">The context.</param>
		protected void InvokeNext(IRailsEngineContext context)
		{
			if (nextHandler != null)
			{
				nextHandler.Process(context);
			}
		}

        public void RenderViewFor(Presentation presentation, IRailsEngineContext context)
        {
            TabularPresentation tabularPresentation = presentation as TabularPresentation;
            Controller controller = context.CurrentController;

            // configuration as json output = { baseParams: {...}, tables: [...] }
            Hashtable configuration = new Hashtable(2);
            configuration["filters"] = CollectFilterParameters(controller.Params);
            configuration["tables"] = new ArrayList();

            foreach (TabularQuery table in tabularPresentation.GetQueries())
            {
                Hashtable tableConfig = new Hashtable();
                tableConfig["url"] = controller.UrlBuilder.BuildUrl(
                    context.UrlInfo,
                    controller.Name,
                    "table",
                    DictHelper.Create("table=" + table.Id.ToString())
                );
                tableConfig["download"] = controller.UrlBuilder.BuildUrl(
                    context.UrlInfo,
                    controller.Name,
                    "download",
                    DictHelper.Create("table=" + table.Id.ToString())
                );
                tableConfig["title"] = table.Title;
                tableConfig["columns"] = table.ColumnNames();
                ((ArrayList)configuration["tables"]).Add(tableConfig);
            }

            controller.PropertyBag["presentation"] = tabularPresentation;
            controller.PropertyBag["configuration"] = JavaScriptConvert.SerializeObject(configuration);
            controller.RenderSharedView("presentation/tables");
        }

		/// <summary>
		/// Renders the mail message.
		/// </summary>
		/// <param name="templateName">Name of the template.</param>
		/// <param name="engineContext">The engine context.</param>
		/// <param name="controller">The controller.</param>
		/// <param name="doNotApplyLayout">if set to <c>true</c> [do not apply layout].</param>
		/// <returns></returns>
		public Message RenderMailMessage(string templateName, IRailsEngineContext engineContext, Controller controller,
		                                 bool doNotApplyLayout)
		{
			context.AddMailTemplateRendered(templateName, controller.PropertyBag);

			return new Message("from", "to", "subject", "body");
		}

		public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
		{
			// Read previous authenticated principal from session 
			// (could be from cookie although with more work)
			
			User user = (User) context.Session["user"];
			
			// Sets the principal as the current user
			context.CurrentUser = user;
			
			// Checks if it is OK
			if (context.CurrentUser == null || !context.CurrentUser.Identity.IsAuthenticated)
			{
				// Not authenticated, redirect to login
				NameValueCollection parameters = new NameValueCollection();
				parameters.Add("ReturnUrl", context.Url);
				controller.Redirect("login", "index", parameters);
				
				// Prevent request from continue
				return false;
			}
			
			// Everything is ok
			return true;
		}

		/// <summary>
		/// Executa o filtro.
		/// </summary>
		public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
		{
			if (!Enabled)
				return true;

			UserAgent ua = null;

			var uaString = context.UnderlyingContext.Request.UserAgent;
			if (uaString != null)
			{
				ua = (UserAgent) cache[uaString];
				if (ua == null)
					cache[uaString] = ua = new UserAgent(uaString);
			}

			if (IsValid(ua))
				return true;

			if (!logged)
			{
				Log.Error("Tentativa de acesso através de browser não suportado: {0}", uaString);
				logged = true;
			}

			controller.PropertyBag["invalidGecko"] = true;
			if (!Redirect)
				return true;

			throw new Exception("redir: " + Redirect);

			//RedirectToNotice(controller);
			//return false;
		}

			public ItemToProcess(WebResourceProcessor proc, string contents, IRailsEngineContext ctx, IDictionary parameters)
			{
				this.proc = proc;
				this.contents = contents;
				this.ctx = ctx;
				this.parameters = parameters;
			}

		public AspViewBase CreateView(Type type, TextWriter output, IRailsEngineContext context, Controller controller)
		{
			ConstructorInfo constructor = (ConstructorInfo)constructors[type];
			AspViewBase self = (AspViewBase)FormatterServices.GetUninitializedObject(type);
			constructor.Invoke(self, new object[] { this, output, context, controller });
			return self;
		}

		public bool Perform(ExecuteEnum exec, IRailsEngineContext ctx, Controller c)
		{
			if (!controllersToSkip.IsMatch(GetControllerName(c)))
				if (ctx.CurrentUser == null || !ctx.CurrentUser.Identity.IsAuthenticated)
					return TryAutoLogin();

			return true;
		}

		/// <summary>
		/// Implementors should perform the action
		/// on the exception. Note that the exception
		/// is available in <see cref="IRailsEngineContext.LastException"/>
		/// </summary>
		/// <param name="context"></param>
        public override void Process(IRailsEngineContext context)
        {
            ILoggerFactory factory = (ILoggerFactory) context.GetService(typeof (ILoggerFactory));
            ILogger logger = factory.Create(context.CurrentController.GetType());

            logger.Error(BuildStandardMessage(context));
            InvokeNext(context);
        }

		/// <summary>
		/// Initializes a new instance of the <see cref="BrailBase"/> class.
		/// </summary>
		/// <param name="viewEngine">The view engine.</param>
		/// <param name="output">The output.</param>
		/// <param name="context">The context.</param>
		/// <param name="__controller">The controller.</param>
		public BrailBase(BooViewEngine viewEngine, TextWriter output, IRailsEngineContext context, Controller __controller)
		{
			this.viewEngine = viewEngine;
			this.outputStream = output;
			this.context = context;
			this.__controller = __controller;
			InitProperties(context, __controller);
		}

 public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
 {
     User user = (User)context.Session["logonUser"];
     if (user == null)
     {
         return false;
     }
     return true;
 }

		public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
		{
			if (context.Params["printable"] != null)
			{
				controller.LayoutName = "printabletheme";
			}

			return true;
		}

 public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
 {
     if (context.Request.Headers["mybadheader"] != null)
     {
         context.Response.Write("Denied!");
         return false;
     }
     return true;
 }

		public WizardStepPage[] GetSteps(IRailsEngineContext context)
		{
			return new WizardStepPage[]
			{
				(WizardStepPage) kernel[typeof(Page1)],
				(WizardStepPage) kernel[typeof(Page2)],
				(WizardStepPage) kernel[typeof(Page3)],
				(WizardStepPage) kernel[typeof(Page4)],
			};
		}

		public virtual bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
		{
			if (!PerformAuthentication(context))
			{
				context.Response.Redirect("account", "authentication");
				return false;
			}

			return true;
		}

		/// <summary>
		/// Implementors should perform the action
		/// on the exception. Note that the exception
		/// is available in <see cref="IRailsEngineContext.LastException"/>
		/// </summary>
		/// <param name="context"></param>
        public override void Process(IRailsEngineContext context)
        {
            Exception ex = context.LastException is TargetInvocationException
                               ? context.LastException.InnerException
                               : context.LastException;
            if (!excludedTypes.Contains(ex.GetType()))
            {
                InvokeNext(context);
            }
        }

		/// <summary>
		/// Implementors should perform they filter logic and
		/// return <c>true</c> if the action should be processed.
		/// </summary>
		/// <param name="exec">When this filter is being invoked</param>
		/// <param name="context">Current context</param>
		/// <param name="controller">The controller instance</param>
		/// <returns>
		/// 	<c>true</c> if the action
		/// should be invoked, otherwise <c>false</c>
		/// </returns>
		public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
		{
			if (context.Request.Headers["HTTP_X_MOZ"].Equals("prefetch"))
			{
				Trace.Write("prefetch detected: sending 403 Forbidden");
				context.Response.StatusCode = 403;
				return false;
			}

			return true;
		}

		public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
		{
			if (context.CurrentUser == null || !context.CurrentUser.Identity.IsAuthenticated)
			{
				context.Response.Redirect("admin", "login");

				return false;
			}

			return true;
		}

			protected override bool IsPreConditionSatisfied(IRailsEngineContext context)
			{
				bool isOk = Query["id"] == "1";
			
				if (!isOk)
				{
					Redirect("TestWizardConditions", "Index");
				}
			
				return isOk;
			}

		public override bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
		{
			if (context.CurrentUser.Identity.IsAuthenticated)
			{
				return true;
			}

			base.PerformAuthentication(context);

			return true;
		}