using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Drawing;
using System.Windows.Forms;

namespace ST.Library.UI.STTextBox
{
    public class STTextBoxGDIPRender : ISTTextBoxRender, IDisposable
    {
        public bool ShowInVisableChar { get; set; }
        public Color InVisableCharColor { get; set; }

        public float XDPIZoom { get; private set; }
        public float YDPIZoom { get; private set; }
        public int TabSize { get; private set; }
        public int SpaceWidth { get; private set; }
        public int FontHeight { get; private set; }
        public bool IsMonospaced { get; private set; }

        private Font m_ft_normal;
        private Font m_ft_bold;
        private Font m_ft_italic;
        private Font m_ft_bold_italic;
        private StringFormat m_sf;
        private SolidBrush m_brush;
        private Graphics m_g_onpaint;
        private Graphics m_g_private;
        private float m_italic_width;

        private Rectangle m_rect_temp;
        private Rectangle m_rect_line;
        private Dictionary<string, int> m_dic_width_cache;


        private Control m_ctrl;
        private int m_nCounter;

        public STTextBoxGDIPRender() {
            this.TabSize = 4;
            m_dic_width_cache = new Dictionary<string, int>();
            m_sf = new StringFormat(StringFormat.GenericTypographic);
            m_sf.FormatFlags |= StringFormatFlags.MeasureTrailingSpaces;
            m_sf.Alignment = StringAlignment.Center;
            m_sf.LineAlignment = StringAlignment.Center;
            m_brush = new SolidBrush(Color.Black);
            this.InVisableCharColor = Color.FromArgb(50, Color.Magenta);
            this.ShowInVisableChar = false;
        }

        public void BindControl(Control ctrl) {
            if (ctrl == null) {
                throw new ArgumentNullException("ctrl");
            }
            m_ctrl = ctrl;
            m_ctrl.FontChanged += m_ctrl_FontChanged;
            this.InitData(m_ctrl.Font);
        }

        public void UnbindControl() {
            m_ctrl.FontChanged -= m_ctrl_FontChanged;
        }

        public void OnBeginPaint(Graphics g) {
            //m_g_onpaint = g;
            //m_b_onpaint = true;
            this.XDPIZoom = g.DpiX / 96;
            this.YDPIZoom = g.DpiY / 96;
            if (this.XDPIZoom < 1) this.XDPIZoom = 1;
            if (this.YDPIZoom < 1) this.YDPIZoom = 1;
            m_g_onpaint = g;
        }

        public void OnEndPaint(Graphics g) {
            m_g_onpaint = null;
        }

        public void BeginPaint() {
            if (m_nCounter == 0) {
                m_g_private = m_ctrl.CreateGraphics();
            }
            var g = m_g_private;
            this.XDPIZoom = g.DpiX / 96;
            this.YDPIZoom = g.DpiY / 96;
            m_nCounter++;
        }

        public void EndPaint() {
            if (--m_nCounter == 0) {
                m_g_private.Dispose();
                m_g_private = null;
            }
        }

        public int SetTabSize(int nSize) {
            if (nSize < 0) {
                throw new ArgumentOutOfRangeException("nSize", "The value must be more than 0");
            }
            if (nSize > 10) {
                throw new ArgumentOutOfRangeException("nSize", "The value must be less than 10");
            }
            int nRet = this.TabSize;
            this.TabSize = nSize;
            return nRet;
        }

        public int GetTabSize() {
            return this.TabSize;
        }

        public int GetTabWidth(int nLeftWidth) {
            return (int)Math.Round(this.GetSpaceWidth() * this.GetTabSpaceCount(nLeftWidth, this.TabSize));
        }

        public int GetFontHeight() { return this.FontHeight; }

        public int GetSpaceWidth() { return this.SpaceWidth; }

        public float GetTabSpaceCount(int nLeftWidth, int nTabSize) {
            if (nTabSize < 0) {
                throw new ArgumentOutOfRangeException("nTabSize", "The value must be more than 0");
            }
            int nSpaceWidth = this.GetSpaceWidth();
            if (nTabSize == 1) {      //If the TAB size just one SPACE,return the SPACE width;
                return nSpaceWidth;
            }
            int nTabFullWidth = nSpaceWidth * nTabSize;
            float nSpaceCount = (nTabFullWidth - (nLeftWidth % nTabFullWidth)) / (float)nSpaceWidth;
            return nSpaceCount < 1 ? nSpaceCount + nTabSize : nSpaceCount;
        }

        public int GetStringWidth(string strText, TextStyle style, int nLeftWidth) {
            return this.GetStringWidth(strText, style, nLeftWidth, true);
        }

        public int GetStringWidth(string strText, TextStyle style, int nLeftWidth, bool bCache) {
            if (string.IsNullOrEmpty(strText) || m_ft_normal == null) {
                return 0;
            }
            Graphics g = this.GetGraphics();
            string strKey = this.GetFontFlag(style);
            Font ft = this.GetFontFromFlag(strKey);
            strKey += ":" + strText;
            if (m_dic_width_cache.ContainsKey(strKey)) {
                return m_dic_width_cache[strKey];
            }
            if (strText == "\t") {
                return this.GetTabWidth(nLeftWidth);
            }
            float fWidth = g.MeasureString(strText, ft, 10000, m_sf).Width;
            if ((ft.Style & FontStyle.Italic) == FontStyle.Italic) {
                fWidth += m_italic_width;
            }
            int nWidth = (int)Math.Ceiling(fWidth);
            if (bCache) {
                m_dic_width_cache.Add(strKey, nWidth);
            }
            return nWidth;
        }

        public void DrawString(string strText, Font ft, Color color, Rectangle rect, StringFormat sf) {
            m_brush.Color = color;
            this.GetGraphics().DrawString(strText, ft, m_brush, rect, sf);
        }

        public void DrawString(string strText, TextStyle style, Rectangle rect) {
            Graphics g = this.GetGraphics();
            m_rect_line.X = rect.X;
            m_rect_line.Width = rect.Width;
            if (style.BackColor.A > 0) {
                m_brush.Color = style.BackColor;
                g.FillRectangle(m_brush, rect);
            }
            if ((style.FontStyle & FontStyle.Underline) == FontStyle.Underline && style.UnderLineColor.A > 0) {
                m_rect_line.Y = rect.Bottom - m_rect_line.Height;
                m_brush.Color = style.UnderLineColor;
                g.FillRectangle(m_brush, m_rect_line);
            }
            if (style.ForeColor.A > 0) {
                m_brush.Color = style.ForeColor;
                switch (strText[0]) {
                    case ' ':
                        if (this.ShowInVisableChar) this.OnDrawSpaceChar(rect);
                        return;
                    case '\t':
                        if (this.ShowInVisableChar) this.OnDrawTabChar(rect);
                        return;
                    case '\r':
                    case '\n':
                        if (this.ShowInVisableChar) this.OnDrawNewLineChar(rect);
                        return;
                    default:
                        g.DrawString(strText, this.GetFontFromFlag(this.GetFontFlag(style)), m_brush, rect, m_sf);
                        break;
                }
            }
            if ((style.FontStyle & FontStyle.Strikeout) == FontStyle.Strikeout && style.StrikeOutColor.A > 0) {
                m_rect_line.Y = rect.Y + rect.Height / 2;
                m_brush.Color = style.StrikeOutColor;
                g.FillRectangle(m_brush, m_rect_line);
            }
        }

        public void DrawImage(Image image, Rectangle rect) {
            this.GetGraphics().DrawImage(image, rect);
        }

        public void FillRectangle(Color backColor, Rectangle rect) {
            m_brush.Color = backColor;
            this.GetGraphics().FillRectangle(m_brush, rect);
        }

        public void FillRectangle(Color backColor, int nX, int nY, int nWidth, int nHeight) {
            m_brush.Color = backColor;
            this.GetGraphics().FillRectangle(m_brush, nX, nY, nWidth, nHeight);
        }

        public void SetClip(Rectangle rect) {
            this.GetGraphics().SetClip(rect);
        }

        public void ResetClip() {
            this.GetGraphics().ResetClip();
        }

        // [protected] ==========================================

        protected virtual void OnDrawNewLineChar(Rectangle rect) {
            Graphics g = this.GetGraphics();
            m_brush.Color = this.InVisableCharColor;
            m_rect_temp.X = rect.X + (int)Math.Round(this.XDPIZoom);
            m_rect_temp.Y = rect.Y + rect.Height / 2 - (int)Math.Round(this.YDPIZoom);
            m_rect_temp.Height = (int)Math.Round(this.YDPIZoom * 3);
            m_rect_temp.Width = (int)Math.Round(this.XDPIZoom);
            g.FillRectangle(m_brush, m_rect_temp);      // draw -> |
            m_rect_temp.X += (int)Math.Round(this.XDPIZoom);
            m_rect_temp.Y += (int)Math.Round(this.YDPIZoom);
            m_rect_temp.Height = (int)Math.Round(this.YDPIZoom);
            m_rect_temp.Width = rect.Width - (int)Math.Round(this.XDPIZoom * 4);
            g.FillRectangle(m_brush, m_rect_temp);      // draw -> -
            m_rect_temp.X = m_rect_temp.Right;
            m_rect_temp.Width = (int)Math.Round(this.XDPIZoom);
            m_rect_temp.Height = (int)Math.Round(this.YDPIZoom * 5);
            m_rect_temp.Y -= (int)Math.Round(this.YDPIZoom * 4);
            g.FillRectangle(m_brush, m_rect_temp);      // draw -> |
        }

        protected virtual void OnDrawTabChar(Rectangle rect) {
            Graphics g = this.GetGraphics();
            m_brush.Color = this.InVisableCharColor;
            m_rect_temp.Height = (int)Math.Round(this.YDPIZoom * 3);
            m_rect_temp.Width = (int)Math.Round(this.XDPIZoom);// *2;
            m_rect_temp.Y = rect.Y + rect.Height / 2 - (int)Math.Round(this.YDPIZoom);
            m_rect_temp.X = rect.X + (int)Math.Round(this.XDPIZoom);
            g.FillRectangle(m_brush, m_rect_temp);
            m_rect_temp.X = rect.Right - (int)Math.Round(this.XDPIZoom * 2);
            g.FillRectangle(m_brush, m_rect_temp);
            m_rect_temp.Y += (int)Math.Round(this.YDPIZoom);
            m_rect_temp.Height = (int)Math.Round(this.YDPIZoom);
            m_rect_temp.X = rect.X + (int)Math.Round(this.XDPIZoom * 2);
            m_rect_temp.Width = rect.Width - (int)Math.Round(this.XDPIZoom * 4);
            g.FillRectangle(m_brush, m_rect_temp);
        }

        protected virtual void OnDrawSpaceChar(Rectangle rect) {
            Graphics g = this.GetGraphics();
            m_brush.Color = this.InVisableCharColor;
            m_rect_temp.Height = (int)Math.Round(this.YDPIZoom);
            m_rect_temp.Width = rect.Width - (int)Math.Round(this.XDPIZoom * 2);// *2;
            m_rect_temp.X = rect.X + (int)Math.Round(this.XDPIZoom);
            m_rect_temp.Y = rect.Bottom - (int)Math.Round(this.YDPIZoom * 2);
            g.FillRectangle(m_brush, m_rect_temp);
            m_rect_temp.Width = m_rect_temp.Height;
            m_rect_temp.X = rect.X + m_rect_temp.Width;
            m_rect_temp.Y -= m_rect_temp.Height;
            g.FillRectangle(m_brush, m_rect_temp);
            m_rect_temp.X = rect.Right - (int)Math.Round(this.XDPIZoom * 2);
            g.FillRectangle(m_brush, m_rect_temp);
        }

        // [private] ============================================

        private void m_ctrl_FontChanged(object sender, EventArgs e) {
            this.InitData(m_ctrl.Font);
        }

        private void InitData(Font ft) {
            if (m_ft_normal == ft) {
                return;
            }
            this.BeginPaint();
            m_rect_line.Height = (int)Math.Round(this.YDPIZoom * 1);
            if (m_rect_line.Height == 0) m_rect_line.Height = 1;
            m_ft_normal = ft;
            if (m_ft_bold != null) m_ft_bold.Dispose();
            m_ft_bold = new Font(ft, FontStyle.Bold);
            if (m_ft_italic != null) m_ft_italic.Dispose();
            m_ft_italic = new Font(ft, FontStyle.Italic);
            if (m_ft_bold_italic != null) m_ft_bold_italic.Dispose();
            m_ft_bold_italic = new Font(ft, FontStyle.Bold | FontStyle.Italic);
            this.FontHeight = ft.Height;
            m_dic_width_cache.Clear();
            //SPACE are used to calculate TAB width.
            int nWidth = this.GetStringWidth(" ", TextStyle.Empty, 0);
            m_dic_width_cache.Add(" ", nWidth);
            m_dic_width_cache.Add("\r", nWidth);
            m_dic_width_cache.Add("\n", nWidth);
            m_dic_width_cache.Add("\r\n", nWidth);
            this.SpaceWidth = nWidth;
            this.IsMonospaced = this.GetStringWidth("i", TextStyle.Empty, 0) == this.GetStringWidth("W", TextStyle.Empty, 0);
            if (!this.IsMonospaced) {
                m_italic_width = (float)(this.FontHeight * Math.Tan(12 * Math.PI / 180));
            } else {
                m_italic_width = 0;
            }
            this.EndPaint();
        }

        private Graphics GetGraphics() {
            if (m_g_onpaint != null) return m_g_onpaint;
            if (m_g_private != null) return m_g_private;
            throw new InvalidOperationException("The Graphics is null, please call BeginPaint() to init it.");
        }

        private string GetFontFlag(TextStyle style) {
            string strKey = "N";
            if ((style.FontStyle & FontStyle.Bold) == FontStyle.Bold) {
                strKey += "B";
            }
            if ((style.FontStyle & FontStyle.Italic) == FontStyle.Italic) {
                strKey += "I";
            }
            return strKey;
        }

        private Font GetFontFromFlag(string strFlag) {
            switch (strFlag) {
                case "NBI":
                    return m_ft_bold_italic;
                case "NB":
                    return m_ft_bold;
                case "NI":
                    return m_ft_italic;
            }
            return m_ft_normal;
        }

        // [interface] ==========================================

        public void Dispose() {
            if (m_g_private != null) m_g_private.Dispose();
            if (m_ft_bold != null) m_ft_bold.Dispose();
            if (m_ft_italic != null) m_ft_italic.Dispose();
            if (m_ft_bold_italic != null) m_ft_bold_italic.Dispose();
            if (m_brush != null) m_brush.Dispose();
            if (m_sf != null) m_sf.Dispose();
            if (m_dic_width_cache != null) m_dic_width_cache.Clear();
        }
    }
}