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

namespace System.Web.UI {
    using System;
    using System.Collections;
    using System.IO;
    using System.Text;
    using System.Globalization;
    using System.Web.UI.WebControls;  // 
    using System.Security.Permissions;
    using System.Web.Util;


    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    public class Html32TextWriter : HtmlTextWriter {

        private const int NOTHING = 0x0000;
        private const int FONT_AROUND_CONTENT = 0x0001;
        private const int FONT_AROUND_TAG = 0x0002;
        private const int TABLE_ATTRIBUTES = 0x0004;
        private const int TABLE_AROUND_CONTENT = 0x0008;
        private const int FONT_PROPAGATE = 0x0010;
        private const int FONT_CONSUME = 0x0020;
        private const int SUPPORTS_HEIGHT_WIDTH = 0x0040;
        private const int SUPPORTS_BORDER = 0x0080;
        private const int SUPPORTS_NOWRAP = 0x0100;

        private StringBuilder _afterContent;
        private StringBuilder _afterTag;
        private StringBuilder _beforeContent;
        private StringBuilder _beforeTag;
        private string _fontColor;
        private string _fontFace;
        private string _fontSize;
        //

        private Stack _fontStack;
        private bool _shouldPerformDivTableSubstitution;
        private bool _renderFontTag;
        private bool _supportsBold = true;
        private bool _supportsItalic = true;
        private int _tagSupports;


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public Html32TextWriter(TextWriter writer) : this(writer, DefaultTabString) {
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public Html32TextWriter(TextWriter writer, string tabString) : base(writer, tabString) {
            // The initial capacities should be set up such that they are at least twice what
            // we expect for the maximum content we're going to stuff in into the builder.
            // This gives the best perf when using the Length property to reset the builder.

            _beforeTag = new StringBuilder(256);
            _beforeContent = new StringBuilder(256);
            _afterContent = new StringBuilder(128);
            _afterTag = new StringBuilder(128);
        }


        /// <internalonly/>
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected Stack FontStack {
            get {
                if (_fontStack == null) {
                    _fontStack = new Stack(3);
                }
                return _fontStack;
            }
        }

        internal override bool RenderDivAroundHiddenInputs {
            get {
                return false;
            }
        }

        public bool ShouldPerformDivTableSubstitution {
            get {
                return _shouldPerformDivTableSubstitution;
            }
            set {
                _shouldPerformDivTableSubstitution = value;
            }
        }


        /// <devdoc>
        /// <para>[To be supplied.]</para>
        /// </devdoc>
        public bool SupportsBold {
            get {
                return _supportsBold;
            }
            set {
                _supportsBold = value;
            }
        }


        /// <devdoc>
        /// <para>[To be supplied.]</para>
        /// </devdoc>
        public bool SupportsItalic {
            get {
                return _supportsItalic;
            }
            set {
                _supportsItalic = value;
            }
        }

        private void AppendFontTag(StringBuilder sbBegin,StringBuilder sbEnd) {
            AppendFontTag(_fontFace, _fontColor, _fontSize, sbBegin, sbEnd);
        }

        private void AppendFontTag(string fontFace, string fontColor, string fontSize, StringBuilder sbBegin,StringBuilder sbEnd) {
            // append font begin tag
            sbBegin.Append(TagLeftChar);
            sbBegin.Append("font");
            if (fontFace != null) {
                sbBegin.Append(" face");
                sbBegin.Append(EqualsDoubleQuoteString);
                sbBegin.Append(fontFace);
                sbBegin.Append(DoubleQuoteChar);
            }
            if (fontColor != null) {
                sbBegin.Append(" color=");
                sbBegin.Append(DoubleQuoteChar);
                sbBegin.Append(fontColor);
                sbBegin.Append(DoubleQuoteChar);
            }
            if (fontSize != null) {
                sbBegin.Append(" size=");
                sbBegin.Append(DoubleQuoteChar);
                sbBegin.Append(fontSize);
                sbBegin.Append(DoubleQuoteChar);
            }
            sbBegin.Append(TagRightChar);

            // insert font end tag
            sbEnd.Insert(0,EndTagLeftChars + "font" + TagRightChar);
        }

        private void AppendOtherTag(string tag) {
            if (Supports(FONT_AROUND_CONTENT))
                AppendOtherTag(tag,_beforeContent,_afterContent);
            else
                AppendOtherTag(tag,_beforeTag,_afterTag);
        }

        private void AppendOtherTag(string tag,StringBuilder sbBegin,StringBuilder sbEnd) {
            // append begin tag
            sbBegin.Append(TagLeftChar);
            sbBegin.Append(tag);
            sbBegin.Append(TagRightChar);

            // insert end tag
            sbEnd.Insert(0,EndTagLeftChars + tag + TagRightChar);
        }

        private void AppendOtherTag(string tag, object[] attribs, StringBuilder sbBegin, StringBuilder sbEnd) {
            // append begin tag
            sbBegin.Append(TagLeftChar);
            sbBegin.Append(tag);
            for (int i = 0; i < attribs.Length; i++) {
                sbBegin.Append(SpaceChar);
                sbBegin.Append(((string[])attribs[i])[0]);
                sbBegin.Append(EqualsDoubleQuoteString);
                sbBegin.Append(((string[])attribs[i])[1]);
                sbBegin.Append(DoubleQuoteChar);
            }
            sbBegin.Append(TagRightChar);

            // insert end tag
            sbEnd.Insert(0,EndTagLeftChars + tag + TagRightChar);
        }

        private void ConsumeFont(StringBuilder sbBegin, StringBuilder sbEnd) {
            
            if (FontStack.Count > 0) {

                string fontFace = null;
                string fontColor = null;
                string fontSize = null;
                bool underline = false;
                bool italic = false;
                bool bold = false;
                bool strikeout = false;

                IEnumerator e = FontStack.GetEnumerator();
                while(e.MoveNext()) {
                    FontStackItem fontInfo = (FontStackItem) e.Current;
                    if (fontFace == null) {
                        fontFace = fontInfo.name;
                    }
                    if (fontColor == null) {
                        fontColor = fontInfo.color;
                    }
                    if (fontSize == null) {
                        fontSize = fontInfo.size;
                    }
                    if (!underline) {
                        underline = fontInfo.underline;
                    }
                    if (!italic) {
                        italic = fontInfo.italic;
                    }
                    if (!bold) {
                        bold = fontInfo.bold;
                    }
                    if (!strikeout) {
                        strikeout = fontInfo.strikeout;
                    }
                }
                
                if ((fontFace != null) || (fontColor != null) || (fontSize != null)) {
                    AppendFontTag(fontFace, fontColor, fontSize, sbBegin, sbEnd);
                }
                if (underline) {
                    AppendOtherTag("u", sbBegin, sbEnd);
                }
                if (italic && SupportsItalic) {
                    AppendOtherTag("i", sbBegin, sbEnd);
                }
                if (bold && SupportsBold) {
                    AppendOtherTag("b", sbBegin, sbEnd);
                }
                if (strikeout) {
                    AppendOtherTag("strike", sbBegin, sbEnd);                    
                }

            }
        }

        private string ConvertToHtmlFontSize(string value) {
            FontUnit fu = new FontUnit(value, CultureInfo.InvariantCulture);
            if ((int)(fu.Type) > 3)
                return((int)(fu.Type)-3).ToString(CultureInfo.InvariantCulture);

            if (fu.Type == FontSize.AsUnit) {
                if (fu.Unit.Type == UnitType.Point) {
                    if (fu.Unit.Value <= 8)
                        return "1";
                    else if (fu.Unit.Value <= 10)
                        return "2";
                    else if (fu.Unit.Value <= 12)
                        return "3";
                    else if (fu.Unit.Value <= 14)
                        return "4";
                    else if (fu.Unit.Value <= 18)
                        return "5";
                    else if (fu.Unit.Value <= 24)
                        return "6";
                    else
                        return "7";
                }
            }

            return null;
        }

        private string ConvertToHtmlSize(string value) {
            Unit u = new Unit(value, CultureInfo.InvariantCulture);
            if (u.Type == UnitType.Pixel) {
                return u.Value.ToString(CultureInfo.InvariantCulture);
            }
            if (u.Type == UnitType.Percentage) {
                return value;
            }
            return null;
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected override bool OnStyleAttributeRender(string name,string value, HtmlTextWriterStyle key) {

            string s;
            if (Supports(FONT_AROUND_CONTENT)) {
                // tag supports downlevel fonts
                switch (key) {
                    case HtmlTextWriterStyle.FontFamily:
                        _fontFace = value;
                        _renderFontTag = true;
                        break;
                    case HtmlTextWriterStyle.Color:
                        _fontColor = value;
                        _renderFontTag = true;
                        break;
                    case HtmlTextWriterStyle.FontSize:
                        _fontSize = ConvertToHtmlFontSize(value);
                        if (_fontSize != null)
                            _renderFontTag = true;
                        break;
                    case HtmlTextWriterStyle.FontWeight:
                        if (StringUtil.EqualsIgnoreCase(value, "bold") && SupportsBold) {
                            AppendOtherTag("b");
                        }
                        break;
                    case HtmlTextWriterStyle.FontStyle:
                        if (!StringUtil.EqualsIgnoreCase(value, "normal") && SupportsItalic) {
                            AppendOtherTag("i");
                        }
                        break;
                    case HtmlTextWriterStyle.TextDecoration:
                        s = value.ToLower(CultureInfo.InvariantCulture);
                        if (s.IndexOf("underline", StringComparison.Ordinal) != -1) {
                            AppendOtherTag("u");
                        }
                        if (s.IndexOf("line-through", StringComparison.Ordinal) != -1) {
                            AppendOtherTag("strike");
                        }
                        break;
                }
            }
            else if (Supports(FONT_PROPAGATE)) {
                FontStackItem font = (FontStackItem)FontStack.Peek();

                switch (key) {
                    case HtmlTextWriterStyle.FontFamily:
                        font.name = value;
                        break;
                    case HtmlTextWriterStyle.Color:
                        font.color = value;
                        break;
                    case HtmlTextWriterStyle.FontSize:
                        font.size = ConvertToHtmlFontSize(value);
                        break;
                    case HtmlTextWriterStyle.FontWeight:
                        if (StringUtil.EqualsIgnoreCase(value, "bold")) {
                            font.bold = true;
                        }
                        break;
                    case HtmlTextWriterStyle.FontStyle:
                        if (!StringUtil.EqualsIgnoreCase(value, "normal")) {
                            font.italic = true;
                        }
                        break;
                    case HtmlTextWriterStyle.TextDecoration:
                        s = value.ToLower(CultureInfo.InvariantCulture);
                        if (s.IndexOf("underline", StringComparison.Ordinal) != -1) {
                            font.underline = true;
                        }
                        if (s.IndexOf("line-through", StringComparison.Ordinal) != -1) {
                            font.strikeout = true;
                        }
                        break;
                }
            }

            if (Supports(SUPPORTS_BORDER) && key == HtmlTextWriterStyle.BorderWidth) {
                s = ConvertToHtmlSize(value);
                if (s != null)
                    AddAttribute(HtmlTextWriterAttribute.Border,s);
            }

            if (Supports(SUPPORTS_NOWRAP) && key == HtmlTextWriterStyle.WhiteSpace) {
                AddAttribute(HtmlTextWriterAttribute.Nowrap, value);
            }

            if (Supports(SUPPORTS_HEIGHT_WIDTH)) {
                switch (key) {
                    case HtmlTextWriterStyle.Height :
                        s = ConvertToHtmlSize(value);
                        if (s != null)
                            AddAttribute(HtmlTextWriterAttribute.Height,s);
                        break;
                    case HtmlTextWriterStyle.Width :
                        s = ConvertToHtmlSize(value);
                        if (s != null)
                            AddAttribute(HtmlTextWriterAttribute.Width,s);
                        break;
                }
            }

            if (Supports(TABLE_ATTRIBUTES) || Supports(TABLE_AROUND_CONTENT)) {
                // tag supports downlevel table attributes
                switch (key) {
                    case HtmlTextWriterStyle.BorderColor:
                        switch (TagKey) {
                            case HtmlTextWriterTag.Div:
                                if (ShouldPerformDivTableSubstitution) {
                                    AddAttribute(HtmlTextWriterAttribute.Bordercolor, value);
                                }
                                break;
                        }
                        break;
                    case HtmlTextWriterStyle.BackgroundColor :
                        switch (TagKey) {
                            case HtmlTextWriterTag.Table :
                            case HtmlTextWriterTag.Tr :
                            case HtmlTextWriterTag.Td :
                            case HtmlTextWriterTag.Th :
                            case HtmlTextWriterTag.Body :
                                AddAttribute(HtmlTextWriterAttribute.Bgcolor,value);
                                break;
                                // div->table substitution.
                            case HtmlTextWriterTag.Div:
                                if (ShouldPerformDivTableSubstitution) {
                                    AddAttribute(HtmlTextWriterAttribute.Bgcolor,value);
                                }
                                break;
                        }
                        break;
                    case HtmlTextWriterStyle.BackgroundImage :
                        switch (TagKey) {
                            case HtmlTextWriterTag.Table :
                            case HtmlTextWriterTag.Td :
                            case HtmlTextWriterTag.Th :
                            case HtmlTextWriterTag.Body :
                                // strip url(...) from value
                                if (StringUtil.StringStartsWith(value, "url("))
                                    value = value.Substring(4,value.Length-5);
                                AddAttribute(HtmlTextWriterAttribute.Background,value);
                                break;
                                // div->table substitution.
                            case HtmlTextWriterTag.Div:
                                if (ShouldPerformDivTableSubstitution) {
                                    if (StringUtil.StringStartsWith(value, "url("))
                                        value = value.Substring(4,value.Length-5);
                                    AddAttribute(HtmlTextWriterAttribute.Background,value);
                                }
                                break;
                        }
                        break;
                }
            }

            switch (key) {
                case HtmlTextWriterStyle.ListStyleType:
                    switch (value) {
                        case "decimal":
                            AddAttribute(HtmlTextWriterAttribute.Type, "1");
                            break;
                        case "lower-alpha":
                            AddAttribute(HtmlTextWriterAttribute.Type, "a");
                            break;
                        case "upper-alpha":
                            AddAttribute(HtmlTextWriterAttribute.Type, "A");
                            break;
                        case "lower-roman":
                            AddAttribute(HtmlTextWriterAttribute.Type, "i");
                            break;
                        case "upper-roman":
                            AddAttribute(HtmlTextWriterAttribute.Type, "I");
                            break;
                        case "disc":
                        case "circle":
                        case "square":
                            AddAttribute(HtmlTextWriterAttribute.Type, value);
                            break;
                        default:
                            AddAttribute(HtmlTextWriterAttribute.Type, "disc");
                            Debug.Assert(false, "Invalid BulletStyle for HTML32.");
                            break;
                    }
                    break;
                case HtmlTextWriterStyle.TextAlign:
                    AddAttribute(HtmlTextWriterAttribute.Align, value);
                    break;
                case HtmlTextWriterStyle.VerticalAlign:
                    AddAttribute(HtmlTextWriterAttribute.Valign, value);
                    break;
                // Netscape 4.72 can properly handle the Display style attribute, so allow it
                // to be rendered.
                case HtmlTextWriterStyle.Display:
                    return true;
            }

            return false;
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected override bool OnTagRender(string name, HtmlTextWriterTag key) {
            // handle any tags that do not work downlevel

            SetTagSupports();
            if (Supports(FONT_PROPAGATE)) {
                FontStack.Push(new FontStackItem());
            }

            // div->table substitution.
            // Make tag look like a table. This must be done after we establish tag support.
            if (key == HtmlTextWriterTag.Div && ShouldPerformDivTableSubstitution) {
                TagKey = HtmlTextWriterTag.Table;
            }

            return base.OnTagRender(name,key);
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected override string GetTagName(HtmlTextWriterTag tagKey) {
            // div->table substitution.
            if (tagKey == HtmlTextWriterTag.Div && ShouldPerformDivTableSubstitution) {
                return "table";
            }
            return base.GetTagName(tagKey);
        }



        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override void RenderBeginTag(HtmlTextWriterTag tagKey) {
            // flush string buffers to build new tag
            _beforeTag.Length = 0;
            _beforeContent.Length = 0;
            _afterContent.Length = 0;
            _afterTag.Length = 0;

            _renderFontTag = false;
            _fontFace = null;
            _fontColor = null;
            _fontSize = null;

            // div->table substitution.
            if (ShouldPerformDivTableSubstitution) {
                if (tagKey == HtmlTextWriterTag.Div) {
                    AppendOtherTag("tr", _beforeContent, _afterContent);

                    string alignment;
                    if (IsAttributeDefined(HtmlTextWriterAttribute.Align, out alignment)) {
                        string[] attribs = new string[] { GetAttributeName(HtmlTextWriterAttribute.Align), alignment};

                        AppendOtherTag("td", new object[]{ attribs}, _beforeContent, _afterContent);
                    }
                    else {
                        AppendOtherTag("td", _beforeContent, _afterContent);
                    }
                    if (!IsAttributeDefined(HtmlTextWriterAttribute.Cellpadding)) {
                        AddAttribute(HtmlTextWriterAttribute.Cellpadding, "0");
                    }
                    if (!IsAttributeDefined(HtmlTextWriterAttribute.Cellspacing)) {
                        AddAttribute(HtmlTextWriterAttribute.Cellspacing, "0");
                    }
                    if (!IsStyleAttributeDefined(HtmlTextWriterStyle.BorderWidth)) {
                        AddAttribute(HtmlTextWriterAttribute.Border, "0");
                    }
                    if (!IsStyleAttributeDefined(HtmlTextWriterStyle.Width)) {
                        AddAttribute(HtmlTextWriterAttribute.Width, "100%");
                    }
                }
            }

            base.RenderBeginTag(tagKey);
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected override string RenderBeforeTag() {
            if (_renderFontTag && Supports(FONT_AROUND_TAG))
                AppendFontTag(_beforeTag,_afterTag);

            if (_beforeTag.Length > 0)
                return(_beforeTag.ToString());

            return base.RenderBeforeTag();
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected override string RenderBeforeContent() {

            if (Supports(FONT_CONSUME)) {
                ConsumeFont(_beforeContent, _afterContent);
            }
            else if (_renderFontTag && Supports(FONT_AROUND_CONTENT)) {
                AppendFontTag(_beforeContent,_afterContent);
            }

            if (_beforeContent.Length > 0)
                return(_beforeContent.ToString());

            return base.RenderBeforeContent();

        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected override string RenderAfterContent() {
            if (_afterContent.Length > 0)
                return(_afterContent.ToString());

            return base.RenderAfterContent();
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected override string RenderAfterTag() {
            if (_afterTag.Length > 0)
                return(_afterTag.ToString());

            return base.RenderAfterTag();
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override void RenderEndTag() {
            base.RenderEndTag();

            SetTagSupports();
            if (Supports(FONT_PROPAGATE)) {
                FontStack.Pop();
            }
        }

        private void SetTagSupports() {
            // determine what downlevel tag supports
            _tagSupports = NOTHING;
            switch (TagKey) {
                case HtmlTextWriterTag.A :
                case HtmlTextWriterTag.Label :
                case HtmlTextWriterTag.P :
                case HtmlTextWriterTag.Span :
                    _tagSupports |= FONT_AROUND_CONTENT;
                    break;
                case HtmlTextWriterTag.Li:
                    _tagSupports |= FONT_AROUND_CONTENT | FONT_CONSUME;
                    break;
                case HtmlTextWriterTag.Div :
                    _tagSupports |= FONT_AROUND_CONTENT | FONT_PROPAGATE;
                    break;
                case HtmlTextWriterTag.Ul:
                case HtmlTextWriterTag.Ol:
                case HtmlTextWriterTag.Table:
                case HtmlTextWriterTag.Tr:
                    _tagSupports |= FONT_PROPAGATE;
                    break;
                case HtmlTextWriterTag.Td :
                case HtmlTextWriterTag.Th :
                    _tagSupports |= FONT_PROPAGATE | FONT_CONSUME;
                    break;
                case HtmlTextWriterTag.Input :
                    _tagSupports |= SUPPORTS_BORDER;
                    break;
            }

            switch (TagKey) {
                // div->table substitution.
                case HtmlTextWriterTag.Div:
                    if (ShouldPerformDivTableSubstitution) {
                        _tagSupports |= SUPPORTS_HEIGHT_WIDTH | SUPPORTS_BORDER;
                    }
                    _tagSupports |= SUPPORTS_NOWRAP;
                    break;
                case HtmlTextWriterTag.Img:
                    _tagSupports |= SUPPORTS_HEIGHT_WIDTH | SUPPORTS_BORDER;
                    break;
                case HtmlTextWriterTag.Table:
                    _tagSupports |= SUPPORTS_HEIGHT_WIDTH;
                    break;
                case HtmlTextWriterTag.Th:
                case HtmlTextWriterTag.Td:
                    _tagSupports |= SUPPORTS_NOWRAP | SUPPORTS_HEIGHT_WIDTH;
                    break;
            }

            //switch (TagKey) {
            //    case HtmlTextWriterTag.INPUT :
            //        _tagSupports |= FONT_AROUND_TAG;
            //        break;
            //}

            switch (TagKey) {
                case HtmlTextWriterTag.Table :
                case HtmlTextWriterTag.Tr :
                case HtmlTextWriterTag.Td :
                case HtmlTextWriterTag.Th :
                case HtmlTextWriterTag.Body :
                    _tagSupports |= TABLE_ATTRIBUTES;
                    break;
            }
            switch (TagKey) {
                // div->table substitution.
                case HtmlTextWriterTag.Div :
                    if (ShouldPerformDivTableSubstitution) {
                        _tagSupports |= TABLE_AROUND_CONTENT;
                    }
                    break;
            }
        }

        private bool Supports(int flag) {
            return(_tagSupports & flag) == flag;
        }



        /// <devdoc>
        ///   Contains information about a font placed on the stack of font information.
        /// </devdoc>
        private sealed class FontStackItem {
            public string name;
            public string color;
            public string size;
            public bool bold;
            public bool italic;
            public bool underline;
            public bool strikeout;
        }
    }
}