My.Web.UrlRewriteModuleBase

using EPiServer;
using EPiServer.Core;
using EPiServer.Editor;
using EPiServer.Web.Routing;
using log4net;
using System;
using System.Threading;
using System.Web;
using System.Reflection;

namespace My.Web
{
    /// <summary>
    /// Responsible for raising appropriate events for mapping between internal and external formats of the
    ///             request URLs.
    ///
    /// </summary>
    ///
    /// <remarks>
    /// Will parse outgoing HTML, and incoming and outgoing special urls and parameter strings, raising the
    ///             appropriate events implemented by the implementation derived classes. It is this
    ///             modules responsibility to identify all necessary urls for rewriting in one or the other direction. The
    ///             descendant class must provide the actual rewriting functionality.
    ///
    /// </remarks>
    ///
    [Obsolete("This is a temporary solution so IIS 8.5 would work as well")]
    public abstract class UrlRewriteModuleBase : EPiServer.Web.UrlRewriteModuleBase
    {
        /// <summary>
        /// A logger instance.
        ///
        /// </summary>
        private static ILog _log = LogManager.GetLogger(typeof(UrlRewriteModuleBase));

        /// <summary>
        /// Gets or sets a value indicating whether the response to the current request should
        ///             be processed for rewriting of internal links to friendly urls.
        ///
        /// </summary>
        ///
        /// <value>
        /// <c>true</c> if the response will be processed by UrlRewriteProvider.
        ///
        /// </value>
        public override bool FURLRewriteResponse
        {
            get
            {
                return UrlRewriteModuleBase.GetRequestContext().FURLRewriteResponse;
            }
            set
            {
                UrlRewriteModuleBase.GetRequestContext().FURLRewriteResponse = value;
            }
        }

        /// <summary>
        /// Gets or sets the internal URL.
        ///
        /// </summary>
        ///
        /// <value>
        /// The internal URL
        /// </value>
        ///
        /// <remarks>
        /// Used together with UrlExternal to provide the necessary context for rewriting relative
        ///             URL's and to make them relative after rewriting, if required.
        ///
        /// </remarks>
        public new UrlBuilder UrlInternal
        {
            get
            {
                return UrlRewriteModuleBase.GetRequestContext().UrlInternal;
            }
        }

        /// <summary>
        /// Gets or sets the external URL.
        ///
        /// </summary>
        ///
        /// <value>
        /// The external URL
        /// </value>
        ///
        /// <remarks>
        /// Used together with UrlInternal to provide the necessary context for rewriting relative
        ///             URL's and to make them relative after rewriting, if required.
        ///
        /// </remarks>
        public new UrlBuilder UrlExternal
        {
            get
            {
                return UrlRewriteModuleBase.GetRequestContext().UrlExternal;
            }
        }

        /// <summary>
        /// Initialize events. Use this handler to subscribe to the relevant events. Raised once
        ///             per instance of the HttpModule.
        ///
        /// </summary>
        public new static event EventHandler<EPiServer.Web.UrlRewriteEventArgs> HttpRewriteInit;

        /// <summary>
        /// Raised before rewriting the request URL from external to internal
        ///
        /// </summary>
        ///
        /// <remarks>
        /// Extra validation can be performed here, as well as pre-steps in the rewriting
        ///             process. Set e.Cancel to true to stop rewriting from ocurring.
        ///
        /// </remarks>
        public new event EventHandler<EPiServer.Web.UrlRewriteEventArgs> HttpRewritingToInternal;

        /// <summary>
        /// Raised after rewriting the request URL from external to internal
        ///
        /// </summary>
        public new event EventHandler<EPiServer.Web.UrlRewriteEventArgs> HttpRewroteToInternal;

        /// <summary>
        /// Raised before rewriting the request URL from internal to external
        ///
        /// </summary>
        ///
        /// <remarks>
        /// Extra validation can be performed here, as well as pre-steps in the rewriting
        ///             process. Set e.Cancel to true to stop rewriting from ocurring.
        ///
        /// </remarks>
        public new event EventHandler<EPiServer.Web.UrlRewriteEventArgs> HttpRewritingToExternal;

        /// <summary>
        /// Raised after rewriting the request URL from internal to external
        ///
        /// </summary>
        public new event EventHandler<EPiServer.Web.UrlRewriteEventArgs> HttpRewroteToExternal;

        /// <summary>
        /// Raised before adding the the HTML rewrite-filter.
        ///
        /// </summary>
        ///
        /// <remarks>
        /// Extra validation can be performed here. Set e.Cancel to true to stop rewriting from ocurring.
        ///
        /// </remarks>
        public new event EventHandler<EPiServer.Web.UrlRewriteEventArgs> HtmlAddingRewriteToExternalFilter;

        /// <summary>
        /// Raised after the HTML rewriting filter has been added.
        ///
        /// </summary>
        public new event EventHandler<EPiServer.Web.UrlRewriteEventArgs> HtmlAddedRewriteToExternalFilter;

        static UrlRewriteModuleBase()
        {
        }

        /// <summary>
        /// Raises the <see cref="E:EPiServer.Web.UrlRewriteModuleBase.HttpRewriteInit"/> event.
        ///
        /// </summary>
        /// <param name="e">The <see cref="T:EPiServer.Web.UrlRewriteEventArgs"/> instance containing the event data.</param>
        protected override void OnHttpRewriteInit(EPiServer.Web.UrlRewriteEventArgs e)
        {
            EventHandler<EPiServer.Web.UrlRewriteEventArgs> eventHandler = UrlRewriteModuleBase.HttpRewriteInit;
            if (eventHandler == null)
                return;
            eventHandler((object)this, e);
        }

        /// <summary>
        /// Raises the <see cref="E:EPiServer.Web.UrlRewriteModuleBase.HttpRewritingToInternal"/> event.
        ///
        /// </summary>
        /// <param name="e">The <see cref="T:EPiServer.Web.UrlRewriteEventArgs"/> instance containing the event data.</param>
        protected override void OnHttpRewritingToInternal(EPiServer.Web.UrlRewriteEventArgs e)
        {
            EventHandler<EPiServer.Web.UrlRewriteEventArgs> eventHandler = this.HttpRewritingToInternal;
            if (eventHandler == null)
                return;
            eventHandler((object)this, e);
        }

        /// <summary>
        /// Raises the <see cref="E:EPiServer.Web.UrlRewriteModuleBase.HttpRewroteToInternal"/> event.
        ///
        /// </summary>
        /// <param name="e">The <see cref="T:EPiServer.Web.UrlRewriteEventArgs"/> instance containing the event data.</param>
        protected override void OnHttpRewroteToInternal(EPiServer.Web.UrlRewriteEventArgs e)
        {
            EventHandler<EPiServer.Web.UrlRewriteEventArgs> eventHandler = this.HttpRewroteToInternal;
            if (eventHandler == null)
                return;
            eventHandler((object)this, e);
        }

        /// <summary>
        /// Raises the <see cref="E:EPiServer.Web.UrlRewriteModuleBase.HttpRewritingToExternal"/> event.
        ///
        /// </summary>
        /// <param name="e">The <see cref="T:EPiServer.Web.UrlRewriteEventArgs"/> instance containing the event data.</param>
        protected override void OnHttpRewritingToExternal(EPiServer.Web.UrlRewriteEventArgs e)
        {
            EventHandler<EPiServer.Web.UrlRewriteEventArgs> eventHandler = this.HttpRewritingToExternal;
            if (eventHandler == null)
                return;
            eventHandler((object)this, e);
        }

        /// <summary>
        /// Raises the <see cref="E:EPiServer.Web.UrlRewriteModuleBase.HttpRewroteToExternal"/> event.
        ///
        /// </summary>
        /// <param name="e">The <see cref="T:EPiServer.Web.UrlRewriteEventArgs"/> instance containing the event data.</param>
        protected override void OnHttpRewroteToExternal(EPiServer.Web.UrlRewriteEventArgs e)
        {
            EventHandler<EPiServer.Web.UrlRewriteEventArgs> eventHandler = this.HttpRewroteToExternal;
            if (eventHandler == null)
                return;
            eventHandler((object)this, e);
        }

        /// <summary>
        /// Raises the <see cref="E:EPiServer.Web.UrlRewriteModuleBase.HtmlAddingRewriteToExternalFilter"/> event.
        ///
        /// </summary>
        /// <param name="e">The <see cref="T:EPiServer.Web.UrlRewriteEventArgs"/> instance containing the event data.</param>
        protected override void OnHtmlAddingRewriteToExternalFilter(EPiServer.Web.UrlRewriteEventArgs e)
        {
            EventHandler<EPiServer.Web.UrlRewriteEventArgs> eventHandler = this.HtmlAddingRewriteToExternalFilter;
            if (eventHandler == null)
                return;
            eventHandler((object)this, e);
        }

        /// <summary>
        /// Raises the <see cref="E:EPiServer.Web.UrlRewriteModuleBase.HtmlAddedRewriteToExternalFilter"/> event.
        ///
        /// </summary>
        /// <param name="e">The <see cref="T:EPiServer.Web.UrlRewriteEventArgs"/> instance containing the event data.</param>
        protected override void OnHtmlAddedRewriteToExternalFilter(EPiServer.Web.UrlRewriteEventArgs e)
        {
            EventHandler<EPiServer.Web.UrlRewriteEventArgs> eventHandler = this.HtmlAddedRewriteToExternalFilter;
            if (eventHandler == null)
                return;
            eventHandler((object)this, e);
        }

        private static UrlRewriteModuleBase.RequestContext GetRequestContext()
        {
            HttpContext current = HttpContext.Current;
            UrlRewriteModuleBase.RequestContext requestContext = current.Items[(object)"EP:urlRewriteContext"] as UrlRewriteModuleBase.RequestContext;
            if (requestContext == null)
            {
                requestContext = new UrlRewriteModuleBase.RequestContext();
                Uri url = current.Request.Url;
                requestContext.UrlInternal = new UrlBuilder(url);
                requestContext.UrlExternal = new UrlBuilder(new Uri(url, current.Request.RawUrl));
                current.Items[(object)"EP:urlRewriteContext"] = (object)requestContext;
            }
            return requestContext;
        }

        /// <summary>
        /// Disposes of the resources (other than memory) used by the module that implements <see cref="T:System.Web.IHttpModule"/>.
        ///
        /// </summary>
        public override void Dispose()
        {
        }

        public static void SetPrivateVariable(System.Type t, string varName, object varValue, object objInstance)
        {
            BindingFlags eFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
            PropertyInfo pi;

            pi = t.GetProperty(varName, eFlags);
            if (pi != null)
                pi.SetValue(objInstance, varValue, null);
        }

        /// <summary>
        /// Called by the ASP.NET framework to initialize module
        ///
        /// </summary>
        /// <param name="application"/>
        public override void Init(HttpApplication application)
        {
            application.BeginRequest += new EventHandler(this.BeginRequestEventHandler);
            application.EndRequest += new EventHandler(this.EndRequestEventHandler);
            application.PostRequestHandlerExecute += new EventHandler(this.PostRequestHandlerExecuteEventHandler);
            SetPrivateVariable(typeof(EPiServer.Web.UrlRewriteProvider), "IsFurlEnabled", true, null);
            SetPrivateVariable(typeof(EPiServer.Web.UrlRewriteProvider), "Module", this, null);
            //EPiServer.Web.UrlRewriteProvider.IsFurlEnabled = true;
            //EPiServer.Web.UrlRewriteProvider.Module = this;
            this.OnHttpRewriteInit(new EPiServer.Web.UrlRewriteEventArgs());
        }

        /// <summary>
        /// The BeginRequest event handler.
        ///             We should only handle Friendly URL rewrites here, and it depends on the authentication mechanism
        ///             where we actually do it. This is a TODO...
        ///
        /// </summary>
        /// <param name="sender"/><param name="e"/>
        private void BeginRequestEventHandler(object sender, EventArgs e)
        {
            HttpApplication httpApplication = (HttpApplication)sender;
            if (UrlRewriteModuleBase._log.IsDebugEnabled)
                UrlRewriteModuleBase._log.DebugFormat("Starting request with Url {0}", (object)httpApplication.Request.Url);
            UrlRewriteModuleBase.RequestContext requestContext = UrlRewriteModuleBase.GetRequestContext();
            this.HttpUrlRewriteToInternal(requestContext.UrlInternal);
            if (string.Equals(HttpUtility.UrlDecode((string)requestContext.UrlInternal), HttpUtility.UrlDecode((string)requestContext.UrlExternal), StringComparison.OrdinalIgnoreCase))
            {
                if (!UrlRewriteModuleBase._log.IsDebugEnabled)
                    return;
                UrlRewriteModuleBase._log.DebugFormat("Exiting with no rewrite, Url is {0}", (object)requestContext.UrlInternal);
            }
            else
            {
                if (string.IsNullOrEmpty(requestContext.UrlInternal.Path))
                {
                    ExceptionManager.RenderHttpRuntimeError((Exception)new HttpException(404, "Not Found"));
                    httpApplication.Context.Response.End();
                }
                RequestContextExtension.SetContentLink(httpApplication.Context.Request.RequestContext, EPiServer.Web.PermanentLinkUtility.GetContentReference(requestContext.UrlInternal));
                RequestContextExtension.SetLanguage(httpApplication.Context.Request.RequestContext, requestContext.UrlInternal.QueryLanguage);
                httpApplication.Context.RewritePath(requestContext.UrlInternal.Path, string.Empty, UriSupport.RemoveQueryStringDelimeter(requestContext.UrlInternal.Query), true);
                if (!UrlRewriteModuleBase._log.IsDebugEnabled)
                    return;
                UrlRewriteModuleBase._log.Debug((object)string.Format("17.1.3 UrlRewriteModule rewrites from '{0}' to '{1}'", (object)requestContext.UrlExternal, (object)requestContext.UrlInternal));
            }
        }

        /// <summary>
        /// The EndRequest event handler
        ///
        /// </summary>
        /// <param name="sender"/><param name="e"/>
        protected new void EndRequestEventHandler(object sender, EventArgs e)
        {
            HttpResponse response = ((HttpApplication)sender).Response;
            if (response.StatusCode != 301 && response.StatusCode != 302 && (response.StatusCode != 303 && response.StatusCode != 307))
                return;
            int num = PageEditing.PageIsInEditMode ? 1 : 0;
            response.RedirectLocation = this.HttpUrlRewriteToExternal(response.RedirectLocation, UrlBuilder.RebaseKind.ToRootRelative);
        }

        /// <summary>
        /// Handles the PostRequestHandlerExecute event of the application. This is where we decide whether to
        ///             hookup the rewrite filter for the output stream, based on MIME-type.
        ///
        /// </summary>
        /// <param name="sender">The source of the event.</param><param name="e">The <see cref="T:System.EventArgs"/> instance containing the event data.</param>
        protected new void PostRequestHandlerExecuteEventHandler(object sender, EventArgs e)
        {
            this.HtmlAddRewriteToExternalFilter((HttpApplication)sender);
        }

        /// <summary>
        /// Rewrite a request URL to external.
        ///
        /// </summary>
        /// <param name="url">The URL.</param><param name="typeOfUrl">The type of rebasing to perform on the url.</param>
        /// <returns>
        /// The rewritten request URL
        /// </returns>
        protected override abstract string HttpUrlRewriteToExternal(string url, UrlBuilder.RebaseKind typeOfUrl);

        /// <summary>
        /// Rewrite the URL to internal.
        ///
        /// </summary>
        /// <param name="url">The URL, possibly rewritten</param>
        protected override abstract void HttpUrlRewriteToInternal(UrlBuilder url);

        /// <summary>
        /// Connect a filter for rewriting of outgoing HTML, and perform other actions before actually sending the HTML
        ///
        /// </summary>
        /// <param name="httpApplication">The HttpApplication instance</param>
        //public abstract void HtmlAddRewriteToExternalFilter(HttpApplication httpApplication);

        private class RequestContext
        {
            public UrlBuilder UrlInternal;
            public UrlBuilder UrlExternal;
            public bool FURLRewriteResponse;
        }
    }
}