// COPYRIGHT (C) Tom. ALL RIGHTS RESERVED.
// THE AntdUI PROJECT IS AN WINFORM LIBRARY LICENSED UNDER THE Apache-2.0 License.
// LICENSED UNDER THE Apache License, VERSION 2.0 (THE "License")
// YOU MAY NOT USE THIS FILE EXCEPT IN COMPLIANCE WITH THE License.
// YOU MAY OBTAIN A COPY OF THE LICENSE AT
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING, SOFTWARE
// DISTRIBUTED UNDER THE LICENSE IS DISTRIBUTED ON AN "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
// SEE THE LICENSE FOR THE SPECIFIC LANGUAGE GOVERNING PERMISSIONS AND
// LIMITATIONS UNDER THE License.
// GITEE: https://gitee.com/antdui/AntdUI
// GITHUB: https://github.com/AntdUI/AntdUI
// CSDN: https://blog.csdn.net/v_132
// QQ: 17379620

using System;
using System.Drawing;

namespace AntdUI
{
    public class ScrollBar
    {
        #region 属性

        internal int Radius { get; set; }
        internal bool RB { get; set; }

        #region 布局容器

        public ScrollBar(FlowPanel control, bool enabledY = true, bool enabledX = false)
        {
            OnInvalidate = ChangeSize = () =>
            {
                control.IOnSizeChanged();
            };
            Invalidate = rect =>
            {
                OnInvalidate?.Invoke();
            };
            EnabledX = enabledX;
            EnabledY = enabledY;
            Init();
        }
        public ScrollBar(StackPanel control)
        {
            OnInvalidate = ChangeSize = () =>
            {
                control.IOnSizeChanged();
            };
            Invalidate = rect =>
            {
                OnInvalidate?.Invoke();
            };
            if (control.Vertical) EnabledY = true;
            else EnabledX = true;
            Init();
        }

        #endregion

        public ScrollBar(IControl control, bool enabledY = true, bool enabledX = false, int radius = 0, bool radiusy = false)
        {
            Radius = radius;
            RB = radiusy;
            Invalidate = rect =>
            {
                OnInvalidate?.Invoke();
                if (rect.HasValue) control.Invalidate(rect.Value);
                else control.Invalidate();
            };
            ChangeSize = () =>
            {
                control.IOnSizeChanged();
            };
            EnabledX = enabledX;
            EnabledY = enabledY;
            Init();
        }

        public ScrollBar(Action change, Action<Rectangle?> invalidate, bool enabledY = true, bool enabledX = false)
        {
            EnabledX = enabledX;
            EnabledY = enabledY;
            ChangeSize = change;
            Invalidate = invalidate;
            Init();
        }

        void Init()
        {
            SIZE = (int)(16 * Config.Dpi);
            SIZE_BAR = (int)(6 * Config.Dpi);
        }

        Action? ChangeSize;
        Action<Rectangle?> Invalidate;
        internal Action? OnInvalidate;

        /// <summary>
        /// 是否显示背景
        /// </summary>
        public bool Back { get; set; } = true;

        /// <summary>
        /// 滚动条大小
        /// </summary>
        public int SIZE { get; set; } = 20;

        /// <summary>
        /// 常态下滚动条大小
        /// </summary>
        public int SIZE_BAR { get; set; } = 8;

        #endregion

        #region 纵向

        /// <summary>
        /// 是否启用纵向滚动条
        /// </summary>
        public bool EnabledY { get; set; }

        Rectangle RectY;

        bool showY = false;
        /// <summary>
        /// 是否显示纵向滚动条
        /// </summary>
        public bool ShowY
        {
            get => showY;
            set
            {
                if (showY == value) return;
                showY = value;
                Invalidate(null);
                ChangeSize?.Invoke();
            }
        }

        int valueY = 0;
        /// <summary>
        /// 当前值纵向滚动条
        /// </summary>
        public int ValueY
        {
            get => valueY;
            set
            {
                if (value < 0) value = 0;
                if (maxY > 0)
                {
                    int valueI = maxY - RectY.Height;
                    if (value > valueI) value = valueI;
                }
                if (valueY == value) return;
                valueY = value;
                Invalidate(null);
            }
        }

        int maxY = 0;
        /// <summary>
        /// 当前值纵向滚动条
        /// </summary>
        public int MaxY
        {
            get => maxY;
            set
            {
                if (maxY == value) return;
                maxY = value;
                Invalidate(null);
            }
        }

        bool hoverY = false;
        /// <summary>
        /// 滑动态纵向滚动条y
        /// </summary>
        public bool HoverY
        {
            get => hoverY;
            set
            {
                if (hoverY == value) return;
                hoverY = value;
                if (Config.Animation)
                {
                    ThreadHoverY?.Dispose();
                    AnimationHoverY = true;
                    var t = Animation.TotalFrames(10, 100);
                    if (value)
                    {
                        ThreadHoverY = new ITask((i) =>
                        {
                            AnimationHoverYValue = Animation.Animate(i, t, 1F, AnimationType.Ball);
                            Invalidate(RectY);
                            return true;
                        }, 10, t, () =>
                        {
                            AnimationHoverYValue = 1F;
                            AnimationHoverY = false;
                            Invalidate(RectY);
                        });
                    }
                    else
                    {
                        ThreadHoverY = new ITask((i) =>
                        {
                            AnimationHoverYValue = 1F - Animation.Animate(i, t, 1F, AnimationType.Ball);
                            Invalidate(RectY);
                            return true;
                        }, 10, t, () =>
                        {
                            AnimationHoverYValue = 0F;
                            AnimationHoverY = false;
                            Invalidate(RectY);
                        });
                    }
                }
                else Invalidate(RectY);
            }
        }

        #endregion

        #region 横向

        /// <summary>
        /// 是否启用横向滚动条
        /// </summary>
        public bool EnabledX { get; set; }

        Rectangle RectX;

        bool showX = false;
        /// <summary>
        /// 是否显示横向滚动条
        /// </summary>
        public bool ShowX
        {
            get => showX;
            set
            {
                if (showX == value) return;
                showX = value;
                Invalidate(null);
                ChangeSize?.Invoke();
            }
        }

        int valueX = 0;
        /// <summary>
        /// 当前值横向滚动条
        /// </summary>
        public int ValueX
        {
            get => valueX;
            set
            {
                if (value < 0) value = 0;
                if (maxX > 0)
                {
                    int valueI = maxX - RectX.Width;
                    if (value > valueI) value = valueI;
                }
                if (valueX == value) return;
                valueX = value;
                Invalidate(null);
            }
        }

        int maxX = 0;
        /// <summary>
        /// 当前值横向滚动条
        /// </summary>
        public int MaxX
        {
            get => maxX;
            set
            {
                if (maxX == value) return;
                maxX = value;
                Invalidate(null);
            }
        }

        bool hoverX = false;
        /// <summary>
        /// 滑动态横向滚动条
        /// </summary>
        public bool HoverX
        {
            get => hoverX;
            set
            {
                if (hoverX == value) return;
                hoverX = value;
                if (Config.Animation)
                {
                    ThreadHoverX?.Dispose();
                    AnimationHoverX = true;
                    var t = Animation.TotalFrames(10, 100);
                    if (value)
                    {
                        ThreadHoverX = new ITask((i) =>
                        {
                            AnimationHoverXValue = Animation.Animate(i, t, 1F, AnimationType.Ball);
                            Invalidate(RectX);
                            return true;
                        }, 10, t, () =>
                        {
                            AnimationHoverXValue = 1F;
                            AnimationHoverX = false;
                            Invalidate(RectX);
                        });
                    }
                    else
                    {
                        ThreadHoverX = new ITask((i) =>
                        {
                            AnimationHoverXValue = 1F - Animation.Animate(i, t, 1F, AnimationType.Ball);
                            Invalidate(RectX);
                            return true;
                        }, 10, t, () =>
                        {
                            AnimationHoverXValue = 0F;
                            AnimationHoverX = false;
                            Invalidate(RectX);
                        });
                    }
                }
                else Invalidate(RectX);
            }
        }

        public void Clear()
        {
            valueX = valueY = 0;
        }

        #endregion

        #region 布局

        /// <summary>
        /// 设置容器大小
        /// </summary>
        public void SizeChange(Rectangle rect)
        {
            RectX = new Rectangle(rect.X, rect.Bottom - SIZE, rect.Width, SIZE);
            RectY = new Rectangle(rect.Right - SIZE, rect.Top, SIZE, rect.Height);
            SetShow(oldx, oldy);
        }

        int oldx = 0, oldy = 0;
        /// <summary>
        /// 设置容器虚拟宽度
        /// </summary>
        public void SetVrSize(int x, int y)
        {
            oldx = x; oldy = y;
            SetShow(oldx, oldy);
        }

        #region 设置是否显示

        string show_oldx = "", show_oldy = "";
        void SetShow(int x, int y)
        {
            SetShow(x, RectX.Width, y, RectY.Height);
        }
        void SetShow(int x, int x2, int y, int y2)
        {
            string show_x = x + "_" + x2, show_y = y + "_" + y2;
            if (show_oldx == show_x && show_oldy == show_y) return;
            show_oldx = show_x;
            show_oldy = show_y;
            if (x2 > 0 && x > 0 && x > x2)
            {
                maxX = x;
                ShowX = maxX > x2;
                if (ShowX)
                {
                    int valueI = x - x2;
                    if (valueX > valueI) ValueX = valueI;
                }
            }
            else
            {
                maxX = valueX = 0;
                ShowX = false;
            }
            if (y2 > 0 && y > 0 && y > y2)
            {
                maxY = y;
                ShowY = maxY > y2;
                if (ShowY)
                {
                    int valueI = y - y2;
                    if (valueY > valueI) ValueY = valueI;
                }
            }
            else
            {
                maxY = valueY = 0;
                ShowY = false;
            }

            if (showX && showY)
            {
                maxX += SIZE;
                maxY += SIZE;
            }
        }

        #endregion

        #endregion

        #region 渲染

        public virtual void Paint(Graphics g)
        {
            Paint(g, Style.Db.TextBase);
        }
        public virtual void Paint(Graphics g, Color baseColor)
        {
            if (Config.ScrollBarHide)
            {
                if (showY && showX)
                {
                    if (Back && ((hoverY || AnimationHoverY) || (hoverX || AnimationHoverX)))
                    {
                        if (hoverY || AnimationHoverY)
                        {
                            using (var brush = BackBrushY(baseColor))
                            {
                                if (Radius > 0)
                                {
                                    float radius = Radius * Config.Dpi;
                                    using (var path = Helper.RoundPath(RectY, radius, false, true, RB, false))
                                    {
                                        g.FillPath(brush, path);
                                    }
                                }
                                else g.FillRectangle(brush, RectY);
                            }
                        }
                        else
                        {
                            using (var brush = BackBrushX(baseColor))
                            {
                                if (RB && Radius > 0)
                                {
                                    float radius = Radius * Config.Dpi;
                                    using (var path = Helper.RoundPath(new Rectangle(RectX.X, RectX.Y, RectX.Width, RectX.Height), radius, false, false, true, true))
                                    {
                                        g.FillPath(brush, path);
                                    }
                                }
                                else g.FillRectangle(brush, new Rectangle(RectX.X, RectX.Y, RectX.Width, RectX.Height));
                            }
                        }
                    }
                    PaintX(g, baseColor);
                    PaintY(g, baseColor);
                }
                else if (showY)
                {
                    if (Back && (hoverY || AnimationHoverY))
                    {
                        using (var brush = BackBrushY(baseColor))
                        {
                            if (Radius > 0)
                            {
                                float radius = Radius * Config.Dpi;
                                using (var path = Helper.RoundPath(RectY, radius, false, true, RB, false))
                                {
                                    g.FillPath(brush, path);
                                }
                            }
                            else g.FillRectangle(brush, RectY);
                        }
                    }
                    PaintY(g, baseColor);
                }
                else if (showX)
                {
                    if (Back && (hoverX || AnimationHoverX))
                    {
                        using (var brush = BackBrushX(baseColor))
                        {
                            if (RB && Radius > 0)
                            {
                                float radius = Radius * Config.Dpi;
                                using (var path = Helper.RoundPath(new Rectangle(RectX.X, RectX.Y, RectX.Width, RectX.Height), radius, false, false, true, true))
                                {
                                    g.FillPath(brush, path);
                                }
                            }
                            else g.FillRectangle(brush, RectX);
                        }
                    }
                    PaintX(g, baseColor);
                }
            }
            else
            {
                if (showY && showX)
                {
                    if (Back)
                    {
                        using (var brush = new SolidBrush(Color.FromArgb(10, baseColor)))
                        {
                            var rectX = new Rectangle(RectX.X, RectX.Y, RectX.Width - RectY.Width, RectX.Height);
                            if (Radius > 0)
                            {
                                float radius = Radius * Config.Dpi;
                                using (var path = Helper.RoundPath(RectY, radius, false, true, RB, false))
                                {
                                    g.FillPath(brush, path);
                                }
                                if (RB)
                                {
                                    using (var path = Helper.RoundPath(rectX, radius, false, false, false, true))
                                    {
                                        g.FillPath(brush, path);

                                    }
                                }
                                else g.FillRectangle(brush, rectX);
                            }
                            else
                            {
                                g.FillRectangle(brush, RectY);
                                g.FillRectangle(brush, rectX);
                            }
                        }
                    }
                    PaintX(g, baseColor);
                    PaintY(g, baseColor);
                }
                else if (showY)
                {
                    if (Back)
                    {
                        using (var brush = new SolidBrush(Color.FromArgb(10, baseColor)))
                        {
                            if (Radius > 0)
                            {
                                float radius = Radius * Config.Dpi;
                                using (var path = Helper.RoundPath(RectY, radius, false, true, RB, false))
                                {
                                    g.FillPath(brush, path);
                                }
                            }
                            else g.FillRectangle(brush, RectY);
                        }
                    }
                    PaintY(g, baseColor);
                }
                else if (showX)
                {
                    if (Back)
                    {
                        using (var brush = new SolidBrush(Color.FromArgb(10, baseColor)))
                        {
                            if (RB && Radius > 0)
                            {
                                float radius = Radius * Config.Dpi;
                                using (var path = Helper.RoundPath(new Rectangle(RectX.X, RectX.Y, RectX.Width, RectX.Height), radius, false, false, true, true))
                                {
                                    g.FillPath(brush, path);
                                }
                            }
                            else g.FillRectangle(brush, RectX);
                        }
                    }
                    PaintX(g, baseColor);
                }
            }
        }

        SolidBrush BackBrushY(Color color)
        {
            if (AnimationHoverY) return new SolidBrush(Color.FromArgb((int)(10 * AnimationHoverYValue), color));
            else return new SolidBrush(Color.FromArgb(10, color));
        }
        SolidBrush BackBrushX(Color color)
        {
            if (AnimationHoverX) return new SolidBrush(Color.FromArgb((int)(10 * AnimationHoverXValue), color));
            else return new SolidBrush(Color.FromArgb(10, color));
        }
        void PaintY(Graphics g, Color color)
        {
            if (AnimationHoverY)
            {
                using (var brush = new SolidBrush(Color.FromArgb(110 + (int)((141 - 110) * AnimationHoverYValue), color)))
                {
                    var slider = RectSliderY();
                    using (var path = slider.RoundPath(slider.Width))
                    {
                        g.FillPath(brush, path);
                    }
                }
            }
            else
            {
                int alpha;
                if (SliderDownY) alpha = 172;
                else alpha = hoverY ? 141 : 110;
                using (var brush = new SolidBrush(Color.FromArgb(alpha, color)))
                {
                    var slider = RectSliderY();
                    using (var path = slider.RoundPath(slider.Width))
                    {
                        g.FillPath(brush, path);
                    }
                }
            }
        }
        void PaintX(Graphics g, Color color)
        {
            if (AnimationHoverX)
            {
                using (var brush = new SolidBrush(Color.FromArgb(110 + (int)((141 - 110) * AnimationHoverXValue), color)))
                {
                    var slider = RectSliderX();
                    using (var path = slider.RoundPath(slider.Height))
                    {
                        g.FillPath(brush, path);
                    }
                }
            }
            else
            {
                int alpha;
                if (SliderDownX) alpha = 172;
                else alpha = hoverX ? 141 : 110;
                using (var brush = new SolidBrush(Color.FromArgb(alpha, color)))
                {
                    var slider = RectSliderX();
                    using (var path = slider.RoundPath(slider.Height))
                    {
                        g.FillPath(brush, path);
                    }
                }
            }
        }

        #region 坐标

        RectangleF RectSliderX()
        {
            float read = RectX.Width - (showY ? SIZE : 0), width = ((RectX.Width * 1F) / maxX) * read;
            if (width < SIZE) width = SIZE;
            float x = (valueX * 1.0F / (maxX - RectX.Width)) * (read - width), gap = (RectX.Height - SIZE_BAR) / 2F;
            return new RectangleF(RectX.X + x + gap, RectX.Y + gap, width - gap * 2, SIZE_BAR);
        }

        RectangleF RectSliderY()
        {
            float read = RectY.Height - (showX ? SIZE : 0), height = ((RectY.Height * 1F) / maxY) * read;
            if (height < SIZE) height = SIZE;
            float y = (valueY * 1.0F / (maxY - RectY.Height)) * (read - height), gap = (RectY.Width - SIZE_BAR) / 2F;
            return new RectangleF(RectY.X + gap, RectY.Y + y + gap, SIZE_BAR, height - gap * 2);
        }

        RectangleF RectSliderFullX()
        {
            float read = RectX.Width - (showY ? SIZE : 0), width = ((RectX.Width * 1F) / maxX) * read;
            if (width < SIZE) width = SIZE;
            float x = (valueX * 1.0F / (maxX - RectX.Width)) * (read - width);
            return new RectangleF(RectX.X + x, RectX.Y, width, RectX.Height);
        }
        RectangleF RectSliderFullY()
        {
            float read = RectY.Height - (showX ? SIZE : 0), height = ((RectY.Height * 1F) / maxY) * read;
            if (height < SIZE) height = SIZE;
            float y = (valueY * 1.0F / (maxY - RectY.Height)) * (read - height);
            return new RectangleF(RectY.X, RectY.Y + y, RectY.Width, height);
        }

        #endregion

        #endregion

        #region 鼠标

        #region 按下

        Point old;
        bool SliderDownX = false;
        float SliderX = 0;
        public bool MouseDownX(Point e)
        {
            if (EnabledX && ShowX && RectX.Contains(e))
            {
                old = e;
                var slider = RectSliderFullX();
                if (!slider.Contains(e))
                {
                    float read = RectX.Width - (showY ? SIZE : 0), x = (e.X - slider.Width / 2F) / read;
                    ValueX = (int)Math.Round(x * maxX);
                    SliderX = RectSliderFullX().X;
                }
                else SliderX = slider.X;
                SliderDownX = true;
                Window.CanHandMessage = false;
                return false;
            }
            return true;
        }

        bool SliderDownY = false;
        float SliderY = 0;
        public bool MouseDownY(Point e)
        {
            if (EnabledY && ShowY && RectY.Contains(e))
            {
                old = e;
                var slider = RectSliderFullY();
                if (!slider.Contains(e))
                {
                    float read = RectY.Height - (showX ? SIZE : 0), y = (e.Y - slider.Height / 2F) / read;
                    ValueY = (int)Math.Round(y * maxY);
                    SliderY = RectSliderFullY().Y;
                }
                else SliderY = slider.Y;
                SliderDownY = true;
                Window.CanHandMessage = false;
                return false;
            }
            return true;
        }

        #endregion

        #region 移动

        public bool MouseMoveX(Point e)
        {
            if (EnabledX && !SliderDownY)
            {
                if (SliderDownX)
                {
                    HoverX = true;
                    var slider = RectSliderFullX();
                    float read = RectX.Width - (showY ? SIZE : 0), x = SliderX + e.X - old.X;
                    ValueX = (int)(x / (read - slider.Width) * (maxX - RectX.Width));
                    return false;
                }
                else if (ShowX && RectX.Contains(e))
                {
                    HoverX = true;
                    return false;
                }
                else HoverX = false;
            }
            return true;
        }
        public bool MouseMoveY(Point e)
        {
            if (EnabledY && !SliderDownX)
            {
                if (SliderDownY)
                {
                    HoverY = true;
                    var slider = RectSliderFullY();
                    float read = RectY.Height - (showX ? SIZE : 0), y = SliderY + e.Y - old.Y;
                    ValueY = (int)(y / (read - slider.Height) * (maxY - RectY.Height));
                    return false;
                }
                else if (ShowY && RectY.Contains(e))
                {
                    HoverY = true;
                    return false;
                }
                else HoverY = false;
            }
            return true;
        }

        #endregion

        public bool MouseUpX()
        {
            if (SliderDownX)
            {
                SliderDownX = false;
                Window.CanHandMessage = true;
                return false;
            }
            return true;
        }
        public bool MouseUpY()
        {
            if (SliderDownY)
            {
                SliderDownY = false;
                Window.CanHandMessage = true;
                return false;
            }
            return true;
        }


        public bool MouseWheelX(int delta)
        {
            if (EnabledX && ShowX && delta != 0)
            {
                int value = ValueX - delta;
                ValueX = value;
                if (ValueX != value) return false;
                return true;
            }
            return false;
        }

        public bool MouseWheelY(int delta)
        {
            if (EnabledY && ShowY && delta != 0)
            {
                int value = ValueY - delta;
                ValueY = value;
                if (ValueY != value) return false;
                return true;
            }
            return false;
        }
        public bool MouseWheel(int delta)
        {
            if (EnabledY)
            {
                if (ShowY && delta != 0)
                {
                    ValueY -= delta;
                    return true;
                }
            }
            else if (EnabledX)
            {
                if (ShowX && delta != 0)
                {
                    ValueX -= delta;
                    return true;
                }
            }
            return false;
        }

        public void Leave()
        {
            HoverX = HoverY = false;
        }

        #endregion

        #region 融合

        public bool Show
        {
            get
            {
                if (EnabledY) return showY;
                return showX;
            }
        }
        public int Value
        {
            get
            {
                if (EnabledY) return valueY;
                return valueX;
            }
            set
            {
                if (EnabledY) ValueY = value;
                else ValueX = value;
            }
        }

        public int VrValueI
        {
            get
            {
                if (EnabledY) return maxY - RectY.Height;
                return maxX - RectX.Width;
            }
        }

        public int ReadSize
        {
            get
            {
                if (EnabledY) return RectY.Height;
                return RectX.Width;
            }
        }

        public int Max
        {
            get
            {
                if (EnabledY) return maxY;
                return maxX;
            }
        }

        /// <summary>
        /// 设置容器虚拟宽度
        /// </summary>
        public void SetVrSize(int len)
        {
            if (EnabledY) SetVrSize(oldx, len);
            else SetVrSize(len, oldy);
        }

        public bool MouseDown(Point e)
        {
            if (EnabledY) return MouseDownY(e);
            return MouseDownX(e);
        }
        public bool MouseMove(Point e)
        {
            if (EnabledY) return MouseMoveY(e);
            return MouseMoveX(e);
        }
        public bool MouseUp()
        {
            if (EnabledY) return MouseUpY();
            return MouseUpX();
        }

        #endregion

        #region 动画

        ITask? ThreadHoverY = null;
        float AnimationHoverYValue = 0F;
        bool AnimationHoverY = false;

        ITask? ThreadHoverX = null;
        float AnimationHoverXValue = 0F;
        bool AnimationHoverX = false;

        #endregion

        public void Dispose()
        { ThreadHoverY?.Dispose(); ThreadHoverX?.Dispose(); }
    }
}