#region Imports

using DPumpHydr.WinFrmUI.RLT.Controls;
using System;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using static DPumpHydr.WinFrmUI.RLT.Helper.CrownHelper;

#endregion

namespace DPumpHydr.WinFrmUI.RLT.Child.Crown
{
    #region CrownScrollBaseChild

    public abstract class CrownScrollBase : Control
    {
        #region Event Region

        public event EventHandler ViewportChanged;
        public event EventHandler ContentSizeChanged;

        #endregion

        #region Field Region

        protected readonly CrownScrollBar _vScrollBar;
        protected readonly CrownScrollBar _hScrollBar;

        private Size _visibleSize;
        private Size _contentSize;

        private Rectangle _viewport;

        private Point _offsetMousePosition;

        private int _maxDragChange = 0;
        private readonly Timer _dragTimer;

        private bool _hideScrollBars = true;

        #endregion

        #region Property Region

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle Viewport
        {
            get => _viewport;
            private set
            {
                _viewport = value;

                ViewportChanged?.Invoke(this, null);
            }
        }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Size ContentSize
        {
            get => _contentSize;
            set
            {
                _contentSize = value;
                UpdateScrollBars();

                ContentSizeChanged?.Invoke(this, null);
            }
        }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Point OffsetMousePosition => _offsetMousePosition;

        [Category("Behavior")]
        [Description("Determines the maximum scroll change when dragging.")]
        [DefaultValue(0)]
        public int MaxDragChange
        {
            get => _maxDragChange;
            set
            {
                _maxDragChange = value;
                Invalidate();
            }
        }

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

        [Category("Behavior")]
        [Description("Determines whether scrollbars will remain visible when disabled.")]
        [DefaultValue(true)]
        public bool HideScrollBars
        {
            get => _hideScrollBars;
            set
            {
                _hideScrollBars = value;
                UpdateScrollBars();
            }
        }

        #endregion

        #region Constructor Region

        protected CrownScrollBase()
        {
            SetStyle
            (
                ControlStyles.Selectable |
                ControlStyles.UserMouse,
                    true
            );

            _vScrollBar = new CrownScrollBar { ScrollOrientation = Enum.Crown.ScrollOrientation.Vertical };
            _hScrollBar = new CrownScrollBar { ScrollOrientation = Enum.Crown.ScrollOrientation.Horizontal };

            Controls.Add(_vScrollBar);
            Controls.Add(_hScrollBar);

            _vScrollBar.ValueChanged += delegate { UpdateViewport(); };
            _hScrollBar.ValueChanged += delegate { UpdateViewport(); };

            _vScrollBar.MouseDown += delegate { Select(); };
            _hScrollBar.MouseDown += delegate { Select(); };

            _dragTimer = new Timer
            {
                Interval = 1
            };
            _dragTimer.Tick += DragTimer_Tick;
        }

        #endregion

        #region Method Region

        private void UpdateScrollBars()
        {
            if (_vScrollBar.Maximum != ContentSize.Height)
            {
                _vScrollBar.Maximum = ContentSize.Height;
            }

            if (_hScrollBar.Maximum != ContentSize.Width)
            {
                _hScrollBar.Maximum = ContentSize.Width;
            }

            int scrollSize = ThemeProvider.Theme.Sizes.ScrollBarSize;

            _vScrollBar.Location = new(ClientSize.Width - scrollSize, 0);
            _vScrollBar.Size = new(scrollSize, ClientSize.Height);

            _hScrollBar.Location = new(0, ClientSize.Height - scrollSize);
            _hScrollBar.Size = new(ClientSize.Width, scrollSize);

            if (DesignMode)
            {
                return;
            }

            // Do this twice in case changing the visibility of the scrollbars
            // causes the VisibleSize to change in such a way as to require a second scrollbar.
            // Probably a better way to detect that scenario...
            SetVisibleSize();
            SetScrollBarVisibility();
            SetVisibleSize();
            SetScrollBarVisibility();

            if (_vScrollBar.Visible)
            {
                _hScrollBar.Width -= scrollSize;
            }

            if (_hScrollBar.Visible)
            {
                _vScrollBar.Height -= scrollSize;
            }

            _vScrollBar.ViewSize = _visibleSize.Height;
            _hScrollBar.ViewSize = _visibleSize.Width;

            UpdateViewport();
        }

        private void SetScrollBarVisibility()
        {
            _vScrollBar.Enabled = _visibleSize.Height < ContentSize.Height;
            _hScrollBar.Enabled = _visibleSize.Width < ContentSize.Width;

            if (_hideScrollBars)
            {
                _vScrollBar.Visible = _vScrollBar.Enabled;
                _hScrollBar.Visible = _hScrollBar.Enabled;
            }
        }

        private void SetVisibleSize()
        {
            int scrollSize = ThemeProvider.Theme.Sizes.ScrollBarSize;

            _visibleSize = new(ClientSize.Width, ClientSize.Height);

            if (_vScrollBar.Visible)
            {
                _visibleSize.Width -= scrollSize;
            }

            if (_hScrollBar.Visible)
            {
                _visibleSize.Height -= scrollSize;
            }
        }

        private void UpdateViewport()
        {
            int left = 0;
            int top = 0;
            int width = ClientSize.Width;
            int height = ClientSize.Height;

            if (_hScrollBar.Visible)
            {
                left = _hScrollBar.Value;
                height -= _hScrollBar.Height;
            }

            if (_vScrollBar.Visible)
            {
                top = _vScrollBar.Value;
                width -= _vScrollBar.Width;
            }

            Viewport = new(left, top, width, height);

            Point pos = PointToClient(MousePosition);
            _offsetMousePosition = new(pos.X + Viewport.Left, pos.Y + Viewport.Top);

            Invalidate();
        }

        public void ScrollTo(Point point)
        {
            HScrollTo(point.X);
            VScrollTo(point.Y);
        }

        public void VScrollTo(int value)
        {
            if (_vScrollBar.Visible)
            {
                _vScrollBar.Value = value;
            }
        }

        public void HScrollTo(int value)
        {
            if (_hScrollBar.Visible)
            {
                _hScrollBar.Value = value;
            }
        }

        protected virtual void StartDrag()
        {
            IsDragging = true;
            _dragTimer.Start();
        }

        protected virtual void StopDrag()
        {
            IsDragging = false;
            _dragTimer.Stop();
        }

        public Point PointToView(Point point)
        {
            return new Point(point.X - Viewport.Left, point.Y - Viewport.Top);
        }

        public Rectangle RectangleToView(Rectangle rect)
        {
            return new Rectangle(new Point(rect.Left - Viewport.Left, rect.Top - Viewport.Top), rect.Size);
        }

        #endregion

        #region Event Handler Region

        protected override void OnCreateControl()
        {
            base.OnCreateControl();

            UpdateScrollBars();
        }

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

            Invalidate();
        }

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

            Invalidate();
        }

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

            UpdateScrollBars();
        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);

            _offsetMousePosition = new(e.X + Viewport.Left, e.Y + Viewport.Top);
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);

            if (e.Button == MouseButtons.Right)
            {
                Select();
            }
        }

        protected override void OnMouseWheel(MouseEventArgs e)
        {
            base.OnMouseWheel(e);

            bool horizontal = false;

            if (_hScrollBar.Visible && ModifierKeys == Keys.Control)
            {
                horizontal = true;
            }

            if (_hScrollBar.Visible && !_vScrollBar.Visible)
            {
                horizontal = true;
            }

            if (!horizontal)
            {
                if (e.Delta > 0)
                {
                    _vScrollBar.ScrollByPhysical(3);
                }
                else if (e.Delta < 0)
                {
                    _vScrollBar.ScrollByPhysical(-3);
                }
            }
            else
            {
                if (e.Delta > 0)
                {
                    _hScrollBar.ScrollByPhysical(3);
                }
                else if (e.Delta < 0)
                {
                    _hScrollBar.ScrollByPhysical(-3);
                }
            }
        }

        protected override void OnPreviewKeyDown(PreviewKeyDownEventArgs e)
        {
            base.OnPreviewKeyDown(e);

            // Allows arrow keys to trigger OnKeyPress
            switch (e.KeyCode)
            {
                case Keys.Up:
                case Keys.Down:
                case Keys.Left:
                case Keys.Right:
                    e.IsInputKey = true;
                    break;
            }
        }

        private void DragTimer_Tick(object sender, EventArgs e)
        {
            Point pos = PointToClient(MousePosition);

            int right = ClientRectangle.Right;
            int bottom = ClientRectangle.Bottom;

            if (_vScrollBar.Visible)
            {
                right = _vScrollBar.Left;
            }

            if (_hScrollBar.Visible)
            {
                bottom = _hScrollBar.Top;
            }

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

                    if (MaxDragChange > 0 && difference > MaxDragChange)
                    {
                        difference = MaxDragChange;
                    }

                    _vScrollBar.Value -= difference;
                }

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

                    if (MaxDragChange > 0 && difference > MaxDragChange)
                    {
                        difference = MaxDragChange;
                    }

                    _vScrollBar.Value += difference;
                }
            }

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

                    if (MaxDragChange > 0 && difference > MaxDragChange)
                    {
                        difference = MaxDragChange;
                    }

                    _hScrollBar.Value -= difference;
                }

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

                    if (MaxDragChange > 0 && difference > MaxDragChange)
                    {
                        difference = MaxDragChange;
                    }

                    _hScrollBar.Value += difference;
                }
            }
        }

        #endregion
    }

    #endregion
}