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

namespace Asa.FaceControl
{
    [DefaultProperty("Text")]
    [DefaultEvent("SelectedIndexChanged")]
    public partial class FaceListBox : ControlBase
    {       
        private Item _item;
        private int _itemHeight = 30;
        private int _selectedIndex = -1;
        private HorizontalAlignment _textAlign = HorizontalAlignment.Center;

        private FaceScrollBar scrollBar;
        private RectangleF[] itemRect;
        private RectangleF[] itemTextRect;
        private int itemOver = -1;
        private float itemOffset = 0;
        private float itemStep = 0;
        private bool scrollVisible;

        private readonly SolidBrush BRUSH_OVER;
        private readonly SolidBrush BRUSH_DOWN;
        private readonly SolidBrush BRUSH_LINE_1;
        private readonly SolidBrush BRUSH_LINE_2;
 

        public FaceListBox()
        {
            InitializeComponent();
            BRUSH_OVER = new SolidBrush(theme.OVER);
            BRUSH_DOWN = new SolidBrush(theme.DOWN);
            BRUSH_LINE_1 = new SolidBrush(theme.LIST_LINE_1);
            BRUSH_LINE_2 = new SolidBrush(theme.LIST_LINE_2);

            MouseUp += FaceListBox_MouseUp;
            MouseDown += FaceListBox_MouseDown;
            MouseMove += FaceListBox_MouseMove;
            MouseLeave += FaceListBox_MouseLeave;
            MouseWheel += FaceListBox_MouseWheel;
            Resize += FaceListBox_Resize;

            scrollVisible = false;
            scrollBar = new() { Visible = false };
            scrollBar.MouseEnter += ScrollBar_MouseEnter;
            scrollBar.MouseLeave += ScrollBar_MouseLeave;
            scrollBar.Scroll += ScrollBar_Scroll;
            Controls.Add(scrollBar);

            _item = new Item(ItemRefresh);
            
        }



        [Browsable(true), Category("行为"), Description("属性值更改时发生")]
        public event EventHandler SelectedIndexChanged;


        [Browsable(true), Category("外观"), Description("控件上显示的文本的对齐方式"), DefaultValue(HorizontalAlignment.Center)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public HorizontalAlignment TextAlign
        {
            get => _textAlign;
            set
            {
                _textAlign = value;
                CalcSize();
                Refresh();
            }
        }

        [Browsable(true), Category("外观"), Description(""), DefaultValue(30)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public int ItemHeight { set => _itemHeight = value; get => _itemHeight; }

        [Browsable(false)]
        public int SelectedIndex
        {
            get => _selectedIndex;
            set
            {
                if (_item.list.Count == 0)
                    _selectedIndex = -1;
                else if (value >= _item.list.Count)
                    _selectedIndex = _item.list.Count - 1;
                else if (value < 0)
                    _selectedIndex = -1;
                else
                    _selectedIndex = value;

                if (scrollVisible && _selectedIndex > -1)
                {
                    float val = (itemRect[_selectedIndex].Top - BorderWidth) / itemStep;
                    scrollBar.Value += Convert.ToInt32(val);
                }
                else
                {
                    Refresh();
                }
                SelectedIndexChanged?.Invoke(this, new EventArgs());
            }
        }

        [Browsable(false)]
        public new string Text
        {
            set
            {
                int idx = _item.list.FindIndex(match => match == value);
                SelectedIndex = idx;
            }
            get
            {
                if (_selectedIndex == -1) return "";
                return _item[_selectedIndex];
            }
        }

        [Browsable(false)]
        public Item Items { get => _item; }



        public void SelectedFirst()
        {
            SelectedIndex = 0;
        }

        public void SelectedLast()
        {
            SelectedIndex = _item.list.Count - 1;
        }

        protected override void CalcSize()
        {
            base.CalcSize();
            if (_item == null) return;

            int count = _item.list.Count;
            itemRect = new RectangleF[count];
            itemTextRect = new RectangleF[count];

            float y = BorderWidth - itemOffset;
            int width = Width - BorderWidth - BorderWidth - (scrollVisible ? scrollBar.Width : 0);

            using Graphics g = CreateGraphics();
            for (int i = 0; i < count; i++)
            {
                itemRect[i] = new RectangleF(BorderWidth, y, width, _itemHeight);
                y += _itemHeight;

                SizeF sf = g.MeasureString(_item.list[i], Font, itemRect[i].Size, stringFormat);
                itemTextRect[i] = new RectangleF(0, itemRect[i].Y + (_itemHeight - sf.Height) / 2f, sf.Width, sf.Height);
                switch (TextAlign)
                {
                    case HorizontalAlignment.Left:
                        itemTextRect[i].X = borderRect.X;
                        break;
                    case HorizontalAlignment.Center:
                        itemTextRect[i].X = borderRect.X + (width - sf.Width) / 2f;
                        break;
                    case HorizontalAlignment.Right:
                        itemTextRect[i].X = borderRect.X + width - sf.Width;
                        break;
                }
            }

            if (scrollBar != null)
            {
                scrollBar.Width = 30;
                scrollBar.Height = Height - BorderWidth - BorderWidth;
                scrollBar.Left = Width - BorderWidth - scrollBar.Width;
                scrollBar.Top = BorderWidth;
            }

        }

        protected override void DrawEnabled(Graphics g)
        {
            base.DrawEnabled(g);
            Brush brush;

            for (int i = 0; i < itemRect.Length; i++)
            {
                if (itemRect[i].Bottom < 0) continue;
                if (itemRect[i].Y > Height) continue;

                if (i == _selectedIndex)
                    brush = BRUSH_DOWN;
                else if (i == itemOver)
                    brush = BRUSH_OVER;
                else
                    brush = i % 2 == 0 ? BRUSH_LINE_1 : BRUSH_LINE_2;
                g.FillRectangle(brush, itemRect[i]);
            }

            //brush = new SolidBrush(ForeColor);
            //for (int i = 0; i < itemTextRect.Length; i++)
            //    g.DrawString(_item.list[i], Font, brush, itemTextRect[i], stringFormat);
            for (int i = 0; i < itemTextRect.Length; i++)
            {
                string text = _item.list[i];
                Brush itemBrush = new SolidBrush(ForeColor);

                if (text.Contains("<OCR>"))
                {
                    int startIndex = text.IndexOf("<OCR>");
                    int endIndex = startIndex + "<OCR>".Length;
                    string prefix = text.Substring(0, startIndex);
                    string redText = text.Substring(startIndex, endIndex - startIndex);
                    string suffix = text.Substring(endIndex);

                    SizeF prefixSize = g.MeasureString(prefix, Font);
                    SizeF redTextSize = g.MeasureString(redText, Font);

                    float x = itemTextRect[i].X + prefixSize.Width;
                    float y = itemTextRect[i].Top;

                    g.DrawString(prefix, Font, itemBrush, itemTextRect[i].Location, stringFormat);
                    g.DrawString(redText, Font, Brushes.Red, new PointF(x, y), stringFormat);
                    g.DrawString(suffix, Font, itemBrush, new PointF(x + redTextSize.Width, y), stringFormat);
                }
                else
                {
                    g.DrawString(text, Font, itemBrush, itemTextRect[i], stringFormat);
                }
            }

        }

        protected override void DrawDisabled(Graphics g)
        {
            base.DrawDisabled(g);
            Brush brush;

            for (int i = 0; i < itemRect.Length; i++)
            {
                if (itemRect[i].Bottom < 0) continue;
                if (itemRect[i].Y > Height) continue;

                brush = i % 2 == 0 ? BRUSH_LINE_1 : BRUSH_LINE_2;
                g.FillRectangle(brush, itemRect[i]);
            }

            for (int i = 0; i < itemTextRect.Length; i++)
                g.DrawString(_item.list[i], Font, BRUSH_DISABLED, itemTextRect[i], stringFormat);
        }



        private void ItemRefresh()
        {
            int height = _item.list.Count * _itemHeight + BorderWidth + BorderWidth;
            scrollVisible = height > Height;
            scrollBar.Visible = scrollVisible;
            itemOffset = 0;

            if (scrollVisible)
            {
                float n = height - Height;
                scrollBar.Maximum = Convert.ToInt32(Math.Ceiling(n / 10f));
                itemStep = n / scrollBar.Maximum;
                itemOffset = itemStep * scrollBar.Value;
            }

            CalcSize();
            Refresh();
        }

        private void FaceListBox_MouseUp(object sender, MouseEventArgs e)
        {
            SelectedIndexChanged?.Invoke(this, new EventArgs());
        }

        private void FaceListBox_MouseDown(object sender, MouseEventArgs e)
        {
            _selectedIndex = itemOver;
        }

        private void FaceListBox_MouseMove(object sender, MouseEventArgs e)
        {
            int index = Array.FindIndex(itemRect, match => match.Contains(e.Location));
            if (index != itemOver)
            {
                itemOver = index;
                Refresh();
            }
        }

        private void FaceListBox_MouseLeave(object sender, EventArgs e)
        {
            itemOver = -1;
            Refresh();
        }

        private void FaceListBox_Resize(object sender, EventArgs e)
        {
            ItemRefresh();
        }

        private void FaceListBox_MouseWheel(object sender, MouseEventArgs e)
        {
            if (!Enabled) return;
            if (e.Delta > 0)
                scrollBar.Value--;
            else
                scrollBar.Value++;
        }

        private void ScrollBar_MouseEnter(object sender, EventArgs e)
        {
            borderEnter = true;
            Refresh();
        }

        private void ScrollBar_MouseLeave(object sender, EventArgs e)
        {
            borderEnter = false;
            Refresh();
        }

        private void ScrollBar_Scroll(object sender, ScrollEventArgs e)
        {
            itemOffset = itemStep * scrollBar.Value;
            CalcSize();
            Refresh();
        }



        public class Item
        {
            internal List<string> list = new();
            private Action _action;

            public Item(Action action)
            {
                _action = action;
            }

            public string this[int index]
            {
                set
                {
                    if (index >= 0 || index < list.Count)
                    {
                        list[index] = value;
                        _action?.Invoke();
                    }
                }
                get
                {
                    if (index < 0 || index >= list.Count)
                        return "";
                    else
                        return list[index];
                }
            }

            public int Count
            {
                get => list.Count;
            }

            public void Add(string s)
            {
                if (s == null) return;
                list.Add(s);
                _action?.Invoke();
            }

            public void AddWithoutExist(string s)
            {
                if (s == null) return;
                int index = list.FindIndex(match => match == s);
                if (index > -1) return;
                list.Add(s);
                _action?.Invoke();
            }

            public void AddRange(params string[] s)
            {
                if (s == null) return;
                list.AddRange(s);
                _action?.Invoke();
            }

            public void AddRangeWithoutExist(params string[] s)
            {
                if (s == null) return;
                for (int i = 0; i < s.Length; i++)
                {
                    int index = list.FindIndex(match => match == s[i]);
                    if (index == -1) list.Add(s[i]);
                }
                _action?.Invoke();
            }

            public void Remove(string s)
            {
                if (s == null) return;

                int index = list.FindIndex(match => match == s);
                if (index != -1)
                {
                    list.RemoveAt(index);
                    _action?.Invoke();
                }
            }

            public void Clear()
            {
                list.Clear();
                _action?.Invoke();
            }

            public void RemoveAt(int index)
            {
                if (index > -1 && index < list.Count)
                {
                    list.RemoveAt(index);
                    _action?.Invoke();
                }
            }


        }

        public enum ItemChange
        {
            Add,
            AddRange,
            RemoveAt,
            Clear,
            Rename
        }

    }
}