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

namespace ST.Library.UI.STTextBox
{
 public class TextManager : IEnumerable<TextLine>
 {
 public int LineCount {
 get { return m_nLineCount; }
 }

 public int TextLength {
 get { return m_nTextLength; }
 }

 public TextLine this[int nIndex] {
 get {
 if (nIndex < 0 || nIndex >= m_nLineCount) {
 throw new ArgumentOutOfRangeException("nIndex");
 }
 return m_lines[nIndex];
 }
 }

 private int m_nLineCount;
 private int m_nTextLength;
 private TextLine[] m_lines;

 public TextManager() {
 m_lines = new TextLine[2];
 m_lines[0] = new TextLine();
 m_nLineCount++;
 }

 public event TextManagerLineEventHandler LineAdded;
 public event TextManagerLineEventHandler LineRemoved;
 public event TextManagerLineEventHandler LineChanged;
 public event TextManagerTextEventHandler TextChanged;
 public event TextManagerTextEventHandler TextStartChange;
 public event EventHandler LineCountChanged;

 #region Event

 protected virtual void OnTextStartChange(TextManagerTextEventArgs e) {
 if (this.TextStartChange != null) {
 this.TextStartChange(this, e);
 }
 }

 protected virtual void OnLineAdded(TextManagerLineEventArgs e) {
 if (this.LineAdded != null) {
 this.LineAdded(this, e);
 }
 }

 protected virtual void OnRemoveLine(TextManagerLineEventArgs e) {
 if (this.LineRemoved != null) {
 this.LineRemoved(this, e);
 }
 }

 protected virtual void OnTextChanged(TextManagerTextEventArgs e) {
 if (this.TextChanged != null) {
 this.TextChanged(this, e);
 }
 }

 protected virtual void OnLineChanged(TextManagerLineEventArgs e) {
 if (this.LineChanged != null) {
 this.LineChanged(this, e);
 }
 }

 protected virtual void OnLineCountChanged(EventArgs e) {
 if (this.LineCountChanged != null) {
 this.LineCountChanged(this, e);
 }
 }

 #endregion

 public string GetText() {
 return this.GetStringBuilder(0, m_nTextLength).ToString();
 }

 public string GetText(int nIndex, int nLen) {
 return this.GetStringBuilder(nIndex, nLen).ToString();
 }

 public StringBuilder GetStringBuilder() {
 return this.GetStringBuilder(0, m_nTextLength);
 }

 public StringBuilder GetStringBuilder(int nIndex, int nLen) {
 StringBuilder sb = new StringBuilder();
 if (nLen == 0) {
 return sb;
 }
 int nIndexStart = this.GetLineIndexFromCharIndex(nIndex);
 int nIndexEnd = this.GetLineIndexFromCharIndex(nIndex + nLen);
 TextLine stLineStart = this[nIndexStart];
 TextLine stLineEnd = this[nIndexEnd];
 if (stLineStart == stLineEnd) {
 sb.Append(stLineStart.RawString.Substring(nIndex - stLineStart.IndexOfFirstChar, nLen));
 return sb;
 }
 int nLenAdded = 0;
 sb.Append(stLineStart.RawString.Substring(nIndex - stLineStart.IndexOfFirstChar));
 nLenAdded += sb.Length;
 for (int i = nIndexStart + 1; i < nIndexEnd; i++) {
 sb.Append(this[i].RawString);
 nLenAdded += this[i].RawString.Length;
 }
 sb.Append(stLineEnd.RawString.Substring(0, nLen - nLenAdded));
 return sb;
 }

 public TextHistoryRecord SetText(string strText) {
 return this.SetText(0, m_nTextLength, strText);
 }

 public TextHistoryRecord SetText(int nIndex, string strText) {
 return this.SetText(nIndex, 0, strText);
 }
 /// <summary>
 /// Modify the source text
 /// </summary>
 /// <param name="nIndex">The index from source string</param>
 /// <param name="nLen">The length of the text to be deleted</param>
 /// <param name="strText">The text that will be add</param>
 public TextHistoryRecord SetText(int nIndex, int nLen, string strText) {
 return this.SetText(nIndex, nLen, strText, false);
 }

 public TextHistoryRecord[] RunHistory(TextHistoryRecord[] histories) {
 if (histories == null || histories.Length == 0) {
 return new TextHistoryRecord[0];
 }
 int nLineCount = m_nLineCount;
 this.OnTextStartChange(new TextManagerTextEventArgs(new List<TextHistoryRecord>(histories)));
 var ret = new TextHistoryRecord[histories.Length];
 for (int i = 0; i < histories.Length; i++) {
 var h = histories[i];
 ret[i] = this.SetText(h.Index, h.OldText.Length, h.NewText, true);
 }
 if (m_nLineCount != nLineCount) {
 this.OnLineCountChanged(EventArgs.Empty);
 }
 this.OnTextChanged(new TextManagerTextEventArgs(new List<TextHistoryRecord>(ret)));
 return ret;
 }

 public int Clear() {
 int nRet = m_nTextLength;
 m_lines = new TextLine[2];
 m_lines[0] = new TextLine();
 m_nLineCount = 1;
 m_nTextLength = 0;
 return nRet;
 }

 public TextLine GetLineFromCharIndex(int nIndex) {
 nIndex = this.GetLineIndexFromCharIndex(nIndex);
 return m_lines[nIndex];
 }

 public int GetLineIndexFromCharIndex(int nIndex) {
 if (m_nLineCount == 0) {
 return -1;
 }
 if (nIndex <= 0) {
 return 0;
 }
 if (nIndex >= m_lines[m_nLineCount - 1].IndexOfFirstChar + m_lines[m_nLineCount - 1].RawString.Length) {
 return m_nLineCount - 1;
 }
 int nLeft = 0, nRight = m_nLineCount - 1, nMid = 0;
 while (nLeft <= nRight) {
 nMid = (nRight + nLeft) >> 1;
 if (nIndex >= m_lines[nMid].IndexOfFirstChar + m_lines[nMid].RawString.Length) {
 nLeft = nMid + 1;
 } else if (nIndex < m_lines[nMid].IndexOfFirstChar) {
 nRight = nMid - 1;
 } else {
 return nMid;
 }
 }
 return -1;
 }

 public int GetLineIndexFromLine(TextLine line) {
 int nLeft = 0, nRight = m_nLineCount - 1, nMid = 0;
 while (nLeft <= nRight) {
 nMid = (nLeft + nRight) >> 1;
 if (line.IndexOfFirstChar < m_lines[nMid].IndexOfFirstChar) {
 nRight = nMid - 1;
 } else if (line.IndexOfFirstChar > m_lines[nMid].IndexOfFirstChar) {
 nLeft = nMid + 1;
 } else {
 if (m_lines[nMid] == line) {
 return nMid;
 }
 return -1;
 }
 }
 return -1;
 }

 public TextHistoryRecord[] InsertAtStart(int nLineIndex, int nLineCount, string strText) {
 if (nLineIndex < 0) {
 nLineCount += nLineCount;
 nLineIndex = 0;
 }
 if (nLineIndex >= m_nLineCount) {
 return new TextHistoryRecord[0];
 }
 if (nLineIndex + nLineCount > m_nLineCount) {
 nLineCount = m_nLineCount - nLineIndex;
 }
 TextHistoryRecord[] lst = new TextHistoryRecord[nLineCount];
 this.OnTextStartChange(new TextManagerTextEventArgs(new List<TextHistoryRecord>(lst)));
 int nAddCounter = 0;
 for (int i = 0; i < nLineCount; i++) {
 var line = m_lines[nLineIndex + i];
 line.RawString = strText + line.RawString;
 line.IndexOfFirstChar += nAddCounter;
 var thr = new TextHistoryRecord() {
 Index = line.IndexOfFirstChar,
 OldText = string.Empty,
 NewText = strText
 };
 lst[i] = thr;
 this.OnLineChanged(new TextManagerLineEventArgs(nLineIndex + i, line, thr));
 nAddCounter += strText.Length;
 }
 for (int i = nLineIndex + nLineCount; i < m_nLineCount; i++) {
 m_lines[i].IndexOfFirstChar += nAddCounter;
 }
 m_nTextLength += nAddCounter;
 this.OnTextChanged(new TextManagerTextEventArgs(new List<TextHistoryRecord>(lst)));
 return lst;
 }

 public List<TextHistoryRecord> TrimStartTab(int nLineIndex, int nLineCount, int nTabSize) {
 List<TextHistoryRecord> lst = new List<TextHistoryRecord>();
 if (nLineIndex < 0) {
 nLineCount += nLineCount;
 nLineIndex = 0;
 }
 if (nLineIndex >= m_nLineCount) {
 return lst;
 }
 if (nLineIndex + nLineCount > m_nLineCount) {
 nLineCount = m_nLineCount - nLineIndex;
 }
 bool bStarted = false;
 int nRemoveCounter = 0, nRemoveLen = 0;
 for (int i = 0; i < nLineCount; i++) {
 nRemoveLen = 0;
 var thr = new TextHistoryRecord();
 var line = m_lines[nLineIndex + i];
 if (line.RawString[0] == '\t') {
 nRemoveLen = 1;
 } else {
 while (nRemoveLen < nTabSize) {
 switch (line.RawString[nRemoveLen]) {
 case ' ':
 nRemoveLen++;
 continue;
 case '\t':
 nRemoveLen++;
 continue;
 default:
 break;
 }
 break;
 }
 }
 line.IndexOfFirstChar -= nRemoveCounter;
 if (nRemoveLen == 0) continue;
 if (!bStarted) {
 this.OnTextStartChange(new TextManagerTextEventArgs(lst));
 bStarted = true;
 }
 thr.OldText = line.RawString.Substring(0, nRemoveLen);
 thr.Index = line.IndexOfFirstChar;
 thr.NewText = "";
 line.RawString = line.RawString.Substring(nRemoveLen);
 nRemoveCounter += nRemoveLen;
 this.OnLineChanged(new TextManagerLineEventArgs(nLineIndex + i, line, thr));
 lst.Add(thr);
 }
 if (lst.Count == 0) return lst;
 for (int i = nLineIndex + nLineCount; i < m_nLineCount; i++) {
 m_lines[i].IndexOfFirstChar -= nRemoveCounter;
 }
 m_nTextLength -= nRemoveCounter;
 this.OnTextChanged(new TextManagerTextEventArgs(lst));
 return lst;
 }

 #region Private

 private TextHistoryRecord SetText(int nIndex, int nLen, string strText, bool isHistory) {
 if (strText == null) {
 strText = "";
 }
 string strOld = string.Empty;
 if (nLen != 0) {
 strOld = this.GetText(nIndex, nLen);
 }
 if (strOld == strText) {
 return TextHistoryRecord.Empty;
 }
 var historyRecord = new TextHistoryRecord() {
 Index = nIndex,
 OldText = strOld,
 NewText = strText
 };
 if (!isHistory) {
 var lstHistory = new List<TextHistoryRecord>() { historyRecord };
 this.OnTextStartChange(new TextManagerTextEventArgs(lstHistory));
 historyRecord = lstHistory[0];
 }
 List<TextLine> lst = this.GetTexLines(historyRecord.NewText);
 int nIndexStartLine = this.GetLineIndexFromCharIndex(nIndex);
 int nIndexEndLine = this.GetLineIndexFromCharIndex(nIndex + nLen);
 var line_start = m_lines[nIndexStartLine];
 var line_end = m_lines[nIndexEndLine];
 string strLeft = line_start.RawString.Substring(0, nIndex - line_start.IndexOfFirstChar);
 string strRight = line_end.RawString.Substring(nIndex + nLen - line_end.IndexOfFirstChar);

 lst[0].RawString = strLeft + lst[0].RawString;
 lst[0].IndexOfFirstChar = line_start.IndexOfFirstChar;
 lst[lst.Count - 1].RawString += strRight;
 int nIncrement = historyRecord.NewText.Length - nLen;
 m_nTextLength += nIncrement;

 line_start.RawString = lst[0].RawString;
 this.OnLineChanged(new TextManagerLineEventArgs(strLeft.Length, line_start, historyRecord));

 int nShouldRemoveLines = nIndexEndLine - nIndexStartLine;
 int nShouldAddLines = lst.Count - 1 - nShouldRemoveLines;
 for (int i = nIndexStartLine + 1; i <= nIndexEndLine; i++) {
 this.OnRemoveLine(new TextManagerLineEventArgs(i, m_lines[i], historyRecord));
 }
 if (nShouldAddLines > 0) {
 this.InsertEmptyLines(nIndexStartLine, nShouldAddLines, nIncrement);
 } else {
 this.RemoveLines(nIndexStartLine + 1, -nShouldAddLines, nIncrement, historyRecord);
 }
 for (int i = 1, j = nIndexStartLine + 1; i < lst.Count; i++, j++) {
 var prev_line = m_lines[j - 1];
 m_lines[j] = lst[i];
 m_lines[j].IndexOfFirstChar = prev_line.IndexOfFirstChar + prev_line.RawString.Length;
 this.OnLineAdded(new TextManagerLineEventArgs(j, m_lines[j], historyRecord));
 }
 if (nShouldAddLines == 0) {
 for (int i = nIndexStartLine + 1; i < m_nLineCount; i++) {
 TextLine prve_line = m_lines[i - 1];
 m_lines[i].IndexOfFirstChar = prve_line.IndexOfFirstChar + prve_line.RawString.Length;
 }
 } else {
 m_nLineCount += nShouldAddLines;
 if (!isHistory) {
 this.OnLineCountChanged(EventArgs.Empty);
 }
 }
 if (!isHistory) {
 this.OnTextChanged(new TextManagerTextEventArgs(new List<TextHistoryRecord>() { historyRecord }));
 }
 return historyRecord;
 }

 private List<TextLine> GetTexLines(string strText) {
 int nIndexStart = 0, nLen = 0;
 TextLine line = new TextLine();
 List<TextLine> lst = new List<TextLine>();
 lst.Add(line);
 for (int i = 0; i < strText.Length; i++) {
 char c = strText[i];
 nLen++;
 if (c == '\n' || c == '\r') {
 if (c == '\r' && i + 1 < strText.Length && strText[i + 1] == '\n') {
 nLen++;
 i++;
 }
 line.RawString = strText.Substring(nIndexStart, nLen);
 line = new TextLine();
 lst.Add(line);
 nIndexStart = i + 1;
 nLen = 0;
 }
 }
 if (nLen != 0) {
 line.RawString = strText.Substring(nIndexStart, nLen);
 }
 return lst;
 }

 private void InsertEmptyLines(int nIndex, int nCount, int nOffsetIncrement) {
 if (nCount == 0) return;
 this.EnsureSpace(nCount);
 for (int i = m_nLineCount + nCount - 1; i > nIndex + nCount; i--) {
 m_lines[i] = m_lines[i - nCount];
 if (m_lines[i] == null) {
 m_lines[i] = new TextLine();
 }
 m_lines[i].IndexOfFirstChar += nOffsetIncrement;
 }
 }

 private void RemoveLines(int nIndex, int nCount, int nOffsetIncrement, TextHistoryRecord history) {
 if (nCount == 0) return;
 int nCounter = nCount;
 for (int i = nIndex; i < m_nLineCount - nCount; i++) {
 if (nCounter > 0) {
 nCounter--;
 }
 m_lines[i] = m_lines[i + nCount];
 m_lines[i].IndexOfFirstChar += nOffsetIncrement;
 }
 }

 private void EnsureSpace(int nCount) {
 if (m_nLineCount + nCount <= m_lines.Length) {
 return;
 }
 int nLen = m_nLineCount + nCount;
 TextLine[] new_arr = new TextLine[Math.Max(m_nLineCount + nCount, m_lines.Length << 1)];
 Array.Copy(m_lines, new_arr, m_lines.Length);
 m_lines = new_arr;
 }

 #endregion

 #region Interface

 public IEnumerator<TextLine> GetEnumerator() {
 for (int i = 0; i < m_nLineCount; i++) {
 yield return m_lines[i];
 }
 }

 IEnumerator IEnumerable.GetEnumerator() {
 return this.GetEnumerator();
 }

 #endregion
 }
}