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

namespace ST.Library.UI.STTextBox
{
 public class WrapTextView : TextView
 {
 public Color LineNumberGuideColor { get; set; }
 public bool ShowLineNumberGuide { get; set; }

 public enum Method { Char, Word };
 public enum Alignment { Left, Center, Right/*, Justify*/ }
 private enum SubLineStatus
 {
 Start,
 Middle,
 End,
 None
 }
 private class WrapLineInfo
 {
 public int ScreenLineOffset { get; set; }
 public List<SubLineInfo> SubLines { get; set; }

 public override string ToString() {
 return "(" /*+ this.IndexOfLine + "," +*/ + this.ScreenLineOffset + "," + this.SubLines.Count + ")";
 }
 }

 private struct WordInfo
 {
 public int Width;
 public int CharCount;
 }

 private struct SubLineInfo
 {
 public int Index; // The first char index of sub-line 
 public int Length; // The text length
 public int CharCount; // Grapheme count
 public int Width; // Sub-Line width
 public int X; // The X position to draw
 //public float ExtraWidth; // The char space width
 }

 public Method WrapMethod { get; private set; }
 public Alignment WrapAlignment { get; private set; }

 private int m_n_line_count_start_change = 0;
 private HashSet<TextLine> m_hs_changed_temp = new HashSet<TextLine>();
 private StringFormat m_sf = new StringFormat(StringFormat.GenericTypographic) {
 Alignment = StringAlignment.Far,
 LineAlignment = StringAlignment.Center
 };

 public WrapTextView() : this(Method.Word, Alignment.Left) { }
 public WrapTextView(Method method, Alignment alignment) {
 this.WrapMethod = method;
 this.WrapAlignment = alignment;
 this.ShowLineNumberGuide = true;
 this.LineNumberGuideColor = Color.Magenta;
 }

 public void SetWrap(Method method, Alignment alignment) {
 this.WrapMethod = method;
 this.WrapAlignment = alignment;
 if (this.Core == null) return;
 this.OnInitAllText();
 }

 public override int GetCurrentCharOffset() {
 var c = base.Core;
 TextLine line = c.Caret.Line;
 var tag = _Tag(line);
 int nSubIndex = 0;
 int nCharIndex = c.Caret.IndexOfChar - line.IndexOfFirstChar;
 foreach (var sub in tag.SubLines) {
 if (nCharIndex >= sub.Index && nCharIndex <= sub.Index + sub.Length) {
 break;
 }
 nSubIndex++;
 }
 var subLine = tag.SubLines[nSubIndex];
 return c.Caret.X - base.TextRectangle.X - subLine.X;
 }

 public override void OnInitAllText() {
 var c = base.Core;
 c.ITextBoxRender.BeginPaint();
 foreach (var line in base.Core.TextManager) {
 this.CacheLine(line, base.Core.ITextBoxRender);
 }
 c.ITextBoxRender.EndPaint();
 c.TextBox.Invalidate();
 }

 public override void OnLineAdded(ISTTextBoxRender render, TextManagerLineEventArgs e) {
 this.CacheLine(e.Line, render);
 m_hs_changed_temp.Add(e.Line);
 }

 private WrapLineInfo _Tag(TextLine line) {
 WrapLineInfo ret = null;
 if (line.Tag == null || !(line.Tag is WrapLineInfo)) {
 line.Tag = ret = new WrapLineInfo();
 return ret;
 }
 return (WrapLineInfo)line.Tag;
 }

 private void CacheLine(TextLine line, ISTTextBoxRender render) {
 var tag = _Tag(line);
 tag.SubLines = this.GetCache(line, render);
 }

 public override void OnLineRemoved(ISTTextBoxRender render, TextManagerLineEventArgs e) {
 //m_hs_changed.Remove(e.Line);
 m_hs_changed_temp.Remove(e.Line);
 }

 public override void OnLineChanged(ISTTextBoxRender render, TextManagerLineEventArgs e) {
 //m_hs_changed.Add(e.Line);
 m_hs_changed_temp.Add(e.Line);
 }

 private List<SubLineInfo> GetCache(TextLine line, ISTTextBoxRender render) {
 var c = base.Core;
 List<SubLineInfo> lst = null;
 if (this.WrapMethod == Method.Char) {
 lst = new List<SubLineInfo>();
 this.GetCacheByChar(line, render, lst, 0, 0);
 } else {
 lst = this.GetCacheByWord(line, render);
 }
 for (int i = 0; i < lst.Count; i++) {
 var sub = lst[i];
 switch (this.WrapAlignment) {
 case Alignment.Center:
 sub.X = (base.TextRectangle.Width - sub.Width) >> 1;
 if (sub.Length > 0) {
 switch (line.RawString[sub.Index + sub.Length - 1]) {
 case '\r':
 case '\n':
 sub.X += c.ITextBoxRender.GetSpaceWidth() / 2;
 break;
 }
 }
 break;
 case Alignment.Right:
 sub.X = base.TextRectangle.Width - sub.Width - c.ITextBoxRender.GetSpaceWidth();
 if (sub.Length > 0) {
 switch (line.RawString[sub.Index]) {
 case '\r':
 case '\n':
 if (i == 0) break;
 var temp = lst[i - 1];
 temp.Width += sub.Width;
 temp.Length += sub.Length;
 temp.CharCount += 1;
 lst[i - 1] = temp;
 lst.RemoveAt(i);
 return lst;

 }
 switch (line.RawString[sub.Index + sub.Length - 1]) {
 case '\r':
 case '\n':
 sub.X += c.ITextBoxRender.GetSpaceWidth();
 break;
 }
 break;
 }
 break;
 }
 lst[i] = sub;
 }
 return lst;
 }

 private int GetCacheByChar(TextLine line, ISTTextBoxRender render, List<SubLineInfo> lst, int nStartIndex, int nWidth) {
 var c = base.Core;
 int nLineWidth = nWidth, nCharWidth = 0;
 int nSubStrLen = 0;
 int nCharCount = 0;
 int nTextViewLineWidth = base.TextRectangle.Width;
 if (this.WrapAlignment != Alignment.Left) {
 nTextViewLineWidth -= c.ITextBoxRender.GetSpaceWidth();
 }
 c.IGraphemeSplitter.Each(line.RawString, nStartIndex, (str, nStart, nLen) => {
 string strChar = str.Substring(nStart, nLen);
 if (c.IsEmoji(strChar)) {
 nCharWidth = c.FontHeight;
 } else {
 nCharWidth = c.GetStringWidth(strChar, c.GetStyleFromCharIndex(line.IndexOfFirstChar + nStart), nLineWidth);
 }
 if (nLineWidth + nCharWidth >= nTextViewLineWidth) {
 lst.Add(new SubLineInfo() {
 Index = nStartIndex,
 Length = nSubStrLen,
 CharCount = nCharCount,
 Width = nLineWidth
 });
 nCharCount = 1;
 nStartIndex += nSubStrLen;
 nSubStrLen = nLen;
 nLineWidth = nCharWidth;
 } else {
 nSubStrLen += nLen;
 nLineWidth += nCharWidth;
 nCharCount++;
 }
 return true;
 });
 lst.Add(new SubLineInfo() {
 Index = nStartIndex,
 Length = nSubStrLen,
 CharCount = nCharCount,
 Width = nLineWidth
 });
 return nLineWidth;
 }

 private List<SubLineInfo> GetCacheByWord(TextLine line, ISTTextBoxRender render) {
 var c = base.Core;
 int nCharCount = 0, nCharCountTemp = 0;
 int nLineWidth = 0;
 int nSubStrLen = 0, nIndexStart = 0;
 List<SubLineInfo> lst = new List<SubLineInfo>();
 int nTextViewLineWidth = base.TextRectangle.Width;
 if (this.WrapAlignment != Alignment.Left) {
 nTextViewLineWidth -= c.ITextBoxRender.GetSpaceWidth();
 }
 //if (this.Alignment == UI.STTextBox.Alignment.Justify) {
 // nTextViewLineWidth -= c.ITextRender.GetSpaceWidth();
 //}
 c.IWordSplitter.Each(line.RawString, (str, nStart, nLen) => {
 string strWord = str.Substring(nStart, nLen);
 nCharCountTemp = 0;
 var wi = this.GetWordInfo(line, render, strWord, nStart, nLineWidth);
 if (wi.Width >= nTextViewLineWidth) {
 int nCharWidth = 0;
 c.IGraphemeSplitter.Each(strWord, (s, ns, nl) => {
 string strChar = s.Substring(ns, nl);
 if (c.IsEmoji(strChar)) {
 nCharWidth = c.FontHeight;
 } else {
 nCharWidth = c.GetStringWidth(strChar, c.GetStyleFromCharIndex(line.IndexOfFirstChar + nStart), nLineWidth);
 }
 nCharCountTemp++;
 if (nLineWidth + nCharWidth >= nTextViewLineWidth) {
 lst.Add(new SubLineInfo() {
 Index = nIndexStart,
 Length = nSubStrLen,
 CharCount = nCharCount,
 Width = nLineWidth
 });
 nIndexStart += nSubStrLen;
 nSubStrLen = nl;
 nLineWidth = nCharWidth;
 nCharCount = nCharCountTemp;
 } else {
 nSubStrLen += nl;
 nLineWidth += nCharWidth;
 nCharCount += nCharCountTemp;
 }
 });
 return true;
 }
 nCharCountTemp += wi.CharCount;
 if (nLineWidth + wi.Width >= nTextViewLineWidth) {
 lst.Add(new SubLineInfo() {
 Index = nIndexStart,
 Length = nSubStrLen,
 CharCount = nCharCount,
 Width = nLineWidth
 });
 nIndexStart += nSubStrLen;
 nSubStrLen = nLen;
 nLineWidth = wi.Width;
 nCharCount = nCharCountTemp;
 } else {
 nSubStrLen += nLen;
 nLineWidth += wi.Width;
 nCharCount += nCharCountTemp;
 }
 return true;
 });
 lst.Add(new SubLineInfo() {
 Index = nIndexStart,
 Length = nSubStrLen,
 CharCount = nCharCount,
 Width = nLineWidth
 });
 return lst;
 }

 private WordInfo GetWordInfo(TextLine line, ISTTextBoxRender render, string strWord, int nIndex, int nLeftWidth) {
 var c = base.Core;
 int nWordWidth = 0;
 int nCharCount = 0;
 c.IGraphemeSplitter.Each(strWord, (s, ns, nl) => {
 string strChar = s.Substring(ns, nl);
 if (c.IsEmoji(strChar)) {
 nWordWidth += c.FontHeight;
 } else {
 nWordWidth += c.GetStringWidth(strChar, c.GetStyleFromCharIndex(line.IndexOfFirstChar + nIndex), nLeftWidth + nWordWidth);
 }
 nCharCount++;
 });
 return new WordInfo() { Width = nWordWidth, CharCount = nCharCount };
 }

 public override void OnTextChanged(ISTTextBoxRender render, TextManagerTextEventArgs e) {
 base.OnTextChanged(render, e);
 var c = base.Core;
 var m = c.TextManager;
 int nIndexMin = int.MaxValue, nLineIndex = 0;
 if (m.LineCount.ToString().Length != m_n_line_count_start_change.ToString().Length) {
 foreach (var line in m) this.CacheLine(line, render);
 m_hs_changed_temp.Clear();
 nIndexMin = 0;
 } else {
 foreach (var v in e.TextHistoryRecord) {
 if (v.Index < nIndexMin) nIndexMin = v.Index;
 nLineIndex = m.GetLineIndexFromCharIndex(v.Index);
 var line = m[nLineIndex];
 if (m_hs_changed_temp.Contains(line)) {
 this.CacheLine(line, render);
 m_hs_changed_temp.Remove(line);
 }
 }
 }
 foreach (var line in m_hs_changed_temp) this.CacheLine(line, render);
 nLineIndex = m.GetLineIndexFromCharIndex(nIndexMin);
 for (int i = nLineIndex + 1; i < m.LineCount; i++) {
 var tag_prev = _Tag(m[i - 1]);
 _Tag(m[i]).ScreenLineOffset = tag_prev.ScreenLineOffset + tag_prev.SubLines.Count;
 }
 }

 public override void OnTextStartChange(ISTTextBoxRender render, TextManagerTextEventArgs e) {
 m_hs_changed_temp.Clear();
 m_n_line_count_start_change = base.Core.TextManager.LineCount;
 }

 public override FindInfo FindFromPoint(Point pt) {
 var c = base.Core;
 FindInfo fi = new FindInfo();
 int nXStart = base.TextRectangle.X;
 float nX = 0;// nXStart - c.Scroll.XOffset;
 int nIndexChar = 0, nCharWidth = 0;
 int nYOffset = ((pt.Y - base.TextRectangle.Y) / c.LineHeight);
 int nYValue = c.Scroll.YValue + nYOffset;
 if (nYValue < 0) nYValue = 0;
 int nIndexLine = this.GetLineIndexFromYScroll(nYValue);
 TextLine line = c.TextManager[nIndexLine];
 var tag = _Tag(line);
 //SubLineInfo subLine = tag.SubLines[0];
 if (nYValue >= tag.ScreenLineOffset + tag.SubLines.Count) {
 nYOffset -= nYValue - tag.ScreenLineOffset - tag.SubLines.Count + 1;
 }
 //if (tag.ScreenLineOffset < nYValue) {
 var temp = nYValue - tag.ScreenLineOffset;
 if (temp >= tag.SubLines.Count) {
 temp = tag.SubLines.Count - 1;
 }
 var subLine = tag.SubLines[temp];
 //}
 //nX += subLine.X;
 fi.Line = line;
 fi.IndexOfLine = nIndexLine;
 //var nXXX = subLine.ExtraWidth * 2;
 c.ITextBoxRender.BeginPaint();
 c.IGraphemeSplitter.Each(line.RawString.Substring(subLine.Index, subLine.Length), nIndexChar, (str, nStart, nLen) => {
 if (str[nStart] == '\r') return false;
 if (str[nStart] == '\n') return false;
 string strChar = str.Substring(nStart, nLen);
 nCharWidth = c.GetStringWidth(strChar, c.GetStyleFromCharIndex(line.IndexOfFirstChar + nStart), (int)nX/* - base.TextRectangle.X + c.Scroll.XOffset*/);
 //nCharWidth += (int)nXXX;
 if (nX + subLine.X + base.TextRectangle.X + nCharWidth > pt.X) {
 fi.Find = true;
 if (pt.X - base.TextRectangle.X - subLine.X - nX >= nCharWidth / 2) {
 fi.IndexOfCharInLine = subLine.Index + nIndexChar + nLen;
 fi.Location = new Point((int)nX + nCharWidth + base.TextRectangle.X + subLine.X, base.TextRectangle.Y + nYOffset * c.LineHeight);
 } else {
 fi.IndexOfCharInLine = subLine.Index + nIndexChar;
 fi.Location = new Point((int)nX + base.TextRectangle.X + subLine.X, base.TextRectangle.Y + nYOffset * c.LineHeight);
 }
 return false;
 }
 nX += nCharWidth;
 nIndexChar += nLen;
 return true;
 });
 c.ITextBoxRender.EndPaint();
 if (!fi.Find) {
 fi.IndexOfCharInLine = subLine.Index + nIndexChar;
 fi.Location = new Point((int)nX + base.TextRectangle.X + subLine.X, base.TextRectangle.Y + nYOffset * c.LineHeight);
 }
 fi.Find = true;
 //Console.WriteLine("->>>>>>>>>>>>>>>>>>>>>" + line.RawString.Substring(subLine.Index, subLine.Length) + " -- " + fi.IndexOfChar);
 return fi;
 }

 public override FindInfo FindFromCharIndex(int nIndex) {
 var c = base.Core;
 int nIndexOfLine = c.TextManager.GetLineIndexFromCharIndex(nIndex);
 TextLine stLine = c.TextManager[nIndexOfLine];
 if (stLine == null) {// TODO: stLine will not be null
 return new FindInfo();
 }
 return this.FindFromCharIndex(nIndexOfLine, nIndex - stLine.IndexOfFirstChar);
 }

 private FindInfo FindFromCharIndex(int nIndexOfLine, int nIndex) {
 var c = base.Core;
 return this.FindFromCharIndex(c.ITextBoxRender, nIndexOfLine, nIndex);
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="g"></param>
 /// <param name="stLine"></param>
 /// <param name="nIndex">Index of stLine</param>
 /// <returns></returns>
 private FindInfo FindFromCharIndex(ISTTextBoxRender render, int nIndexOfLine, int nIndex) {
 var c = base.Core;
 TextLine line = c.TextManager[nIndexOfLine];
 int nX = base.TextRectangle.X;
 int nCharWidth = 0;
 var tag = _Tag(line);
 int nSubIndex = 0;
 foreach (var sub in tag.SubLines) {
 if (nIndex >= sub.Index && nIndex < sub.Index + sub.Length) {
 break;
 }
 nSubIndex++;
 }
 var subLine = tag.SubLines[nSubIndex];
 c.IGraphemeSplitter.Each(line.RawString.Substring(subLine.Index, subLine.Length), (str, nStart, nLen) => {
 if (subLine.Index + nStart >= nIndex) {
 return false;
 }
 string strChar = str.Substring(nStart, nLen);
 nCharWidth = c.GetStringWidth(strChar, c.GetStyleFromCharIndex(line.IndexOfFirstChar + subLine.Index + nStart), nX - base.TextRectangle.X + c.Scroll.XOffset);
 nX += nCharWidth;
 return true;
 });
 return new FindInfo() {
 Line = line,
 IndexOfLine = nIndexOfLine,
 IndexOfCharInLine = nIndex,
 Location = new Point((int)nX + subLine.X, base.TextRectangle.Y + (tag.ScreenLineOffset + nSubIndex - c.Scroll.YValue) * c.LineHeight)
 };
 }

 protected override int OnDrawLine(ISTTextBoxRender render, TextLine line, int nX, int nY) {
 var c = base.Core;
 int nRet = 0;
 int nLineSpacing = c.TextBox.GetIntYSize(c.TextBox.LineSpacing) / 2;
 //nY += c.TextBox.GetIntYSize(c.TextBox.LineSpacing) / 2;
 float nXStart = 0;
 int nIndexEach = 0, nCharWidth;
 if (string.IsNullOrEmpty(line.RawString)) {
 return c.LineHeight;
 }
 int nCharSpacing = c.TextBox.GetIntXSize(c.TextBox.CharSpacing) / 2;
 int nCurrentCharIndex = line.IndexOfFirstChar + nIndexEach;
 Rectangle rect_char = new Rectangle(0, nY, 0, c.LineHeight);
 var tag = _Tag(line);
 var temp = tag.ScreenLineOffset < c.Scroll.YValue ? c.Scroll.YValue - tag.ScreenLineOffset : 0;
 for (int i = temp; i < tag.SubLines.Count; i++) {
 var subLine = tag.SubLines[i];
 nXStart = nX + subLine.X;
 rect_char.Y = nY;
 rect_char.X = nX + subLine.X;
 bool bIsEmoji = false;
 TextStyleRange tsi = TextStyleRange.Empty;
 c.IGraphemeSplitter.Each(line.RawString.Substring(subLine.Index, subLine.Length), nIndexEach, (str, nStart, nLen) => {
 nCurrentCharIndex = line.IndexOfFirstChar + subLine.Index + nStart;
 string strChar = str.Substring(nStart, nLen);
 if (c.IsEmoji(strChar)) {
 bIsEmoji = true;
 nCharWidth = c.FontHeight;
 } else {
 if (nLen > 1 && strChar[nLen - 1] >= '\uFE00' && strChar[nLen - 1] <= '\uFE0F') {
 strChar = str.Substring(nStart, nLen - 1);
 }
 bIsEmoji = false;
 nCharWidth = c.GetStringWidth(strChar, c.GetStyleFromCharIndex(line.IndexOfFirstChar + nStart), rect_char.X - subLine.X - base.TextRectangle.X) + nCharSpacing;
 }
 if (nXStart + nCharWidth <= base.TextRectangle.Left) {
 nXStart += nCharWidth;
 return true;
 }
 rect_char.Width = nCharWidth;
 if (bIsEmoji) {
 bool bSelected = nCurrentCharIndex >= c.Selection.StartIndex && nCurrentCharIndex < c.Selection.EndIndex;
 c.IEmojiRender.DrawEmoji(render, strChar, rect_char.X + (nCharSpacing >> 1), nY + nLineSpacing, c.FontHeight, bSelected);
 } else {
 c.ITextBoxRender.DrawString(strChar, c.GetStyleFromCharIndex(nCurrentCharIndex), rect_char);
 }
 rect_char.X += rect_char.Width;
 nXStart += nCharWidth;
 if (rect_char.X >= base.TextRectangle.Right) {
 return false;
 }
 return true;
 });
 nY += c.LineHeight;
 nRet += c.LineHeight;
 if (nY >= base.TextRectangle.Bottom) break;
 }
 return nRet;
 }

 protected override void OnDrawHead(ISTTextBoxRender render, int nStartLineIndex) {
 var c = base.Core;
 TextLine line = c.TextManager[nStartLineIndex];
 var tag = _Tag(line);
 var temp = tag.ScreenLineOffset < c.Scroll.YValue ? c.Scroll.YValue - tag.ScreenLineOffset : 0;

 render.FillRectangle(base.HeadBackgroundColor, base.HeadRectangle);

 var clr_temp = Color.FromArgb(base.LineNumberColor.A / 3, base.LineNumberColor);
 int nY = base.HeadRectangle.Y;
 this.DrawHeadLine(render, line, this.GetSubLineStatus(tag.SubLines.Count, temp), nStartLineIndex + 1, base.LineNumberColor, nY);
 nY += c.LineHeight;
 for (int i = temp + 1; i < tag.SubLines.Count; i++) {
 if (nY >= base.HeadRectangle.Bottom) return;
 this.DrawHeadLine(render, line, this.GetSubLineStatus(tag.SubLines.Count, i), nStartLineIndex + 1, clr_temp, nY);
 nY += c.LineHeight;
 }

 for (int i = nStartLineIndex + 1; i < c.TextManager.LineCount; i++) {
 line = c.TextManager[i];
 tag = _Tag(line);
 this.DrawHeadLine(render, line, this.GetSubLineStatus(tag.SubLines.Count, 0), i + 1, base.LineNumberColor, nY);
 nY += c.LineHeight;
 for (int j = 1; j < tag.SubLines.Count; j++) {
 if (nY >= base.HeadRectangle.Bottom) return;
 this.DrawHeadLine(render, line, this.GetSubLineStatus(tag.SubLines.Count, j), i + 1, clr_temp, nY);
 nY += c.LineHeight;
 }
 }
 }

 private void DrawHeadLine(ISTTextBoxRender render, TextLine line, SubLineStatus status, int nShowNumber, Color clr, int nY) {
 var c = base.Core;
 //int nStatusWidth = c.TextBox.GetIntXSize(base.LineStatusWidth);
 Rectangle rect_linenumber = new Rectangle(base.HeadRectangle.X, nY, base.LineNumberWidth - c.TextBox.GetIntXSize(10), c.LineHeight);
 //Rectangle rect_status = new Rectangle(base.HeadRectangle.Right - nStatusWidth, nY, nStatusWidth, c.LineHeight);
 Rectangle rect_temp = new Rectangle(base.HeadRectangle.X + c.TextBox.GetIntXSize(5), nY, c.TextBox.GetIntXSize(1), c.LineHeight);
 if (this.ShowLineNumberGuide) {
 var clr_temp = this.LineNumberGuideColor;
 switch (status) {
 case SubLineStatus.Start:
 rect_temp.Y += c.LineHeight / 2;
 rect_temp.Height -= rect_temp.Y - nY;
 render.FillRectangle(clr_temp, rect_temp.Right, rect_temp.Y, rect_temp.Width * 3, rect_temp.Width);
 break;
 //case SubLineStatus.Middle:
 case SubLineStatus.End:
 rect_temp.Height -= c.LineHeight / 2;
 render.FillRectangle(clr_temp, rect_temp.Right, rect_temp.Bottom - rect_temp.Width, rect_temp.Width * 3, rect_temp.Width);
 break;
 case SubLineStatus.None:
 rect_temp.Y += rect_temp.Width;
 rect_temp.Height -= rect_temp.Width * 2;
 rect_temp.Width = c.TextBox.GetIntXSize(4);
 clr_temp = Color.FromArgb(clr_temp.A / 3, clr_temp);
 break;
 }
 render.FillRectangle(clr_temp, rect_temp);
 }
 render.DrawString(nShowNumber.ToString(), c.TextBox.Font, clr, rect_linenumber, m_sf);
 //if (base.ShowLineStatus) {
 // if (m_hs_changed.Contains(line)) {
 // render.FillRectangle(base.LineStatusColor, rect_status);
 // }
 //}
 }

 private SubLineStatus GetSubLineStatus(int nSubLineCount, int nIndex) {
 if (nSubLineCount == 1) {
 return SubLineStatus.None;
 } else if (nIndex == 0) {
 return SubLineStatus.Start;
 } else if (nIndex == nSubLineCount - 1) {
 return SubLineStatus.End;
 } else {
 return SubLineStatus.Middle;
 }
 }

 public override int GetLineIndexFromYScroll(int nYValue) {
 var m = base.Core.TextManager;
 int nLeft = 0, nRight = m.LineCount - 1, nMid = 0;
 while (nLeft <= nRight) {
 nMid = (nLeft + nRight) >> 1;
 var tag = _Tag(m[nMid]);
 if (nYValue < tag.ScreenLineOffset) {
 nRight = nMid - 1;
 } else if (nYValue >= tag.ScreenLineOffset + tag.SubLines.Count) {
 nLeft = nMid + 1;
 } else {
 return nMid;
 }
 }
 if (nMid < 0) return 0;
 if (nMid >= m.LineCount) return m.LineCount - 1;
 return nMid;
 }

 public override void SetCaretPostion(int nCharIndex) {
 var c = this.Core;
 int nLineIndex = c.TextManager.GetLineIndexFromCharIndex(nCharIndex);
 var line = c.TextManager[nLineIndex];
 int nWidth = 0, nTempCharIndex = 0, nSubLineIndex = 0;
 var tag = _Tag(line);

 foreach (var v in tag.SubLines) {
 nTempCharIndex = line.IndexOfFirstChar + v.Index;
 if (nCharIndex >= nTempCharIndex && nCharIndex < nTempCharIndex + v.Length) {
 break;
 }
 nSubLineIndex++;
 }
 if (nSubLineIndex >= tag.SubLines.Count) {
 nSubLineIndex = tag.SubLines.Count - 1;
 }
 nTempCharIndex = nCharIndex;
 var subLine = tag.SubLines[nSubLineIndex];
 c.ITextBoxRender.BeginPaint();
 c.IGraphemeSplitter.Each(line.RawString, subLine.Index, (str, nStart, nLen) => {
 if (nStart >= nCharIndex - line.IndexOfFirstChar) return false;
 string strChar = str.Substring(nStart, nLen);
 nWidth += c.GetStringWidth(strChar, c.GetStyleFromCharIndex(line.IndexOfFirstChar + nStart), nWidth);
 nTempCharIndex = line.IndexOfFirstChar + nStart + nLen;
 return true;
 });
 c.ITextBoxRender.EndPaint();
 c.Caret.Line = line;
 c.Caret.IndexOfLine = nLineIndex;
 c.Caret.IndexOfChar = nTempCharIndex;
 this.SetCaretPostion((int)nWidth + this.TextRectangle.X + subLine.X, this.TextRectangle.Y + (tag.ScreenLineOffset + nSubLineIndex - c.Scroll.YValue) * c.LineHeight);
 }

 protected override void OnDrawLineSelectionBackground(ISTTextBoxRender render, TextLine line, int nLineIndex, STTextBoxSelectionInfo selection, int nY) {
 var c = base.Core;
 int nRet = 0;
 //nY += c.TextBox.GetIntYSize(c.TextBox.LineSpacing) / 2;
 if (string.IsNullOrEmpty(line.RawString)) {
 return;
 }
 int nCharSpacing = c.TextBox.GetIntXSize(c.TextBox.CharSpacing) / 2;
 var tag = _Tag(line);
 var temp = tag.ScreenLineOffset < c.Scroll.YValue ? c.Scroll.YValue - tag.ScreenLineOffset : 0;
 for (int i = temp; i < tag.SubLines.Count; i++) {
 var subLine = tag.SubLines[i];
 if (line.IndexOfFirstChar + subLine.Index >= selection.EndIndex) {
 return;
 }
 if (line.IndexOfFirstChar + subLine.Index + subLine.Length <= selection.StartIndex) {
 if (nY >= base.TextRectangle.Bottom) break;
 nY += c.LineHeight;
 nRet += c.LineHeight;
 continue;
 }
 int nLeft = base.TextRectangle.X + subLine.X, nWidth = subLine.Width;
 if (selection.StartIndex > line.IndexOfFirstChar + subLine.Index) {
 nLeft = this.FindFromCharIndex(render, nLineIndex, selection.StartIndex - line.IndexOfFirstChar).Location.X;
 nWidth -= nLeft - base.TextRectangle.X - subLine.X;
 }
 if (selection.EndIndex < line.IndexOfFirstChar + subLine.Index + subLine.Length) {
 int nCurrentIndex = line.IndexOfFirstChar + subLine.Index;
 nWidth = this.FindFromCharIndex(render, nLineIndex, selection.EndIndex - line.IndexOfFirstChar).Location.X;
 nWidth -= nLeft;
 }
 render.FillRectangle(c.TextBox.SelectionColor, nLeft, nY, nWidth, c.LineHeight);
 nY += c.LineHeight;
 nRet += c.LineHeight;
 if (nY >= base.TextRectangle.Bottom) break;
 }
 }

 public override void OnResize(EventArgs e) {
 base.OnResize(e);
 var c = base.Core;
 int nLineOffset = 0;
 c.ITextBoxRender.BeginPaint();
 foreach (TextLine line in c.TextManager) {
 var tag = _Tag(line);
 tag.ScreenLineOffset = nLineOffset;
 tag.SubLines = this.GetCache(line, c.ITextBoxRender);
 nLineOffset += tag.SubLines.Count;
 }
 c.ITextBoxRender.EndPaint();
 //this.ResizeScroll();
 //this.SetCaretPostion(c.Caret.IndexOfChar);
 }

 public override void OnCalcScroll(STTextBoxScrollInfo scrollInfo) {
 var c = base.Core;
 var m = c.TextManager;
 var tag = _Tag(m[m.LineCount - 1]);
 c.Scroll.MaxYValue = tag.ScreenLineOffset + tag.SubLines.Count - base.TextRectangle.Height / c.LineHeight + 2;
 if (c.Scroll.MaxYValue < 0) {
 c.Scroll.MaxYValue = 0;
 }
 if (c.Scroll.YValue > c.Scroll.MaxYValue) {
 c.Scroll.YValue = c.Scroll.MaxYValue;
 }
 //this.SetCaretPostion(c.Caret.IndexOfChar);
 }
 }
}