using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Drawing;

using System.ComponentModel;

namespace ST.Library.UI.STTextBox

{

partial class STTextBox

{

public class Core

{

private Dictionary<ITextStyleMonitor, TextStyleRange> m_dic_cache_style;

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

public int LineHeight { get { return this.ITextBoxRender.GetFontHeight() + this.TextBox.GetIntYSize(this.TextBox.LineSpacing); } }

public bool IsMonospaced { get { return this.ITextBoxRender.IsMonospaced; } }

public float CharWidthFloat { get { return this.ITextBoxRender.CharWidthFloat; } }

public ITextBoundary IGraphemeSplitter { get; internal set; }

public ITextBoundary IWordSplitter { get; internal set; }

public ISTTextBoxRender ITextBoxRender { get; internal set; }

public IEmojiRender IEmojiRender { get; internal set; }

public ITextView ITextView { get; internal set; }

public ITextHistory ITextHistory { get; internal set; }

public ITextStyleMonitor[] ITextStyleMonitors { get; internal set; }

public Rectangle ViewRectangle { get; internal set; }

public STTextBox TextBox { get; private set; }

public TextManager TextManager { get; private set; }

public STTextBoxCaretInfo Caret { get; private set; }

public STTextBoxScrollInfo Scroll { get; private set; }

public STTextBoxSelectionInfo Selection { get; private set; }

internal Core(STTextBox textBox) {

if (textBox == null) {

throw new ArgumentNullException("textBox");

}

this.TextBox = textBox;

m_dic_cache_style = new Dictionary<ITextStyleMonitor, TextStyleRange>();

//GraphemeSplitter.CreateArrayCache();

//WordSplitter.CreateArrayCache();

this.IGraphemeSplitter = new GraphemeSplitter();

this.IWordSplitter = new WordSplitter();

this.ITextBoxRender = new STTextBoxGDIPRender();

this.ITextHistory = new TextHistory(10);

this.ITextView = new NoWrapTextView();

this.TextManager = new TextManager();

this.Caret = new STTextBoxCaretInfo();

this.Scroll = new STTextBoxScrollInfo();

this.Selection = new STTextBoxSelectionInfo();

var textManager = this.TextManager;

textManager.TextStartChange += (s, e) => {

this.ITextBoxRender.BeginPaint();

this.ITextView.OnTextStartChange(this.ITextBoxRender, e);

};

textManager.LineAdded += (s, e) => this.ITextView.OnLineAdded(this.ITextBoxRender, e);

textManager.LineChanged += (s, e) => this.ITextView.OnLineChanged(this.ITextBoxRender, e);

textManager.LineRemoved += (s, e) => this.ITextView.OnLineRemoved(this.ITextBoxRender, e);

textManager.LineCountChanged += (s, e) => {

this.ITextView.OnLineCountChanged(this.ITextBoxRender, e);

this.ITextView.OnCalcTextRectangle();

};

textManager.TextChanged += (s, e) => {

m_dic_cache_style.Clear();

if (this.ITextStyleMonitors != null) {

foreach (var m in this.ITextStyleMonitors) {

m.OnTextChanged(textManager, e.TextHistoryRecord);

}

}

this.ITextView.OnTextChanged(this.ITextBoxRender, e);

this.ITextBoxRender.EndPaint();

this.ITextView.OnCalcScroll(this.Scroll);

this.TextBox.Invalidate();

};

this.ITextBoxRender.BindControl(textBox);

this.ITextView.Init(this);

this.Selection.SelectionChanged += (s, e) => {

if (this.ITextStyleMonitors == null || this.ITextStyleMonitors.Length == 0) {

return;

}

m_dic_cache_style.Clear();

foreach (var m in this.ITextStyleMonitors) {

m.OnSelectionChanged(textManager, this.Selection.StartIndex, this.Selection.Length);

}

};

}

public ISTTextBoxRender SetTextBoxRender(ISTTextBoxRender render) {

//TODO: move out

var old = this.ITextBoxRender;

if (old == render) return old;

old.UnbindControl();

render.BindControl(this.TextBox);

this.ITextBoxRender = render;

if (this.ITextView != null) {

this.ITextView.Init(this);

this.ITextView.OnCalcTextRectangle();

this.ITextView.OnCalcScroll(this.Scroll);

}

this.TextBox.Invalidate();

return old;

}

public ITextStyleMonitor[] SetTextStyleMonitors(params ITextStyleMonitor[] monitors) {

var old = this.ITextStyleMonitors;

string strText = this.TextManager.GetText();

List<ITextStyleMonitor> lst = new List<ITextStyleMonitor>();

foreach (var m in monitors) {

if (m == null) {

continue;

}

lst.Add(m);

m.Init(strText);

}

this.ITextStyleMonitors = lst.ToArray();

m_dic_cache_style.Clear();

return old;

}

public bool IsEmoji(string strChar) {

if (this.IEmojiRender == null) return false;

return this.IEmojiRender.IsEmoji(strChar);

}

public bool TryGetEmoji(string text, int index, int maxLen, out int emojiLength, out string emojiStr) {

emojiLength = 0;

emojiStr = null;

if (this.IEmojiRender == null || index >= maxLen || string.IsNullOrEmpty(text)) return false;

// 1. Try grapheme cluster first (handles ZWJ sequences, skin tones, flags, surrogate pairs, BMP emojis)

if (this.IGraphemeSplitter is GraphemeSplitter gs) {

int next = gs.NextBreak(text, index);

if (next > index && next <= maxLen) {

int len = next - index;

string str = text.Substring(index, len);

if (this.IsEmoji(str)) {

emojiLength = len;

emojiStr = str;

return true;

}

}

}

// 2. Fallback: try surrogate pair (length 2) if high surrogate

char ch = text[index];

if (char.IsHighSurrogate(ch) && index + 1 < maxLen && char.IsLowSurrogate(text[index + 1])) {

string str = text.Substring(index, 2);

if (this.IsEmoji(str)) {

emojiLength = 2;

emojiStr = str;

return true;

}

}

// 3. Fallback: try single character (length 1, for BMP emojis like ☺, ⚽, ⚡)

string singleStr = text.Substring(index, 1);

if (this.IsEmoji(singleStr)) {

emojiLength = 1;

emojiStr = singleStr;

return true;

}

return false;

}

public int GetStringWidth(string strText, TextStyle textStyle, int nLeftWidth) {

if (this.IsEmoji(strText)) {

return this.FontHeight;

}

if (strText.Length > 1 && strText[strText.Length - 1] >= '\uFE00' && strText[strText.Length - 1] <= '\uFE0F') {

strText = strText.Substring(0, strText.Length - 1);

}

return this.ITextBoxRender.GetStringWidth(strText, textStyle, nLeftWidth) + this.TextBox.GetIntXSize(this.TextBox.CharSpacing);

}

public float GetStringWidthFloat(string strText, TextStyle textStyle, float fLeftWidth) {

if (this.IsEmoji(strText)) {

return (float)this.FontHeight;

}

if (strText.Length > 1 && strText[strText.Length - 1] >= '\uFE00' && strText[strText.Length - 1] <= '\uFE0F') {

strText = strText.Substring(0, strText.Length - 1);

}

return this.ITextBoxRender.GetStringWidthFloat(strText, textStyle, fLeftWidth) + (float)this.TextBox.GetIntXSize(this.TextBox.CharSpacing);

}

public TextStyle GetStyleFromCharIndex(int nIndex) {

TextStyle style = new TextStyle();

if (this.ITextStyleMonitors == null || this.ITextStyleMonitors.Length == 0) {

style.ForeColor = this.TextBox.ForeColor;

return style;

}

var range = TextStyleRange.Empty;

foreach (var m in this.ITextStyleMonitors) {

if (m_dic_cache_style.ContainsKey(m)) {

range = m_dic_cache_style[m];

if (nIndex >= range.Index && nIndex < range.Index + range.Length) {

if (range.Style.RejectMix) return range.Style;

style.Mix(range.Style);

continue;

}

}

range = m.GetStyleFromCharIndex(nIndex);

if (range == TextStyleRange.Empty) continue;

if (m_dic_cache_style.ContainsKey(m)) {

m_dic_cache_style[m] = range;

} else {

m_dic_cache_style.Add(m, range);

}

if (range.Style.RejectMix) return range.Style;

style.Mix(range.Style);

}

if (style.ForeColor.A == 0) {

style.ForeColor = this.TextBox.ForeColor;

}

return style;

}

}

public ISTTextBoxRender SetTextBoxRender(ISTTextBoxRender render) {

if (render == null) {

throw new ArgumentNullException("render");

}

return m_core.SetTextBoxRender(render);

}

public ITextBoundary SetGraphemeSplitter(ITextBoundary textBoundary) {

if (textBoundary == null) {

throw new ArgumentNullException("textBoundary");

}

if (m_core.IGraphemeSplitter == textBoundary) {

return textBoundary;

}

var old = m_core.IGraphemeSplitter;

m_core.IGraphemeSplitter = textBoundary;

return old;

}

public ITextBoundary SetWordSplitter(ITextBoundary textBoundary) {

if (textBoundary == null) {

throw new ArgumentNullException("textBoundary");

}

if (m_core.IWordSplitter == textBoundary) {

return textBoundary;

}

var old = m_core.IWordSplitter;

m_core.IWordSplitter = textBoundary;

return old;

}

public IEmojiRender SetEmojiRender(IEmojiRender emojiRender) {

if (emojiRender == null) {

throw new ArgumentNullException("emojiRender");

}

if (m_core.IEmojiRender == emojiRender) {

return emojiRender;

}

var old = m_core.IEmojiRender;

m_core.IEmojiRender = emojiRender;

return old;

}

public ITextHistory SetTextHistory(ITextHistory textHistory) {

if (m_core.ITextHistory == textHistory) {

return textHistory;

}

var old = m_core.ITextHistory;

m_core.ITextHistory = textHistory;

return old;

}

public ITextView SetTextView(ITextView textView) {

if (textView == null) {

throw new ArgumentNullException("textView");

}

if (m_core.ITextView == textView) {

return textView;

}

var old = m_core.ITextView;

m_core.ITextView = textView;

textView.Init(m_core);

textView.OnCalcTextRectangle();

textView.OnCalcScroll(m_core.Scroll);

return old;

}

public ITextStyleMonitor[] SetTextStyleMonitors(params ITextStyleMonitor[] monitors) {

return m_core.SetTextStyleMonitors(monitors);

}

}

}