using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.ComponentModel;

namespace ST.Library.UI.STTextBox
{
 public partial class STTextBox : Control
 {
 [Browsable(false)]
 public float XDPIZoom { get; private set; }
 [Browsable(false)]
 public float YDPIZoom { get; private set; }

 private int _BorderWidth = 1;

 public int BorderWidth {
 get { return _BorderWidth; }
 set { _BorderWidth = value; }
 }

 private int _LineSpacing = 0;

 public int LineSpacing {
 get { return _LineSpacing; }
 set {
 if (value < 0) {
 throw new ArgumentException("The value must be more than zero");
 }
 _LineSpacing = value;
 this.Invalidate();
 }
 }

 private int _CharSpacing = 0;

 public int CharSpacing {
 get { return _CharSpacing; }
 set {
 if (value < 0) {
 throw new ArgumentException("The value must be more than zero");
 }
 _CharSpacing = value;
 this.Invalidate();
 }
 }

 private Color _BorderColor = Color.FromArgb(125, 0, 0, 0);

 public Color BorderColor {
 get { return _BorderColor; }
 set {
 if (_BorderColor == value) {
 return;
 }
 _BorderColor = value;
 this.Invalidate();
 }
 }

 private Color _SelectionColor = Color.FromArgb(125, Color.DarkGray);

 public Color SelectionColor {
 get { return _SelectionColor; }
 set {
 if (value == _SelectionColor) {
 return;
 }
 _SelectionColor = value;
 if (!m_core.Selection.IsEmptySelection) {
 this.Invalidate();
 }
 }
 }

 private bool _AllowScrollBar = true;

 public bool AllowScrollBar {
 get { return _AllowScrollBar; }
 set { _AllowScrollBar = value; }
 }

 private Color _ScrollbarBackColor = Color.FromArgb(40, Color.Gray);

 public Color ScrollbarBackColor {
 get { return _ScrollbarBackColor; }
 set { _ScrollbarBackColor = value; }
 }

 private Color _ScrollBarCornerColor = Color.FromArgb(80, Color.Gray);

 public Color ScrollBarCornerColor {
 get { return _ScrollBarCornerColor; }
 set { _ScrollBarCornerColor = value; }
 }

 private Color _ScrollbarThumbHoverColor = Color.FromArgb(80, Color.Gray);

 public Color ScrollbarThumbHoverColor {
 get { return _ScrollbarThumbHoverColor; }
 set { _ScrollbarThumbHoverColor = value; }
 }

 private Color _ScrollbarThumbBackColor = Color.FromArgb(80, Color.Black);

 public Color ScrollbarThumbBackColor {
 get { return _ScrollbarThumbBackColor; }
 set { _ScrollbarThumbBackColor = value; }
 }

 private int _TabSize = 4;

 private bool _AutoIndent = true;

 private bool _TabToSpace = false;

 private const int WM_MOUSEHWHEEL = 0x020E;
 private object m_obj_sync = new object();
 private Timer m_timer;
 private IntPtr m_hIMC;
 protected Core m_core;


 public STTextBox() {
 this.SetStyle(ControlStyles.UserPaint, true);
 this.SetStyle(ControlStyles.ResizeRedraw, true);
 this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
 this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
 this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);

 this.BackColor = Color.White;
 m_timer = new Timer();
 m_timer.Interval = 1000;
 m_timer.Tick += new EventHandler(m_timer_Tick);
 m_core = new Core(this);
 }

 #region override

 protected override void OnCreateControl() {
 base.OnCreateControl();
 using (Graphics g = this.CreateGraphics()) {
 this.XDPIZoom = g.DpiX / 96;
 this.YDPIZoom = g.DpiY / 96;
 }
 }

 protected override void WndProc(ref Message m) {
 switch (m.Msg) {
 case Win32.WM_IME_STARTCOMPOSITION:
 m_hIMC = Win32.ImmGetContext(this.Handle);
 this.OnImeStartPrivate(m_hIMC);
 break;
 case Win32.WM_IME_ENDCOMPOSITION:
 this.OnImeEndPrivate(m_hIMC);
 break;
 case Win32.WM_IME_COMPOSITION:
 if (((int)m.LParam & Win32.GCS_RESULTSTR) == Win32.GCS_RESULTSTR) {
 m.Result = (IntPtr)1;
 this.OnImeResultStrPrivate(m_hIMC, Win32.ImmGetCompositionString(m_hIMC, Win32.GCS_RESULTSTR));
 return;//Interrupt, WM_CHAR, WM_IME_CHAR messages will not be generated.
 }
 if (((int)m.LParam & Win32.GCS_COMPSTR) == Win32.GCS_COMPSTR) {
 this.OnImeCompStr(m_hIMC, Win32.ImmGetCompositionString(m_hIMC, Win32.GCS_COMPSTR));
 }
 break;
 case WM_MOUSEHWHEEL:
 Point pt = new Point(((int)m.LParam) >> 16, (ushort)m.LParam);
 pt = this.PointToClient(pt);
 MouseButtons mb = MouseButtons.None;
 int n = (ushort)m.WParam;
 if ((n & 0x0001) == 0x0001) mb |= MouseButtons.Left;
 if ((n & 0x0010) == 0x0010) mb |= MouseButtons.Middle;
 if ((n & 0x0002) == 0x0002) mb |= MouseButtons.Right;
 if ((n & 0x0020) == 0x0020) mb |= MouseButtons.XButton1;
 if ((n & 0x0040) == 0x0040) mb |= MouseButtons.XButton2;
 this.OnMouseHWheel(new MouseEventArgs(mb, 0, pt.X, pt.Y, ((int)m.WParam) >> 16));
 break;
 }
 base.WndProc(ref m);
 }

 protected override void OnPaint(PaintEventArgs e) {
 base.OnPaint(e);
 //System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
 //sw.Start();
 this.XDPIZoom = e.Graphics.DpiX / 96;
 this.YDPIZoom = e.Graphics.DpiY / 96;
 var render = m_core.ITextBoxRender;
 //try {
 render.OnBeginPaint(e.Graphics);
 m_core.ITextView.OnDrawView(render);
 if (this._AllowScrollBar && m_core.Scroll.CountDown != 0) {
 this.OnCalcScrollRectangle(m_core.Scroll);
 bool bFlag = true;
 if (m_core.Scroll.HBackRect != m_core.Scroll.HThumbRect) {
 this.OnDrawHScrollBar(render, m_core.Scroll);
 } else { bFlag = false; }
 if (m_core.Scroll.VBackRect != m_core.Scroll.VThumbRect) {
 this.OnDrawVScrollBar(render, m_core.Scroll);
 } else { bFlag = false; }
 if (bFlag) this.OnDrawScrollBarCorner(render, m_core.Scroll);
 }
 this.OnDrawBorder(render);
 render.OnEndPaint(e.Graphics);
 //} catch (Exception ex) {
 // MessageBox.Show(ex.Message + "\r\n\r\n" + ex.StackTrace);
 //}
 //sw.Stop();
 //Console.WriteLine("OnPaint - " + sw.ElapsedMilliseconds + "ms");
 }

 protected virtual void OnDrawBorder(ISTTextBoxRender render) {
 if (this._BorderWidth <= 0) {
 return;
 }
 int nWidth = this.GetIntXSize(this._BorderWidth);
 int nHeight = this.GetIntYSize(this._BorderWidth);
 if (nWidth == 0) nWidth = 1;
 if (nHeight == 0) nHeight = 1;

 render.FillRectangle(this._BorderColor, 0, 0, nWidth, this.Height);
 render.FillRectangle(this._BorderColor, this.Width - nWidth, 0, nWidth, this.Height);
 render.FillRectangle(this._BorderColor, nWidth, 0, this.Width - nWidth * 2, nHeight);
 render.FillRectangle(this._BorderColor, nWidth, this.Height - nHeight, this.Width - nWidth * 2, nHeight);
 }

 protected override void OnResize(EventArgs e) {
 base.OnResize(e);
 int nX = this.GetIntXSize(this._BorderWidth);
 int nY = this.GetIntYSize(this._BorderWidth);
 var rect = new Rectangle(nX, nY, this.Width - nX * 2, this.Height - nY * 2);
 if (rect.Height < 1 || rect.Width < 1 || rect == m_core.ViewRectangle) {
 return;
 }
 m_core.ViewRectangle = rect;
 m_core.ITextView.OnCalcTextRectangle();
 m_core.ITextView.OnResize(e);
 m_core.ITextView.OnCalcScroll(m_core.Scroll);
 }

 protected override void OnGotFocus(EventArgs e) {
 base.OnGotFocus(e);
 Win32.CreateCaret(this.Handle, IntPtr.Zero, this.GetIntXSize(1), m_core.LineHeight);
 Win32.ShowCaret(this.Handle);
 }

 protected override void OnLostFocus(EventArgs e) {
 base.OnLostFocus(e);
 Win32.HideCaret(this.Handle);
 Win32.DestroyCaret();
 }

 #endregion

 #region public

 public float GetFloatXSize(int nSize) { return nSize * this.XDPIZoom; }
 public float GetFloatXSize(float fSize) { return fSize * this.XDPIZoom; }
 public int GetIntXSize(int nSize) { return (int)Math.Round(nSize * this.XDPIZoom); }
 public int GetIntXSize(float fSize) { return (int)Math.Round(fSize * this.XDPIZoom); }

 public float GetFloatYSize(int nSize) { return nSize * this.YDPIZoom; }
 public float GetFloatYSize(float fSize) { return fSize * this.YDPIZoom; }
 public int GetIntYSize(int nSize) { return (int)Math.Round(nSize * this.YDPIZoom); }
 public int GetIntYSize(float fSize) { return (int)Math.Round(fSize * this.YDPIZoom); }

 public void ShowScrollBar(int nSecond) {
 lock (m_obj_sync) {
 m_core.Scroll.CountDown = nSecond;
 }
 m_timer.Start();
 }

 public TextHistoryRecord SetText(string strText) {
 return m_core.TextManager.SetText(strText);
 }

 public TextHistoryRecord SetText(int nIndex, string strText) {
 return m_core.TextManager.SetText(nIndex, strText);
 }

 public TextHistoryRecord SetText(int nIndex, int nLen, string strText) {
 return m_core.TextManager.SetText(nIndex, nLen, strText);
 }

 public void SelectAll() {
 m_core.Selection.SetSelection(0, m_core.TextManager.TextLength);
 m_core.Caret.IndexOfChar = m_core.Selection.EndIndex;
 m_core.ITextView.SetCaretPostion(m_core.Caret.IndexOfChar);
 this.Invalidate();
 }

 public void Copy() {
 this.Copy(false);
 }

 public void Cut() {
 this.Copy(true);
 }

 private void Copy(bool bCut) {
 var c = m_core;
 if (c.Selection.IsEmptySelection) {
 return;
 }
 Clipboard.SetText(c.TextManager.GetText(c.Selection.StartIndex, c.Selection.Length));
 if (bCut) {
 this.EnterText("");
 }
 }

 public void Paste() {
 string strText = Clipboard.GetText();
 if (string.IsNullOrEmpty(strText)) {
 return;
 }
 this.EnterText(strText);
 }

 public void Undo() {
 this.RunHistory(true);
 }

 public void Redo() {
 this.RunHistory(false);
 }

 private void RunHistory(bool isUndo) {
 var c = m_core;
 if (c.ITextHistory == null) {
 return;
 }
 var histories = isUndo ? c.ITextHistory.GetUndo() : c.ITextHistory.GetRedo();
 if (histories == null || histories.Length == 0) {
 return;
 }
 if (isUndo) {
 var temp = new TextHistoryRecord[histories.Length];
 for (int i = 0; i < histories.Length; i++) {
 temp[i] = histories[i];
 temp[i].NewText = histories[i].OldText;
 temp[i].OldText = histories[i].NewText;
 }
 histories = temp;
 }
 histories = c.TextManager.RunHistory(histories);
 var last = histories[histories.Length - 1];
 c.Selection.SetSelection(last.Index, last.Index + last.NewText.Length);
 c.Caret.IndexOfChar = m_core.Selection.EndIndex;
 c.ITextView.SetCaretPostion(c.Caret.IndexOfChar);
 c.ITextView.ScrollToCaret();
 this.Invalidate();
 }

 #endregion

 #region protected

 protected virtual void OnImeStart(IntPtr hIMC) { }
 protected virtual void OnImeResultStr(IntPtr hIMC, string strResult) { this.EnterText(strResult); }
 protected virtual void OnImeCompStr(IntPtr hIMC, string strComp) { }
 protected virtual void OnImeEnd(IntPtr hIMC) { }

 protected virtual void OnCalcScrollRectangle(STTextBoxScrollInfo scroll) {
 int nSW = this.GetIntXSize(scroll.Size);
 int nSH = this.GetIntYSize(scroll.Size);
 var c = m_core;
 Rectangle rectV = c.ViewRectangle;
 scroll.HBackRect = new Rectangle(rectV.X, rectV.Bottom - nSH, rectV.Width - nSW, nSH);
 scroll.VBackRect = new Rectangle(rectV.Right - nSW, rectV.Y, nSW, rectV.Height - nSH);
 Rectangle rect_h_thumb = scroll.HBackRect;
 Rectangle rect_v_thumb = scroll.VBackRect;

 float fScale = ((float)rectV.Width / scroll.XIncrement) / (rectV.Width / scroll.XIncrement + scroll.MaxXValue);
 rect_h_thumb.Width = (int)(rectV.Width * fScale);
 if (rect_h_thumb.Width > scroll.HBackRect.Width) {
 rect_h_thumb.Width = scroll.HBackRect.Width;
 } else if (rect_h_thumb.Width < this.GetIntXSize(4)) {
 rect_h_thumb.Width = this.GetIntXSize(4);
 }

 fScale = ((float)rectV.Height / c.LineHeight) / (rectV.Height / c.LineHeight + scroll.MaxYValue);
 rect_v_thumb.Height = (int)(rectV.Height * fScale);
 if (rect_v_thumb.Height > scroll.VBackRect.Height) {
 rect_v_thumb.Height = scroll.VBackRect.Height;
 } else if (rect_v_thumb.Height < this.GetIntYSize(4)) {
 rect_v_thumb.Height = this.GetIntYSize(4);
 }

 rect_h_thumb.X = rectV.X;
 if (scroll.MaxXValue > 0) {
 fScale = (float)scroll.XValue / scroll.MaxXValue;
 rect_h_thumb.X += (int)((scroll.HBackRect.Width - rect_h_thumb.Width) * fScale);
 }

 rect_v_thumb.Y = rectV.Y;
 if (scroll.MaxYValue > 0) {
 fScale = (float)scroll.YValue / scroll.MaxYValue;
 rect_v_thumb.Y += (int)((scroll.VBackRect.Height - rect_v_thumb.Height) * fScale);
 }
 scroll.HThumbRect = rect_h_thumb;
 scroll.VThumbRect = rect_v_thumb;
 if (scroll.VBackRect == rect_v_thumb) {
 rect_h_thumb.Width += nSW;
 scroll.HThumbRect = rect_h_thumb;
 var temp = scroll.HBackRect;
 temp.Width += nSW;
 scroll.HBackRect = temp;
 } else if (scroll.HBackRect == rect_h_thumb) {
 rect_v_thumb.Height += nSH;
 scroll.VThumbRect = rect_v_thumb;
 var temp = scroll.VBackRect;
 temp.Height += nSH;
 scroll.VBackRect = temp;
 } else {
 }
 //scroll.HThumbRect = rect_h_thumb;
 //scroll.VThumbRect = rect_v_thumb;
 }

 protected virtual void OnDrawVScrollBar(ISTTextBoxRender render, STTextBoxScrollInfo scroll) {
 var clr = scroll.HoverScrollBar == STTextBoxScrollInfo.ScrollBarType.V ? this._ScrollbarThumbHoverColor : this._ScrollbarBackColor;
 render.FillRectangle(clr, scroll.VBackRect);
 render.FillRectangle(clr, scroll.VBackRect.X, scroll.VBackRect.Y, this.GetIntXSize(1), scroll.VBackRect.Height);
 render.FillRectangle(this._ScrollbarThumbBackColor, scroll.VThumbRect);
 }

 protected virtual void OnDrawHScrollBar(ISTTextBoxRender render, STTextBoxScrollInfo scroll) {
 var clr = scroll.HoverScrollBar == STTextBoxScrollInfo.ScrollBarType.H ? this._ScrollbarThumbHoverColor : this._ScrollbarBackColor;
 render.FillRectangle(clr, scroll.HBackRect);
 render.FillRectangle(clr, scroll.HBackRect.X, scroll.HBackRect.Y, scroll.HBackRect.Width, this.GetIntYSize(1));
 render.FillRectangle(this._ScrollbarThumbBackColor, scroll.HThumbRect);
 }

 protected virtual void OnDrawScrollBarCorner(ISTTextBoxRender render, STTextBoxScrollInfo scroll) {
 int nWidth = this.GetIntXSize(scroll.Size);
 int nHeight = this.GetIntYSize(scroll.Size);
 render.FillRectangle(
 this._ScrollBarCornerColor, m_core.ViewRectangle.Right - nWidth,
 m_core.ViewRectangle.Bottom - nHeight,
 nWidth,
 nHeight);
 }

 #endregion

 #region private

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

 private void OnImeStartPrivate(IntPtr hIMC) {
 var CandidateForm = new Win32.CANDIDATEFORM() {
 dwStyle = Win32.CFS_CANDIDATEPOS,
 ptCurrentPos = m_core.Caret.Location
 };
 Win32.ImmSetCandidateWindow(hIMC, ref CandidateForm);
 var CompositionForm = new Win32.COMPOSITIONFORM() {
 dwStyle = Win32.CFS_FORCE_POSITION,
 ptCurrentPos = m_core.Caret.Location
 };
 Win32.ImmSetCompositionWindow(hIMC, ref CompositionForm);
 var logFont = new Win32.LOGFONT() {
 lfHeight = m_core.FontHeight,
 lfFaceName = this.Font.Name + "0円"
 };
 Win32.ImmSetCompositionFont(hIMC, ref logFont);
 this.OnImeStart(hIMC);
 }

 private void OnImeEndPrivate(IntPtr hIMC) {
 Win32.ImmReleaseContext(this.Handle, hIMC);
 this.OnImeEnd(hIMC);
 }

 private void OnImeResultStrPrivate(IntPtr hIMC, string strResult) {
 var CompositionForm = new Win32.COMPOSITIONFORM() {
 dwStyle = Win32.CFS_FORCE_POSITION,
 ptCurrentPos = m_core.Caret.Location
 };
 Win32.ImmSetCompositionWindow(hIMC, ref CompositionForm);
 this.OnImeResultStr(hIMC, strResult);
 }

 private void m_timer_Tick(object sender, EventArgs e) {
 if (m_core.Scroll.HoverScrollBar != STTextBoxScrollInfo.ScrollBarType.None) {
 return;
 }
 lock (m_obj_sync) {
 m_core.Scroll.CountDown--;
 }
 if (m_core.Scroll.CountDown <= 0) {
 m_timer.Stop();
 this.Invalidate();
 }
 }

 #endregion
 }
}