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 abstract class TextView : ITextView
    {
        private bool _ShowLineNumber = true;

        public bool ShowLineNumber {
            get { return _ShowLineNumber; }
            set {
                if (value == _ShowLineNumber) return;
                _ShowLineNumber = value;
                if (this.Core == null) return;
                this.OnCalcTextRectangle();
                this.OnCalcScroll(this.Core.Scroll);
                this.SetCaretPostion(this.Core.Caret.IndexOfChar);
                this.Invalidate();
            }
        }

        private Color _HeadBackgroundColor = Color.FromArgb(120, Color.LightGray);

        public Color HeadBackgroundColor {
            get { return _HeadBackgroundColor; }
            set { _HeadBackgroundColor = value; }
        }

        private Color _TextViewBackgroundColor = Color.Transparent;

        public Color TextViewBackgroundColor {
            get { return _TextViewBackgroundColor; }
            set { _TextViewBackgroundColor = value; }
        }

        private Color _LineNumberColor = Color.Black;

        public Color LineNumberColor {
            get { return _LineNumberColor; }
            set { _LineNumberColor = value; }
        }

        public int LineNumberWidth { get; private set; }

        public Rectangle HeadRectangle { get; protected set; }
        public Rectangle TextRectangle { get; protected set; }

        protected STTextBox.Core Core { get; private set; }

        public abstract int GetCurrentCharOffset();

        public void Init(STTextBox.Core textBoxCore) {
            this.Core = textBoxCore;
            this.OnInitAllText();
        }

        public abstract void SetCaretPostion(int nCharIndex);
        public virtual FindInfo SetCaretPostion(Point pt) {
            var fi = this.FindFromPoint(pt);
            if (!fi.Find) {
                return fi;
            }
            this.Core.Caret.CopyFromFindInfo(fi);
            this.SetCaretPostion(fi.Location.X, fi.Location.Y);
            return fi;
        }

        protected virtual void SetCaretPostion(int nX, int nY) {
            var caret = this.Core.Caret;
            caret.X = nX;
            caret.Y = nY;
            if (!this.TextRectangle.Contains(new Point(nX, nY))) {
                if (!caret.Visable) return;
                Win32.HideCaret(this.Core.TextBox.Handle);
                caret.Visable = false;
            } else {
                Win32.SetCaretPos(nX, nY);
                if (!caret.Visable) {
                    caret.Visable = true;
                    Win32.ShowCaret(this.Core.TextBox.Handle);
                }
            }
        }

        public virtual void ScrollXToMuosePoint(int nX) {
            var c = this.Core;
            nX -= c.ViewRectangle.X;
            nX -= c.Scroll.HThumbRect.Width / 2;
            if (nX < 0) {
                nX = 0;
            } else if (nX + c.Scroll.HThumbRect.Width > c.Scroll.HBackRect.Width) {
                nX = c.Scroll.HBackRect.Width - c.Scroll.HThumbRect.Width;
            }
            int nTemp = (int)((float)nX / (c.Scroll.HBackRect.Width - c.Scroll.HThumbRect.Width) * c.Scroll.MaxXValue);
            c.Scroll.XValue = nTemp;
            this.SetCaretPostion(c.Caret.IndexOfChar);
        }

        public virtual void ScrollYToMousePoint(int nY) {
            var c = this.Core;
            nY -= c.ViewRectangle.Y;
            nY -= c.Scroll.VThumbRect.Height / 2;
            if (nY < 0) {
                nY = 0;
            } else if (nY + c.Scroll.VThumbRect.Height > c.Scroll.VBackRect.Height) {
                nY = c.Scroll.VBackRect.Height - c.Scroll.VThumbRect.Height;
            }
            int nTemp = (int)((float)nY / (c.Scroll.VBackRect.Height - c.Scroll.VThumbRect.Height) * c.Scroll.MaxYValue);
            c.Scroll.YValue = nTemp;
            this.SetCaretPostion(c.Caret.IndexOfChar);
        }

        public virtual bool ScrollToCaret() {
            var c = this.Core;
            bool flag = false;
            Point pt = c.Caret.Location;
            if (pt.Y < this.TextRectangle.Y) {
                c.Scroll.YValue += (pt.Y - this.TextRectangle.Y) / c.LineHeight;
                flag = true;
            } else if (pt.Y + c.LineHeight > this.TextRectangle.Bottom) {
                int nIncrement = (int)Math.Ceiling((pt.Y + c.LineHeight - this.TextRectangle.Bottom) / (float)c.LineHeight);
                c.Scroll.YValue += nIncrement;
                flag = true;
            }
            if (pt.X >= this.TextRectangle.Right) {
                int nIncrement = (int)Math.Ceiling((pt.X - this.TextRectangle.Right + 1) / (float)c.Scroll.XIncrement);
                c.Scroll.XValue += nIncrement;
                flag = true;
            } else if (pt.X < this.TextRectangle.X) {
                int nIncrement = ((int)Math.Ceiling((this.TextRectangle.X - pt.X) / (float)c.Scroll.XIncrement));
                c.Scroll.XValue -= nIncrement;
                flag = true;
            }
            if (flag) {
                this.SetCaretPostion(c.Caret.IndexOfChar);
            }
            return flag;
        }

        public Point ControlToView(Point pt) {
            var c = this.Core;
            pt.X = pt.X - this.TextRectangle.X + this.Core.Scroll.XOffset;
            pt.Y = pt.Y - c.TextBox.GetIntYSize(c.ViewRectangle.Y) + c.Scroll.YValue * c.LineHeight;
            return pt;
        }

        public Point ViewToControl(Point pt) {
            var c = this.Core;
            pt.X = pt.X - c.Scroll.XOffset + this.TextRectangle.X;
            pt.Y = pt.Y - c.Scroll.YValue * c.LineHeight + c.TextBox.GetIntYSize(c.ViewRectangle.Y);
            return pt;
        }

        public void Invalidate() {
            if (this.Core != null && this.Core.TextBox != null) {
                this.Core.TextBox.Invalidate();
            }
        }

        public void OnDrawView(ISTTextBoxRender render) {
            var c = this.Core;
            int nXStart = this.TextRectangle.X;
            if (this._TextViewBackgroundColor.A > 0) {  // fill background
                Rectangle rect = c.ViewRectangle;
                rect.X = this.HeadRectangle.Right;
                rect.Width -= this.HeadRectangle.Width;
                this.OnFillTextViewBackground(render, rect);
            }
            render.SetClip(this.TextRectangle);
            //this.OnDrawSelectionBackground(dt, c.Selection);    // fill selection background
            // start draw line
            int nY = this.TextRectangle.Y;
            int nStartLineIndex = this.GetLineIndexFromYScroll(c.Scroll.YValue);
            for (int i = nStartLineIndex; i < c.TextManager.LineCount; i++) {
                TextLine line = c.TextManager[i];
                if (!c.Selection.IsEmptySelection) {
                    this.OnDrawLineSelectionBackground(render, line, i, c.Selection, nY);
                }
                nY += this.OnDrawLine(render, line, nXStart, nY);
                if (nY > c.ViewRectangle.Bottom) break;
            }
            // start draw line number
            render.SetClip(this.HeadRectangle);
            this.OnDrawHead(render, nStartLineIndex);
            render.ResetClip();
        }

        protected virtual void OnFillTextViewBackground(ISTTextBoxRender render, Rectangle rect) {
            render.FillRectangle(this.TextViewBackgroundColor, rect);
        }

        protected virtual void OnFillHeadBackground(ISTTextBoxRender render, Rectangle rect) {
            render.FillRectangle(this._HeadBackgroundColor, rect);
        }

        protected abstract void OnDrawLineSelectionBackground(ISTTextBoxRender render, TextLine line, int nLineIndex, STTextBoxSelectionInfo selection, int nY);
        protected abstract void OnDrawHead(ISTTextBoxRender render, int nStartLineIndex);
        protected abstract int OnDrawLine(ISTTextBoxRender render, TextLine line, int nX, int nY);

        public virtual void OnResize(EventArgs e) { }

        public virtual void OnTextStartChange(ISTTextBoxRender render, TextManagerTextEventArgs e) { }
        public virtual void OnTextChanged(ISTTextBoxRender render, TextManagerTextEventArgs e) { }
        public virtual void OnLineCountChanged(ISTTextBoxRender render, EventArgs e) { }
        public abstract void OnInitAllText();
        public abstract void OnLineAdded(ISTTextBoxRender render, TextManagerLineEventArgs e);
        public abstract void OnLineRemoved(ISTTextBoxRender render, TextManagerLineEventArgs e);
        public abstract void OnLineChanged(ISTTextBoxRender render, TextManagerLineEventArgs e);
        public abstract int GetLineIndexFromYScroll(int nYValue);
        public abstract FindInfo FindFromPoint(Point pt);
        public abstract FindInfo FindFromCharIndex(int nIndex);

        public void OnSetCursor(MouseEventArgs e) {
            var c = this.Core;
            if (c.ViewRectangle.Contains(e.Location) && e.X < this.TextRectangle.X) {
                c.Scroll.HoverScrollBar = STTextBoxScrollInfo.ScrollBarType.None;
                this.SetCursor(Cursors.Arrow);
            } else {
                c.Scroll.HoverScrollBar = STTextBoxScrollInfo.ScrollBarType.None;
                this.SetCursor(Cursors.IBeam);
            }
        }

        private bool SetCursor(Cursor c) {
            if (this.Core.TextBox.Cursor == c) {
                return false;
            }
            this.Core.TextBox.Cursor = c;
            return true;
        }

        public virtual void OnCalcTextRectangle() {
            var c = this.Core;

            string strLineCount = c.TextManager.LineCount.ToString();
            this.Core.ITextBoxRender.BeginPaint();
            this.LineNumberWidth = c.GetStringWidth("".PadLeft(strLineCount.Length, '8'), TextStyle.Empty, 0) + c.TextBox.GetIntXSize(20);
            c.ITextBoxRender.EndPaint();

            Rectangle rect = c.ViewRectangle;
            Rectangle rect_temp = new Rectangle() {
                X = rect.X,
                Y = rect.Y,
                Height = rect.Height
            };
            if (this._ShowLineNumber) {
                rect_temp.Width += this.LineNumberWidth;
            }
            this.HeadRectangle = rect_temp;
            rect_temp.X = this.HeadRectangle.Right + this.Core.TextBox.GetIntXSize(2);
            rect_temp.Width = rect.Width - rect_temp.X - this.Core.TextBox.GetIntXSize(2) + rect.X;
            this.TextRectangle = rect_temp;
        }

        public abstract void OnCalcScroll(STTextBoxScrollInfo scrollInfo);
    }
}