#region Imports

using DPumpHydr.WinFrmUI.RLT.Extension.Crown;
using DPumpHydr.WinFrmUI.RLT.Util;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using static DPumpHydr.WinFrmUI.RLT.Helper.CrownHelper;

#endregion

namespace DPumpHydr.WinFrmUI.RLT.Controls
{
    #region CrownTreeView

    public class CrownTreeView : CrownScrollView
    {
        #region Event Region

        public event EventHandler SelectedNodesChanged;
        public event EventHandler AfterNodeExpand;
        public event EventHandler AfterNodeCollapse;

        #endregion

        #region Field Region

        private bool _disposed;

        private readonly int _expandAreaSize = 16;
        private readonly int _iconSize = 16;

        private int _itemHeight = 20;
        private int _indent = 20;

        private ObservableList<CrownTreeNode> _nodes;
        private CrownTreeNode _anchoredNodeStart;
        private CrownTreeNode _anchoredNodeEnd;

        private Bitmap _nodeClosed;
        private Bitmap _nodeClosedHover;
        private Bitmap _nodeClosedHoverSelected;
        private Bitmap _nodeOpen;
        private Bitmap _nodeOpenHover;
        private Bitmap _nodeOpenHoverSelected;

        private CrownTreeNode _provisionalNode;
        private CrownTreeNode _dropNode;
        private bool _provisionalDragging;
        private List<CrownTreeNode> _dragNodes;
        private Point _dragPos;

        #endregion

        #region Property Region

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ObservableList<CrownTreeNode> Nodes
        {
            get => _nodes;
            set
            {
                if (_nodes != null)
                {
                    _nodes.ItemsAdded -= Nodes_ItemsAdded;
                    _nodes.ItemsRemoved -= Nodes_ItemsRemoved;

                    foreach (CrownTreeNode node in _nodes)
                    {
                        UnhookNodeEvents(node);
                    }
                }

                _nodes = value;

                _nodes.ItemsAdded += Nodes_ItemsAdded;
                _nodes.ItemsRemoved += Nodes_ItemsRemoved;

                foreach (CrownTreeNode node in _nodes)
                {
                    HookNodeEvents(node);
                }

                UpdateNodes();
            }
        }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ObservableCollection<CrownTreeNode> SelectedNodes { get; }

        [Category("Appearance")]
        [Description("Determines the height of tree nodes.")]
        [DefaultValue(20)]
        public int ItemHeight
        {
            get => _itemHeight;
            set
            {
                _itemHeight = value;
                MaxDragChange = _itemHeight;
                UpdateNodes();
            }
        }

        [Category("Appearance")]
        [Description("Determines the amount of horizontal space given by parent node.")]
        [DefaultValue(20)]
        public int Indent
        {
            get => _indent;
            set
            {
                _indent = value;
                UpdateNodes();
            }
        }

        [Category("Behavior")]
        [Description("Determines whether multiple tree nodes can be selected at once.")]
        [DefaultValue(false)]
        public bool MultiSelect { get; set; }

        [Category("Behavior")]
        [Description("Determines whether nodes can be moved within this tree view.")]
        [DefaultValue(false)]
        public bool AllowMoveNodes { get; set; }

        [Category("Appearance")]
        [Description("Determines whether icons are rendered with the tree nodes.")]
        [DefaultValue(false)]
        public bool ShowIcons { get; set; }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int VisibleNodeCount { get; private set; }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public IComparer<CrownTreeNode> TreeViewNodeSorter { get; set; }

        #endregion

        #region Constructor Region

        public CrownTreeView()
        {
            Nodes = new ObservableList<CrownTreeNode>();
            SelectedNodes = new ObservableCollection<CrownTreeNode>();
            SelectedNodes.CollectionChanged += SelectedNodes_CollectionChanged;

            MaxDragChange = _itemHeight;

            LoadIcons();
        }

        #endregion

        #region Dispose Region

        protected override void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                DisposeIcons();

                if (SelectedNodesChanged != null)
                {
                    SelectedNodesChanged = null;
                }

                if (AfterNodeExpand != null)
                {
                    AfterNodeExpand = null;
                }

                if (AfterNodeCollapse != null)
                {
                    AfterNodeExpand = null;
                }

                if (_nodes != null)
                {
                    _nodes.Dispose();
                }

                if (SelectedNodes != null)
                {
                    SelectedNodes.CollectionChanged -= SelectedNodes_CollectionChanged;
                }

                _disposed = true;
            }

            base.Dispose(disposing);
        }

        #endregion

        #region Event Handler Region

        private void Nodes_ItemsAdded(object sender, ObservableListModified<CrownTreeNode> e)
        {
            foreach (CrownTreeNode node in e.Items)
            {
                node.ParentTree = this;
                node.IsRoot = true;

                HookNodeEvents(node);
            }

            if (TreeViewNodeSorter != null)
            {
                Nodes.Sort(TreeViewNodeSorter);
            }

            UpdateNodes();
        }

        private void Nodes_ItemsRemoved(object sender, ObservableListModified<CrownTreeNode> e)
        {
            foreach (CrownTreeNode node in e.Items)
            {
                node.ParentTree = this;
                node.IsRoot = true;

                HookNodeEvents(node);
            }

            UpdateNodes();
        }

        private void ChildNodes_ItemsAdded(object sender, ObservableListModified<CrownTreeNode> e)
        {
            foreach (CrownTreeNode node in e.Items)
            {
                HookNodeEvents(node);
            }

            UpdateNodes();
        }

        private void ChildNodes_ItemsRemoved(object sender, ObservableListModified<CrownTreeNode> e)
        {
            foreach (CrownTreeNode node in e.Items)
            {
                if (SelectedNodes.Contains(node))
                {
                    SelectedNodes.Remove(node);
                }

                UnhookNodeEvents(node);
            }

            UpdateNodes();
        }

        private void SelectedNodes_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            SelectedNodesChanged?.Invoke(this, null);
        }

        private void Nodes_TextChanged(object sender, EventArgs e)
        {
            UpdateNodes();
        }

        private void Nodes_NodeExpanded(object sender, EventArgs e)
        {
            UpdateNodes();

            AfterNodeExpand?.Invoke(this, null);
        }

        private void Nodes_NodeCollapsed(object sender, EventArgs e)
        {
            UpdateNodes();

            AfterNodeCollapse?.Invoke(this, null);
        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
            if (_provisionalDragging)
            {
                if (OffsetMousePosition != _dragPos)
                {
                    StartDrag();
                    HandleDrag();
                    return;
                }
            }

            if (IsDragging)
            {
                if (_dropNode != null)
                {
                    Rectangle rect = GetNodeFullRowArea(_dropNode);
                    if (!rect.Contains(OffsetMousePosition))
                    {
                        _dropNode = null;
                        Invalidate();
                    }
                }
            }

            CheckHover();

            if (IsDragging)
            {
                HandleDrag();
            }

            base.OnMouseMove(e);
        }

        protected override void OnMouseWheel(MouseEventArgs e)
        {
            CheckHover();

            base.OnMouseWheel(e);
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (e.Button is MouseButtons.Left or MouseButtons.Right)
            {
                foreach (CrownTreeNode node in Nodes)
                {
                    CheckNodeClick(node, OffsetMousePosition, e.Button);
                }
            }

            base.OnMouseDown(e);
        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            if (IsDragging)
            {
                HandleDrop();
            }

            if (_provisionalDragging)
            {

                if (_provisionalNode != null)
                {
                    Point pos = _dragPos;
                    if (OffsetMousePosition == pos)
                    {
                        SelectNode(_provisionalNode);
                    }
                }

                _provisionalDragging = false;
            }

            base.OnMouseUp(e);
        }

        protected override void OnMouseDoubleClick(MouseEventArgs e)
        {
            if (ModifierKeys == Keys.Control)
            {
                return;
            }

            if (e.Button == MouseButtons.Left)
            {
                foreach (CrownTreeNode node in Nodes)
                {
                    CheckNodeDoubleClick(node, OffsetMousePosition);
                }
            }

            base.OnMouseDoubleClick(e);
        }

        protected override void OnMouseLeave(EventArgs e)
        {
            base.OnMouseLeave(e);

            foreach (CrownTreeNode node in Nodes)
            {
                NodeMouseLeave(node);
            }
        }

        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown(e);

            if (IsDragging)
            {
                return;
            }

            if (Nodes.Count == 0)
            {
                return;
            }

            if (e.KeyCode is not Keys.Down and not Keys.Up and not Keys.Left and not Keys.Right)
            {
                return;
            }

            if (_anchoredNodeEnd == null)
            {
                if (Nodes.Count > 0)
                {
                    SelectNode(Nodes[0]);
                }

                return;
            }

            if (e.KeyCode is Keys.Down or Keys.Up)
            {
                if (MultiSelect && ModifierKeys == Keys.Shift)
                {
                    if (e.KeyCode == Keys.Up)
                    {
                        if (_anchoredNodeEnd.PrevVisibleNode != null)
                        {
                            SelectAnchoredRange(_anchoredNodeEnd.PrevVisibleNode);
                            EnsureVisible();
                        }
                    }
                    else if (e.KeyCode == Keys.Down)
                    {
                        if (_anchoredNodeEnd.NextVisibleNode != null)
                        {
                            SelectAnchoredRange(_anchoredNodeEnd.NextVisibleNode);
                            EnsureVisible();
                        }
                    }
                }
                else
                {
                    if (e.KeyCode == Keys.Up)
                    {
                        if (_anchoredNodeEnd.PrevVisibleNode != null)
                        {
                            SelectNode(_anchoredNodeEnd.PrevVisibleNode);
                            EnsureVisible();
                        }
                    }
                    else if (e.KeyCode == Keys.Down)
                    {
                        if (_anchoredNodeEnd.NextVisibleNode != null)
                        {
                            SelectNode(_anchoredNodeEnd.NextVisibleNode);
                            EnsureVisible();
                        }
                    }
                }
            }

            if (e.KeyCode is Keys.Left or Keys.Right)
            {
                if (e.KeyCode == Keys.Left)
                {
                    if (_anchoredNodeEnd.Expanded && _anchoredNodeEnd.Nodes.Count > 0)
                    {
                        _anchoredNodeEnd.Expanded = false;
                    }
                    else
                    {
                        if (_anchoredNodeEnd.ParentNode != null)
                        {
                            SelectNode(_anchoredNodeEnd.ParentNode);
                            EnsureVisible();
                        }
                    }
                }
                else if (e.KeyCode == Keys.Right)
                {
                    if (!_anchoredNodeEnd.Expanded)
                    {
                        _anchoredNodeEnd.Expanded = true;
                    }
                    else
                    {
                        if (_anchoredNodeEnd.Nodes.Count > 0)
                        {
                            SelectNode(_anchoredNodeEnd.Nodes[0]);
                            EnsureVisible();
                        }
                    }
                }
            }
        }

        private void DragTimer_Tick(object sender, EventArgs e)
        {
            if (!IsDragging)
            {
                StopDrag();
                return;
            }

            if (MouseButtons != MouseButtons.Left)
            {
                StopDrag();
                return;
            }

            Point pos = PointToClient(MousePosition);

            if (_vScrollBar.Visible)
            {
                // Scroll up
                if (pos.Y < ClientRectangle.Top)
                {
                    int difference = (pos.Y - ClientRectangle.Top) * -1;

                    if (difference > ItemHeight)
                    {
                        difference = ItemHeight;
                    }

                    _vScrollBar.Value -= difference;
                }

                // Scroll down
                if (pos.Y > ClientRectangle.Bottom)
                {
                    int difference = pos.Y - ClientRectangle.Bottom;

                    if (difference > ItemHeight)
                    {
                        difference = ItemHeight;
                    }

                    _vScrollBar.Value += difference;
                }
            }

            if (_hScrollBar.Visible)
            {
                // Scroll left
                if (pos.X < ClientRectangle.Left)
                {
                    int difference = (pos.X - ClientRectangle.Left) * -1;

                    if (difference > ItemHeight)
                    {
                        difference = ItemHeight;
                    }

                    _hScrollBar.Value -= difference;
                }

                // Scroll right
                if (pos.X > ClientRectangle.Right)
                {
                    int difference = pos.X - ClientRectangle.Right;

                    if (difference > ItemHeight)
                    {
                        difference = ItemHeight;
                    }

                    _hScrollBar.Value += difference;
                }
            }
        }

        #endregion

        #region Method Region

        private void HookNodeEvents(CrownTreeNode node)
        {
            node.Nodes.ItemsAdded += ChildNodes_ItemsAdded;
            node.Nodes.ItemsRemoved += ChildNodes_ItemsRemoved;

            node.TextChanged += Nodes_TextChanged;
            node.NodeExpanded += Nodes_NodeExpanded;
            node.NodeCollapsed += Nodes_NodeCollapsed;

            foreach (CrownTreeNode childNode in node.Nodes)
            {
                HookNodeEvents(childNode);
            }
        }

        private void UnhookNodeEvents(CrownTreeNode node)
        {
            node.Nodes.ItemsAdded -= ChildNodes_ItemsAdded;
            node.Nodes.ItemsRemoved -= ChildNodes_ItemsRemoved;

            node.TextChanged -= Nodes_TextChanged;
            node.NodeExpanded -= Nodes_NodeExpanded;
            node.NodeCollapsed -= Nodes_NodeCollapsed;

            foreach (CrownTreeNode childNode in node.Nodes)
            {
                UnhookNodeEvents(childNode);
            }
        }

        private void UpdateNodes()
        {
            if (IsDragging)
            {
                return;
            }

            ContentSize = new(0, 0);

            if (Nodes.Count == 0)
            {
                return;
            }

            int yOffset = 0;
            bool isOdd = false;
            int index = 0;
            CrownTreeNode prevNode = null;

            for (int i = 0; i <= Nodes.Count - 1; i++)
            {
                CrownTreeNode node = Nodes[i];
                UpdateNode(node, ref prevNode, 0, ref yOffset, ref isOdd, ref index);
            }

            ContentSize = new(ContentSize.Width, yOffset);

            VisibleNodeCount = index;

            Invalidate();
        }

        private void UpdateNode(CrownTreeNode node, ref CrownTreeNode prevNode, int indent, ref int yOffset,
                                ref bool isOdd, ref int index)
        {
            UpdateNodeBounds(node, yOffset, indent);

            yOffset += ItemHeight;

            node.Odd = isOdd;
            isOdd = !isOdd;

            node.VisibleIndex = index;
            index++;

            node.PrevVisibleNode = prevNode;

            if (prevNode != null)
            {
                prevNode.NextVisibleNode = node;
            }

            prevNode = node;

            if (node.Expanded)
            {
                foreach (CrownTreeNode childNode in node.Nodes)
                {
                    UpdateNode(childNode, ref prevNode, indent + Indent, ref yOffset, ref isOdd, ref index);
                }
            }
        }

        private void UpdateNodeBounds(CrownTreeNode node, int yOffset, int indent)
        {
            int expandTop = yOffset + (ItemHeight / 2) - (_expandAreaSize / 2);
            node.ExpandArea = new(indent + 3, expandTop, _expandAreaSize, _expandAreaSize);

            int iconTop = yOffset + (ItemHeight / 2) - (_iconSize / 2);

            if (ShowIcons)
            {
                node.IconArea = new(node.ExpandArea.Right + 2, iconTop, _iconSize, _iconSize);
            }
            else
            {
                node.IconArea = new(node.ExpandArea.Right, iconTop, 0, 0);
            }

            using (Graphics g = CreateGraphics())
            {
                int textSize = (int)g.MeasureString(node.Text, Font).Width;
                node.TextArea = new(node.IconArea.Right + 2, yOffset, textSize + 1, ItemHeight);
            }

            node.FullArea = new(indent, yOffset, node.TextArea.Right - indent, ItemHeight);

            if (ContentSize.Width < node.TextArea.Right + 2)
            {
                ContentSize = new(node.TextArea.Right + 2, ContentSize.Height);
            }
        }

        private void LoadIcons()
        {
            DisposeIcons();

            _nodeClosed = Properties.Resources.node_closed_empty.SetColor(ThemeProvider.Theme.Colors.LightText);
            _nodeClosedHover = Properties.Resources.node_closed_empty.SetColor(ThemeProvider.Theme.Colors.BlueHighlight);
            _nodeClosedHoverSelected = Properties.Resources.node_closed_full.SetColor(ThemeProvider.Theme.Colors.LightText);
            _nodeOpen = Properties.Resources.node_open.SetColor(ThemeProvider.Theme.Colors.LightText);
            _nodeOpenHover = Properties.Resources.node_open.SetColor(ThemeProvider.Theme.Colors.BlueHighlight);
            _nodeOpenHoverSelected = Properties.Resources.node_open_empty.SetColor(ThemeProvider.Theme.Colors.LightText);
        }

        private void DisposeIcons()
        {
            if (_nodeClosed != null)
            {
                _nodeClosed.Dispose();
            }

            if (_nodeClosedHover != null)
            {
                _nodeClosedHover.Dispose();
            }

            if (_nodeClosedHoverSelected != null)
            {
                _nodeClosedHoverSelected.Dispose();
            }

            if (_nodeOpen != null)
            {
                _nodeOpen.Dispose();
            }

            if (_nodeOpenHover != null)
            {
                _nodeOpenHover.Dispose();
            }

            if (_nodeOpenHoverSelected != null)
            {
                _nodeOpenHoverSelected.Dispose();
            }
        }

        private void CheckHover()
        {
            if (!ClientRectangle.Contains(PointToClient(MousePosition)))
            {
                if (IsDragging)
                {
                    if (_dropNode != null)
                    {
                        _dropNode = null;
                        Invalidate();
                    }
                }

                return;
            }

            foreach (CrownTreeNode node in Nodes)
            {
                CheckNodeHover(node, OffsetMousePosition);
            }
        }

        private void NodeMouseLeave(CrownTreeNode node)
        {
            node.ExpandAreaHot = false;

            foreach (CrownTreeNode childNode in node.Nodes)
            {
                NodeMouseLeave(childNode);
            }

            Invalidate();
        }

        private void CheckNodeHover(CrownTreeNode node, Point location)
        {
            if (IsDragging)
            {
                Rectangle rect = GetNodeFullRowArea(node);
                if (rect.Contains(OffsetMousePosition))
                {
                    CrownTreeNode newDropNode = _dragNodes.Contains(node) ? null : node;

                    if (_dropNode != newDropNode)
                    {
                        _dropNode = newDropNode;
                        Invalidate();
                    }
                }
            }
            else
            {
                bool hot = node.ExpandArea.Contains(location);
                if (node.ExpandAreaHot != hot)
                {
                    node.ExpandAreaHot = hot;
                    Invalidate();
                }
            }

            foreach (CrownTreeNode childNode in node.Nodes)
            {
                CheckNodeHover(childNode, location);
            }
        }

        private void CheckNodeClick(CrownTreeNode node, Point location, MouseButtons button)
        {
            Rectangle rect = GetNodeFullRowArea(node);
            if (rect.Contains(location))
            {
                if (node.ExpandArea.Contains(location))
                {
                    if (button == MouseButtons.Left)
                    {
                        node.Expanded = !node.Expanded;
                    }
                }
                else
                {
                    if (button == MouseButtons.Left)
                    {
                        if (MultiSelect && ModifierKeys == Keys.Shift)
                        {
                            SelectAnchoredRange(node);
                        }
                        else if (MultiSelect && ModifierKeys == Keys.Control)
                        {
                            ToggleNode(node);
                        }
                        else
                        {
                            if (!SelectedNodes.Contains(node))
                            {
                                SelectNode(node);
                            }

                            _dragPos = OffsetMousePosition;
                            _provisionalDragging = true;
                            _provisionalNode = node;
                        }

                        return;
                    }
                    else if (button == MouseButtons.Right)
                    {
                        if (MultiSelect && ModifierKeys == Keys.Shift)
                        {
                            return;
                        }

                        if (MultiSelect && ModifierKeys == Keys.Control)
                        {
                            return;
                        }

                        if (!SelectedNodes.Contains(node))
                        {
                            SelectNode(node);
                        }

                        return;
                    }
                }
            }

            if (node.Expanded)
            {
                foreach (CrownTreeNode childNode in node.Nodes)
                {
                    CheckNodeClick(childNode, location, button);
                }
            }
        }

        private void CheckNodeDoubleClick(CrownTreeNode node, Point location)
        {
            Rectangle rect = GetNodeFullRowArea(node);
            if (rect.Contains(location))
            {
                if (!node.ExpandArea.Contains(location))
                {
                    node.Expanded = !node.Expanded;
                }

                return;
            }

            if (node.Expanded)
            {
                foreach (CrownTreeNode childNode in node.Nodes)
                {
                    CheckNodeDoubleClick(childNode, location);
                }
            }
        }

        public void SelectNode(CrownTreeNode node)
        {
            SelectedNodes.Clear();
            SelectedNodes.Add(node);

            _anchoredNodeStart = node;
            _anchoredNodeEnd = node;

            Invalidate();
        }

        public void SelectNodes(CrownTreeNode startNode, CrownTreeNode endNode)
        {
            List<CrownTreeNode> nodes = new();

            if (startNode == endNode)
            {
                nodes.Add(startNode);
            }

            if (startNode.VisibleIndex < endNode.VisibleIndex)
            {
                CrownTreeNode node = startNode;
                nodes.Add(node);
                while (node != endNode && node != null)
                {
                    node = node.NextVisibleNode;
                    nodes.Add(node);
                }
            }
            else if (startNode.VisibleIndex > endNode.VisibleIndex)
            {
                CrownTreeNode node = startNode;
                nodes.Add(node);
                while (node != endNode && node != null)
                {
                    node = node.PrevVisibleNode;
                    nodes.Add(node);
                }
            }

            SelectNodes(nodes, false);
        }

        public void SelectNodes(List<CrownTreeNode> nodes, bool updateAnchors = true)
        {
            SelectedNodes.Clear();

            foreach (CrownTreeNode node in nodes)
            {
                SelectedNodes.Add(node);
            }

            if (updateAnchors && SelectedNodes.Count > 0)
            {
                _anchoredNodeStart = SelectedNodes[SelectedNodes.Count - 1];
                _anchoredNodeEnd = SelectedNodes[SelectedNodes.Count - 1];
            }

            Invalidate();
        }

        private void SelectAnchoredRange(CrownTreeNode node)
        {
            _anchoredNodeEnd = node;
            SelectNodes(_anchoredNodeStart, _anchoredNodeEnd);
        }

        public void ToggleNode(CrownTreeNode node)
        {
            if (SelectedNodes.Contains(node))
            {
                SelectedNodes.Remove(node);

                // If we just removed both the anchor start AND end then reset them
                if (_anchoredNodeStart == node && _anchoredNodeEnd == node)
                {
                    if (SelectedNodes.Count > 0)
                    {
                        _anchoredNodeStart = SelectedNodes[0];
                        _anchoredNodeEnd = SelectedNodes[0];
                    }
                    else
                    {
                        _anchoredNodeStart = null;
                        _anchoredNodeEnd = null;
                    }
                }

                // If we just removed the anchor start then update it accordingly
                if (_anchoredNodeStart == node)
                {
                    if (_anchoredNodeEnd.VisibleIndex < node.VisibleIndex)
                    {
                        _anchoredNodeStart = node.PrevVisibleNode;
                    }
                    else if (_anchoredNodeEnd.VisibleIndex > node.VisibleIndex)
                    {
                        _anchoredNodeStart = node.NextVisibleNode;
                    }
                    else
                    {
                        _anchoredNodeStart = _anchoredNodeEnd;
                    }
                }

                // If we just removed the anchor end then update it accordingly
                if (_anchoredNodeEnd == node)
                {
                    if (_anchoredNodeStart.VisibleIndex < node.VisibleIndex)
                    {
                        _anchoredNodeEnd = node.PrevVisibleNode;
                    }
                    else if (_anchoredNodeStart.VisibleIndex > node.VisibleIndex)
                    {
                        _anchoredNodeEnd = node.NextVisibleNode;
                    }
                    else
                    {
                        _anchoredNodeEnd = _anchoredNodeStart;
                    }
                }
            }
            else
            {
                SelectedNodes.Add(node);

                _anchoredNodeStart = node;
                _anchoredNodeEnd = node;
            }

            Invalidate();
        }

        public Rectangle GetNodeFullRowArea(CrownTreeNode node)
        {
            if (node.ParentNode != null && !node.ParentNode.Expanded)
            {
                return new Rectangle(-1, -1, -1, -1);
            }

            int width = Math.Max(ContentSize.Width, Viewport.Width);
            Rectangle rect = new(0, node.FullArea.Top, width, ItemHeight);
            return rect;
        }

        public void EnsureVisible()
        {
            if (SelectedNodes.Count == 0)
            {
                return;
            }

            foreach (CrownTreeNode node in SelectedNodes)
            {
                node.EnsureVisible();
            }

            int itemTop = -1;

            if (!MultiSelect)
            {
                itemTop = SelectedNodes[0].FullArea.Top;
            }
            else
            {
                itemTop = _anchoredNodeEnd.FullArea.Top;
            }

            int itemBottom = itemTop + ItemHeight;

            if (itemTop < Viewport.Top)
            {
                VScrollTo(itemTop);
            }

            if (itemBottom > Viewport.Bottom)
            {
                VScrollTo(itemBottom - Viewport.Height);
            }
        }

        public void Sort()
        {
            if (TreeViewNodeSorter == null)
            {
                return;
            }

            Nodes.Sort(TreeViewNodeSorter);

            foreach (CrownTreeNode node in Nodes)
            {
                SortChildNodes(node);
            }
        }

        private void SortChildNodes(CrownTreeNode node)
        {
            node.Nodes.Sort(TreeViewNodeSorter);

            foreach (CrownTreeNode childNode in node.Nodes)
            {
                SortChildNodes(childNode);
            }
        }

        public CrownTreeNode FindNode(string path)
        {
            foreach (CrownTreeNode node in Nodes)
            {
                CrownTreeNode compNode = FindNode(node, path);
                if (compNode != null)
                {
                    return compNode;
                }
            }

            return null;
        }

        private CrownTreeNode FindNode(CrownTreeNode parentNode, string path, bool recursive = true)
        {
            if (parentNode.FullPath == path)
            {
                return parentNode;
            }

            foreach (CrownTreeNode node in parentNode.Nodes)
            {
                if (node.FullPath == path)
                {
                    return node;
                }

                if (recursive)
                {
                    CrownTreeNode compNode = FindNode(node, path);
                    if (compNode != null)
                    {
                        return compNode;
                    }
                }
            }

            return null;
        }

        #endregion

        #region Drag & Drop Region

        protected override void StartDrag()
        {
            if (!AllowMoveNodes)
            {
                _provisionalDragging = false;
                return;
            }

            // Create initial list of nodes to drag
            _dragNodes = new List<CrownTreeNode>();
            foreach (CrownTreeNode node in SelectedNodes)
            {
                _dragNodes.Add(node);
            }

            // Clear out any nodes with a parent that is being dragged
            foreach (CrownTreeNode node in _dragNodes.ToList())
            {
                if (node.ParentNode == null)
                {
                    continue;
                }

                if (_dragNodes.Contains(node.ParentNode))
                {
                    _dragNodes.Remove(node);
                }
            }

            _provisionalDragging = false;

            Cursor = Cursors.SizeAll;

            base.StartDrag();
        }

        private void HandleDrag()
        {
            if (!AllowMoveNodes)
            {
                return;
            }

            CrownTreeNode dropNode = _dropNode;

            if (dropNode == null)
            {
                if (Cursor != Cursors.No)
                {
                    Cursor = Cursors.No;
                }

                return;
            }

            if (ForceDropToParent(dropNode))
            {
                dropNode = dropNode.ParentNode;
            }

            if (!CanMoveNodes(_dragNodes, dropNode))
            {
                if (Cursor != Cursors.No)
                {
                    Cursor = Cursors.No;
                }

                return;
            }

            if (Cursor != Cursors.SizeAll)
            {
                Cursor = Cursors.SizeAll;
            }
        }

        private void HandleDrop()
        {
            if (!AllowMoveNodes)
            {
                return;
            }

            CrownTreeNode dropNode = _dropNode;

            if (dropNode == null)
            {
                StopDrag();
                return;
            }

            if (ForceDropToParent(dropNode))
            {
                dropNode = dropNode.ParentNode;
            }

            if (CanMoveNodes(_dragNodes, dropNode, true))
            {
                List<CrownTreeNode> cachedSelectedNodes = SelectedNodes.ToList();

                MoveNodes(_dragNodes, dropNode);

                foreach (CrownTreeNode node in _dragNodes)
                {
                    if (node.ParentNode == null)
                    {
                        Nodes.Remove(node);
                    }
                    else
                    {
                        node.ParentNode.Nodes.Remove(node);
                    }

                    dropNode.Nodes.Add(node);
                }

                if (TreeViewNodeSorter != null)
                {
                    dropNode.Nodes.Sort(TreeViewNodeSorter);
                }

                dropNode.Expanded = true;

                NodesMoved(_dragNodes);

                foreach (CrownTreeNode node in cachedSelectedNodes)
                {
                    SelectedNodes.Add(node);
                }
            }

            StopDrag();
            UpdateNodes();
        }

        protected override void StopDrag()
        {
            _dragNodes = null;
            _dropNode = null;

            Cursor = Cursors.Default;

            Invalidate();

            base.StopDrag();
        }

        protected virtual bool ForceDropToParent(CrownTreeNode node)
        {
            return false;
        }

        protected virtual bool CanMoveNodes(List<CrownTreeNode> dragNodes, CrownTreeNode dropNode, bool isMoving = false)
        {
            if (dropNode == null)
            {
                return false;
            }

            foreach (CrownTreeNode node in dragNodes)
            {
                if (node == dropNode)
                {
                    if (isMoving)
                    {
                        CrownMessageBox.ShowError($"Cannot move {node.Text}. The destination folder is the same as the source folder.", Application.ProductName);
                    }

                    return false;
                }

                if (node.ParentNode != null && node.ParentNode == dropNode)
                {
                    if (isMoving)
                    {
                        CrownMessageBox.ShowError($"Cannot move {node.Text}. The destination folder is the same as the source folder.", Application.ProductName);
                    }

                    return false;
                }

                CrownTreeNode parentNode = dropNode.ParentNode;
                while (parentNode != null)
                {
                    if (node == parentNode)
                    {
                        if (isMoving)
                        {
                            CrownMessageBox.ShowError($"Cannot move {node.Text}. The destination folder is a subfolder of the source folder.", Application.ProductName);
                        }

                        return false;
                    }

                    parentNode = parentNode.ParentNode;
                }
            }

            return true;
        }

        protected virtual void MoveNodes(List<CrownTreeNode> dragNodes, CrownTreeNode dropNode)
        { }

        protected virtual void NodesMoved(List<CrownTreeNode> nodesMoved)
        { }

        #endregion

        #region Paint Region

        protected override void OnPaintBackground(PaintEventArgs e)
        {
            base.OnPaintBackground(e);
            LoadIcons();
        }

        protected override void PaintContent(Graphics g)
        {
            // Fill body
            using (SolidBrush b = new(ThemeProvider.Theme.Colors.GreyBackground))
            {
                g.FillRectangle(b, ClientRectangle);
            }

            foreach (CrownTreeNode node in Nodes)
            {
                DrawNode(node, g);
            }
        }

        private void DrawNode(CrownTreeNode node, Graphics g)
        {
            Rectangle rect = GetNodeFullRowArea(node);

            // 1. Draw background
            Color bgColor = node.Odd ? ThemeProvider.Theme.Colors.HeaderBackground : ThemeProvider.Theme.Colors.GreyBackground;

            if (SelectedNodes.Count > 0 && SelectedNodes.Contains(node))
            {
                bgColor = Focused ? ThemeProvider.Theme.Colors.BlueSelection : ThemeProvider.Theme.Colors.GreySelection;
            }

            if (IsDragging && _dropNode == node)
            {
                bgColor = Focused ? ThemeProvider.Theme.Colors.BlueSelection : ThemeProvider.Theme.Colors.GreySelection;
            }

            using (SolidBrush b = new(bgColor))
            {
                g.FillRectangle(b, rect);
            }

            // 2. Draw plus/minus icon
            if (node.Nodes.Count > 0)
            {
                Point pos = new(node.ExpandArea.Location.X - 1, node.ExpandArea.Location.Y - 1);

                Bitmap icon = _nodeOpen;

                if (node.Expanded && !node.ExpandAreaHot)
                {
                    icon = _nodeOpen;
                }
                else if (node.Expanded && node.ExpandAreaHot && !SelectedNodes.Contains(node))
                {
                    icon = _nodeOpenHover;
                }
                else if (node.Expanded && node.ExpandAreaHot && SelectedNodes.Contains(node))
                {
                    icon = _nodeOpenHoverSelected;
                }
                else if (!node.Expanded && !node.ExpandAreaHot)
                {
                    icon = _nodeClosed;
                }
                else if (!node.Expanded && node.ExpandAreaHot && !SelectedNodes.Contains(node))
                {
                    icon = _nodeClosedHover;
                }
                else if (!node.Expanded && node.ExpandAreaHot && SelectedNodes.Contains(node))
                {
                    icon = _nodeClosedHoverSelected;
                }

                g.DrawImageUnscaled(icon, pos);
            }

            // 3. Draw icon
            if (ShowIcons && node.Icon != null)
            {
                if (node.Expanded && node.ExpandedIcon != null)
                {
                    g.DrawImageUnscaled(node.ExpandedIcon, node.IconArea.Location);
                }
                else
                {
                    g.DrawImageUnscaled(node.Icon, node.IconArea.Location);
                }
            }

            // 4. Draw text
            using (SolidBrush b = new(ThemeProvider.Theme.Colors.LightText))
            {
                StringFormat stringFormat = new()
                {
                    Alignment = StringAlignment.Near,
                    LineAlignment = StringAlignment.Center
                };

                g.DrawString(node.Text, Font, b, node.TextArea, stringFormat);
            }

            // 5. Draw child nodes
            if (node.Expanded)
            {
                foreach (CrownTreeNode childNode in node.Nodes)
                {
                    DrawNode(childNode, g);
                }
            }
        }

        #endregion
    }

    #endregion
}