//------------------------------------------------------------------------------
// <copyright file="XhtmlBasicPageAdapter.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
//------------------------------------------------------------------------------

using System;
using System.Web;
using System.Collections;
using System.Collections.Specialized;
using System.Web.UI;
using System.IO;
using System.Security.Permissions;
using System.Text;
using System.Web.Mobile;
using System.Web.UI.MobileControls;
using System.Web.UI.MobileControls.Adapters;
using System.Diagnostics;
using System.Globalization;

#if COMPILING_FOR_SHIPPED_SOURCE
namespace System.Web.UI.MobileControls.ShippedAdapterSource.XhtmlAdapters
#else
namespace System.Web.UI.MobileControls.Adapters.XhtmlAdapters
#endif
{

    /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter"]/*' />
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    [Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
    public class XhtmlPageAdapter : XhtmlControlAdapter, IPageAdapter {
        private static readonly TimeSpan _cacheExpirationTime = new TimeSpan(0, 20, 0);
        private const int DefaultPageWeight = 4000;

        private IDictionary _cookielessDataDictionary = null;
        private int _defaultPageWeight = DefaultPageWeight;
        private int _optimumPageWeight = 0;
        private MobilePage _page;
        private bool _persistCookielessData = true;
        private bool _pushedCssClassForBody = false;

        public XhtmlPageAdapter() {
            HtmlPageAdapter.SetPreferredEncodings(HttpContext.Current);
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.CacheVaryByHeaders"]/*' />
        public virtual IList CacheVaryByHeaders {
            get {
                return null;
            }
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.CookielessDataDictionary"]/*' />
        public IDictionary CookielessDataDictionary {
            get {
                return _cookielessDataDictionary;
            }

            set {
                _cookielessDataDictionary = value;
            }
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.EventArgumentKey"]/*' />
        public virtual String EventArgumentKey {
            get {
                return Constants.EventArgumentID;
            }
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.EventSourceKey"]/*' />
        public virtual String EventSourceKey {
            get {
                return Constants.EventSourceID;
            }
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.OptimumPageWeight"]/*' />
        public virtual int OptimumPageWeight {
            get {
                if (_optimumPageWeight == 0) {
                    _optimumPageWeight = CalculateOptimumPageWeight(_defaultPageWeight);
                }
                return _optimumPageWeight;
            }
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.Page"]/*' />
        public override MobilePage Page {
            get {
                return _page;
            }
            set {
                _page = value;
            }
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.PersistCookielessData"]/*' />
        public bool PersistCookielessData {
            get {
                return _persistCookielessData;
            }
            set {
                _persistCookielessData = value;
            }
        }

        // Helper function to add multiple values for the same key
        private void AddValues(NameValueCollection sourceCollection,
            String sourceKey,
            NameValueCollection targetCollection) {
            String [] values = sourceCollection.GetValues(sourceKey);
            foreach (String value in values) {
                targetCollection.Add(sourceKey, value);
            }
        }

        private NameValueCollection CollectionFromForm(
            NameValueCollection form,
            String postEventSourceID,
            String postEventArgumentID) {
            int i;
            int count = form.Count;
            NameValueCollection collection = new NameValueCollection();
            bool isPostBack = false;

            for (i = 0; i < count; i++) {
                String name = form.GetKey(i);
                if (name == null || name.Length == 0) {
                    continue;
                }

                // Pager navigation is rendered by buttons which have the
                // targeted page number appended to the form id after
                // PagePrefix which is a constant string to identify this
                // special case.  E.g. ControlID__PG_2
                int index = name.LastIndexOf(Constants.PagePrefix, StringComparison.Ordinal);
                if (index != -1) {
                    // We need to associate the form id with the event source
                    // id and the page number with the event argument id in
                    // order to have the event raised properly by ASP.NET
                    int pageBeginPos = index + Constants.PagePrefix.Length;
                    collection.Add(postEventSourceID,
                        name.Substring(0, index));
                    collection.Add(postEventArgumentID,
                        name.Substring(pageBeginPos,
                        name.Length - pageBeginPos));
                    continue;
                }

                // This is to determine if the request is a postback from
                // the same mobile page.
                if (name == MobilePage.ViewStateID ||
                    name == EventSourceKey) {
                    isPostBack = true;
                }

                // Default case, just preserve the value(s)
                AddValues(form, name, collection);
            }

            if (collection.Count == 0 || !isPostBack) {
                // Returning null to indicate this is not a postback
                return null;
            }
            else {
                return collection;
            }
        }

        private NameValueCollection CollectionFromQueryString(
            NameValueCollection queryString,
            String postEventSourceID,
            String postEventArgumentID) {
            NameValueCollection collection = new NameValueCollection();
            bool isPostBack = false;

            for (int i = 0; i < queryString.Count; i++) {
                String name = queryString.GetKey(i);

                // ASSUMPTION: In query string, besides the expected
                // name/value pairs (ViewStateID, EventSource and
                // EventArgument), there are hidden variables, control
                // id/value pairs (if the form submit method is GET), unique
                // file path suffix variable and custom query string text.
                // They will be in the above order if any of them present.
                // Hidden variables and control id/value pairs should be added
                // back to the collection intactly, but the other 2 items
                // should not be added to the collection.

                // name can be null if there is a query name without equal
                // sign appended.  We should just ignored it in this case.
                if (name == null) {
                    continue;
                }
                else if (name == MobilePage.ViewStateID) {
                    collection.Add(MobilePage.ViewStateID, queryString.Get(i));
                    isPostBack = true;
                }
                else if (name == Constants.EventSourceID) {
                    collection.Add(postEventSourceID, queryString.Get(i));
                    isPostBack = true;
                }
                else if (name == Constants.EventArgumentID) {
                    collection.Add(postEventArgumentID, queryString.Get(i));
                }
                else if (Constants.UniqueFilePathSuffixVariable.StartsWith(name, StringComparison.Ordinal)) {
                    // At this point we know that the rest of them is
                    // the custom query string text, so we are done.
                    break;
                }
                else {
                    AddValues(queryString, name, collection);
                }
            }

            if (collection.Count == 0 || !isPostBack) {
                // Returning null to indicate this is not a postback
                return null;
            }
            else {
                return collection;
            }
        }

        private void ConditionalRenderLinkElement (XhtmlMobileTextWriter writer) {
            if (DoesDeviceRequireCssSuppression()) {
                return;
            }

            String cssLocation = (String) Page.ActiveForm.CustomAttributes[XhtmlConstants.StyleSheetLocationCustomAttribute];
            if (cssLocation != null &&
                cssLocation.Length != 0) {
                writer.WriteBeginTag ("link");
                writer.WriteAttribute ("type", "text/css");
                writer.WriteAttribute ("rel", "stylesheet");
                writer.WriteAttribute("href", cssLocation, true);
                writer.WriteLine("/>");
            }
            else if (!writer.IsStyleSheetEmpty () && CssLocation!=StyleSheetLocation.Internal) {
                writer.WriteLine ();
                writer.WriteBeginTag ("link");
                writer.WriteAttribute ("type", "text/css");
                writer.WriteAttribute ("rel", "stylesheet");
                String queryStringValue = GetCssQueryStringValue(writer);
                writer.Write(" href=\"" + XhtmlConstants.CssMappedFileName + "?" + XhtmlConstants.CssQueryStringName + "=" + queryStringValue + "\"/>");
                writer.WriteLine();
            }
        }

        private void ConditionalRenderStyleElement (XhtmlMobileTextWriter writer) {
            if (!writer.IsStyleSheetEmpty () && CssLocation == StyleSheetLocation.Internal) {
                bool requiresComments = (String)Device["requiresCommentInStyleElement"] == "true";
                writer.WriteLine();
                writer.WriteBeginTag("style");
                writer.Write(" type=\"text/css\">");
                writer.WriteLine();
                if (requiresComments) {
                    writer.WriteLine("<!--");
                }
                writer.Write(writer.GetStyles());
                if (requiresComments) {
                    writer.WriteLine("-->");
                }
                writer.WriteEndTag("style");
                writer.WriteLine(); 
            }
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.CreateTextWriter"]/*' />
        public virtual HtmlTextWriter CreateTextWriter( TextWriter writer) {
            return new XhtmlMobileTextWriter (writer, Device);
        }

        // Similar to CHTML.
        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.DeterminePostBackMode"]/*' />
        public virtual NameValueCollection DeterminePostBackMode(
            HttpRequest request,
            String postEventSourceID,
            String postEventArgumentID,
            NameValueCollection baseCollection) {

            if (baseCollection != null && baseCollection[EventSourceKey] == XhtmlConstants.PostedFromOtherFile) {
                return null;
            }
            else if (request == null) {
                return baseCollection;
            }
            else if (String.Compare(request.HttpMethod, "POST", StringComparison.OrdinalIgnoreCase) == 0) {
                return CollectionFromForm(request.Form,
                    postEventSourceID,
                    postEventArgumentID);
            }
            else if (request.QueryString.Count == 0) {
                return baseCollection;
            }
            else {
                return CollectionFromQueryString(request.QueryString,
                    postEventSourceID,
                    postEventArgumentID);
            }
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.DeviceQualifies"]/*' />
        public static bool DeviceQualifies(HttpContext context) {
            String type = ((MobileCapabilities)context.Request.Browser).PreferredRenderingType;
            return String.Equals(type, "xhtml-basic", StringComparison.OrdinalIgnoreCase) || 
                String.Equals(type, "xhtml-mp", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(type, "wml20", StringComparison.OrdinalIgnoreCase);
        }

        private bool DoesDeviceRequireCssSuppression() {
            return(String)Device[XhtmlConstants.RequiresXhtmlCssSuppression] == "true";
        }

        private String GetCssQueryStringValue(XhtmlMobileTextWriter writer) {
            if (CssLocation == StyleSheetLocation.ApplicationCache) {
                // Initialize the cache key
                writer.SetCacheKey(Page.Cache);                
                return writer.CacheKey;
            }
            else if (CssLocation == StyleSheetLocation.SessionState) {
                writer.SetSessionKey(Page.Session);
                return writer.SessionKey;
            }
            Debug.Assert (StyleSheetLocationAttributeValue != null);
            return StyleSheetLocationAttributeValue;        
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.HandleError"]/*' />
        public virtual bool HandleError (Exception e, HtmlTextWriter writer) {
            return false;
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.HandlePagePostBackEvent"]/*' />
        public virtual bool HandlePagePostBackEvent (string eventSource, string eventArgument) {
            return false;
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.InitWriterState"]/*' />
        protected virtual void InitWriterState(XhtmlMobileTextWriter writer) {
            writer.UseDivsForBreaks = (String)Device[XhtmlConstants.BreaksOnInlineElements] == "true";
            writer.SuppressNewLine = (String)Device[XhtmlConstants.RequiresNewLineSuppression] == "true";
            writer.SupportsNoWrapStyle = (String)Device[XhtmlConstants.SupportsNoWrapStyle] != "false";
        }
        
        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.OnPreRender"]/*' />
        public override void OnPreRender(EventArgs e) {
            if (Page.ActiveForm.Paginate && Page.ActiveForm.Action.Length > 0) {
                Page.ActiveForm.Paginate = false;
            }
            base.OnPreRender(e);
        }
        
        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.Render"]/*' />
        public override void Render (XhtmlMobileTextWriter writer) {
            writer.BeginResponse ();
            if (Page.Request.Browser["requiresPragmaNoCacheHeader"] == "true") {
                Page.Response.AppendHeader("Pragma", "no-cache");
            }
            InitWriterState(writer);          
            writer.BeginCachedRendering ();
            // For consistency with HTML, we render the form style with body tag.
            RenderOpeningBodyElement(writer);
            // Certain WML 2.0 devices require that we write an onevent onenterforward setvar snippet.
            // We cannot know the relevant variables until after the form is rendered, so we mark this
            // position.  The setvar elements will be inserted into the cached rendering here.
            writer.MarkWmlOnEventLocation ();
            Page.ActiveForm.RenderControl(writer);
            RenderClosingBodyElement(writer);
            writer.ClearPendingBreak ();
            writer.EndCachedRendering ();

            // Note: first and third arguments are not used.
            writer.BeginFile (Page.Request.Url.ToString (), Page.Device.PreferredRenderingMime, Page.Response.Charset);
            String supportsXmlDeclaration = Device["supportsXmlDeclaration"];
            // Invariant culture not needed, included for best practices compliance.
            if (supportsXmlDeclaration == null ||
                !String.Equals(supportsXmlDeclaration, "false", StringComparison.OrdinalIgnoreCase)) {
                writer.WriteXmlDeclaration ();
            }
            writer.WriteDoctypeDeclaration(DocumentType);
            // Review: Hard coded xmlns.
            writer.WriteFullBeginTag ("html xmlns=\"http://www.w3.org/1999/xhtml\"");
            writer.WriteLine ();
            writer.WriteFullBeginTag ("head");
            writer.WriteLine ();
            writer.WriteFullBeginTag ("title");
            if (Page.ActiveForm.Title != null) {
                writer.WriteEncodedText(Page.ActiveForm.Title);
            }
            writer.WriteEndTag ("title");
            ConditionalRenderLinkElement (writer);
            ConditionalRenderStyleElement (writer);
            writer.WriteEndTag ("head");
            writer.WriteLine ();
            writer.WriteCachedMarkup (); // includes body tag.
            writer.WriteLine ();
            writer.WriteEndTag ("html");
            writer.EndFile ();
            if (!DoesDeviceRequireCssSuppression()) {
                if (CssLocation == StyleSheetLocation.ApplicationCache && !writer.IsStyleSheetEmpty()) {
                    // Recall that Page.Cache has application scope
                    Page.Cache.Insert(writer.CacheKey, writer.GetStyles (), null, DateTime.MaxValue, _cacheExpirationTime);
                }
                else if (CssLocation == StyleSheetLocation.SessionState && !writer.IsStyleSheetEmpty()) {
                    Page.Session[writer.SessionKey] = writer.GetStyles();
                }
            }

            writer.EndResponse ();
        }

        private void RenderClosingBodyElement(XhtmlMobileTextWriter writer) {
            Style formStyle = ((ControlAdapter)Page.ActiveForm.Adapter).Style;
            if (CssLocation == StyleSheetLocation.PhysicalFile) {
                writer.WriteEndTag("body");
                if (_pushedCssClassForBody) {
                    writer.PopPhysicalCssClass();
                }
            }
            else if ((String)Device[XhtmlConstants.RequiresXhtmlCssSuppression] != "true" &&
                (String)Device[XhtmlConstants.SupportsBodyClassAttribute] != "false") {
                writer.ExitStyle(formStyle); // writes the closing body element.
            }
            else {
                writer.WriteEndTag ("body");
            }
        }

        private void RenderHiddenVariablesInUrl(XhtmlMobileTextWriter writer) {
            if (Page.HasHiddenVariables()) {
                String hiddenVariablePrefix = MobilePage.HiddenVariablePrefix;
                foreach (DictionaryEntry entry in Page.HiddenVariables) {
                    writer.Write("&amp;");
                    writer.WriteUrlParameter(hiddenVariablePrefix + (String)entry.Key,
                        (String)entry.Value);
                }
            }
        }

        private void RenderOpeningBodyElement(XhtmlMobileTextWriter writer) {
            Form activeForm = Page.ActiveForm;
            Style formStyle = ((ControlAdapter)activeForm.Adapter).Style;
            if (CssLocation == StyleSheetLocation.PhysicalFile) {
                String cssClass = (String) activeForm.CustomAttributes[XhtmlConstants.CssClassCustomAttribute];
                writer.WriteBeginTag("body");
                if (cssClass != null  && (String)Device["supportsBodyClassAttribute"] != "false") {
                    writer.WriteAttribute("class", cssClass, true /* encode */);
                    writer.PushPhysicalCssClass(cssClass);
                    _pushedCssClassForBody = true;
                }
                writer.Write(">");
            }
            else if ((String)Device[XhtmlConstants.RequiresXhtmlCssSuppression] != "true" &&
                (String)Device[XhtmlConstants.SupportsBodyClassAttribute] != "false") {
                writer.EnterStyle(formStyle, "body");
            }
            else {
                writer.WriteFullBeginTag("body");    
                if ((String)Device[XhtmlConstants.RequiresXhtmlCssSuppression] != "true" &&
                    (String)Device[XhtmlConstants.SupportsBodyClassAttribute] == "false") {
                    writer.SetBodyStyle(formStyle);
                }
            }
        }

        /// <include file='doc\XhtmlBasicPageAdapter.uex' path='docs/doc[@for="XhtmlPageAdapter.RenderUrlPostBackEvent"]/*' />
        public virtual void RenderUrlPostBackEvent (XhtmlMobileTextWriter writer,
            String target, 
            String argument) {

            String amp = (String)Device[XhtmlConstants.SupportsUrlAttributeEncoding] == "false"  ? "&" : "&amp;";
            
            if ((String)Device["requiresAbsolutePostbackUrl"] == "true") {
                writer.WriteEncodedUrl(Page.AbsoluteFilePath);
            }
            else {
                writer.WriteEncodedUrl(Page.RelativeFilePath);
            }
            writer.Write ("?");

            // Encode ViewStateID=.....&__ET=controlid&__EA=value in URL
            // Note: the encoding needs to be agreed with the page
            // adapter which handles the post back info
            String pageState = Page.ClientViewState;
            if (pageState != null) {
                writer.WriteUrlParameter (MobilePage.ViewStateID, pageState);
                writer.Write (amp);
            }
            writer.WriteUrlParameter (EventSourceKey, target);
            writer.Write (amp);
            writer.WriteUrlParameter (EventArgumentKey, argument);
            RenderHiddenVariablesInUrl (writer);

            // Unique file path suffix is used for identify if query
            // string text is present.  Corresponding code needs to agree
            // on this.  Even if the query string is empty, we still need
            // to output the suffix to indicate this. (this corresponds
            // to the code that handles the postback)
            writer.Write(amp);
            writer.Write(Constants.UniqueFilePathSuffixVariable);

            String queryStringText = PreprocessQueryString(Page.QueryStringText);

            if (queryStringText != null && queryStringText.Length > 0) {
                writer.Write (amp);
                if ((String)Device[XhtmlConstants.SupportsUrlAttributeEncoding] != "false") {
                    writer.WriteEncodedAttributeValue(queryStringText);
                }
                else {
                    writer.Write (queryStringText);
                }
            }
        }
    }
}