namespace Yw.WinFrmUI.HydroL2d
{
    /// <summary>
    /// 管网面板
    /// </summary>
    public partial class NetworkPanel : Panel
    {
        public NetworkPanel()
        {
            InitializeComponent();

            #region 防止闪烁

            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.DoubleBuffer, true);
            SetStyle(ControlStyles.UserPaint, true);

            #endregion

            //设置允许的最小尺寸
            this.MinimumSize = new Size(10, 10);
        }

        #region 初始化

        protected Network _network = null;//管网
        protected RectangleF _networkBounds;//管网边界
        protected RectangleF _clientRectf;//工作区域矩形

        /// <summary>
        /// 是否初始化
        /// </summary>
        public bool Initialized => _network != null;

        /// <summary>
        /// 初始化
        /// </summary>
        public virtual void Initial(Network network)
        {
            _network = network;
            _networkBounds = _network.GetBounds();
            _clientRectf = GetClientRectangleF();
            CreateCache();
            ZoomAll();
        }

        #endregion

        #region 缓存与显示

        private Bitmap _cache = null;//缓存<依据工作区域创建的空图片>
        private object _cacheLocker = new();//缓存锁

        /// <summary>
        /// 创建缓存
        /// </summary>
        protected virtual void CreateCache()
        {
            if (!Initialized)
            {
                return;
            }
            var img = new Bitmap((int)_clientRectf.Width, (int)_clientRectf.Height);
            lock (_cacheLocker)
            {
                if (_cache != null)
                {
                    _cache.Dispose();
                }
                _cache = img;
            }
        }

        /// <summary>
        /// 绘制缓存
        /// </summary>
        protected virtual void DrawCache()
        {
            if (!Initialized)
            {
                return;
            }
            if (_cache == null)
            {
                return;
            }
            var dispRect = GetDispRectangleF();
            using (var g = Graphics.FromImage(_cache))
            {
                g.Clear(Color.White);
                g.PageUnit = GraphicsUnit.Pixel;
                g.InterpolationMode = InterpolationMode.High;
                g.SmoothingMode = SmoothingMode.AntiAlias;
                g.PixelOffsetMode = PixelOffsetMode.HighQuality;
                g.PageScale = _zoom;
                g.TranslateTransform(_dxo, _dyo);
                g.ScaleTransform(1, -1);

                _network.Draw(g, dispRect);
            }
        }

        /// <summary>
        /// 应用缓存
        /// </summary>
        protected virtual void ApplyCache(Graphics g)
        {
            if (!Initialized)
            {
                return;
            }
            lock (_cacheLocker)
            {
                if (_cache != null)
                {
                    g.DrawImage(_cache, _clientRectf);
                }
            }

        }

        #endregion

        #region 缩放与偏移

        private float _zoomMin = 0.001f;//最小缩放层级
        private float _zoomMax = 30000f;//最大缩放层级
        private float _zoom = 1f;//当前缩放层级
        private float _dxo = 0f;//x偏移量
        private float _dyo = 0f;//y偏移量

        /// <summary>
        /// 缩放等级
        /// </summary>
        public float Zoom
        {
            get => _zoom;
            private set
            {
                if (_networkBounds.IsEmpty)
                {
                    _zoom = 1f;
                    return;
                }

                float sizeMax = Math.Max(_networkBounds.Height, _networkBounds.Width);
                float sizeNew = sizeMax * value;

                if (sizeNew > _zoomMax)
                {
                    _zoom = _zoomMax / sizeMax;
                }
                else if (sizeNew < _zoomMin)
                {
                    _zoom = _zoomMin / sizeMax;
                }
                else
                {
                    _zoom = value;
                }
            }
        }

        /// <summary>
        /// 自适应
        /// </summary>
        public void ZoomAll()
        {
            if (!Initialized)
            {
                return;
            }
            var networkBounds = _network.GetBounds();
            if (networkBounds.IsEmpty)
            {
                return;
            }
            this.Zoom = networkBounds.Width / networkBounds.Height < this.Width / this.Height ?
                this.Height / networkBounds.Height :
                this.Width / networkBounds.Width;


            _dxo = -networkBounds.X;
            _dyo = networkBounds.Bottom;

            this.Zoom *= 0.9f;

            _dxo += this.Width * 0.5f / this.Zoom - networkBounds.Width * 0.5f;
            _dyo += this.Height * 0.5f / this.Zoom - networkBounds.Height * 0.5f;
        }


        private void ZoomToPoint(MouseEventArgs e)
        {
            float scale = e.Delta > 0 ? this.Zoom * 1.5f : this.Zoom / 1.5f;
            var pt = ClientToDispPoint(e.Location);
            this.Zoom = scale;
            _dxo = -pt.X + e.X / this.Zoom;
            _dyo = pt.Y + e.Y / this.Zoom;
        }

        #endregion

        #region 坐标转换

        protected PointF ClientToDispPoint(PointF cp)
        {
            return new PointF(-_dxo + cp.X / _zoom, _dyo - cp.Y / _zoom);
        }

        #endregion

        #region 边框绘制

        /// <summary>
        /// 边框颜色
        /// </summary>
        [Browsable(true)]
        [Description("自定义边框颜色")]
        public Color CustomBorderColor
        {
            get { return _customBorderColor; }
            set { _customBorderColor = value; }
        }
        private Color _customBorderColor = Color.Gray;

        /// <summary>
        /// 边框宽度
        /// </summary>
        [Browsable(true)]
        [Description("自定义边框宽度")]
        public int CustomBorderWidth
        {
            get { return _customBorderWidth; }
            set { _customBorderWidth = value; }
        }
        private int _customBorderWidth = 1;

        /// <summary>
        /// 边框是否显示
        /// </summary>
        [Browsable(true)]
        [Description("自定义边框可见性")]
        [DefaultValue(false)]
        public bool CustomBorderVisible
        {
            get { return _customBorderVisible; }
            set
            {
                _customBorderVisible = value;
            }
        }
        private bool _customBorderVisible = false;

        /// <summary>
        /// 绘制自定义边框
        /// </summary>
        protected virtual void DrawCustomBorder(Graphics g)
        {
            if (this.CustomBorderVisible)
            {
                ControlPaint.DrawBorder(g,
                                                    this.ClientRectangle,
                                                    this.CustomBorderColor, this.CustomBorderWidth, ButtonBorderStyle.Solid,
                                                    this.CustomBorderColor, this.CustomBorderWidth, ButtonBorderStyle.Solid,
                                                    this.CustomBorderColor, this.CustomBorderWidth, ButtonBorderStyle.Solid,
                                                    this.CustomBorderColor, this.CustomBorderWidth, ButtonBorderStyle.Solid);
            }
        }


        #endregion

        #region 获取矩形区域

        /// <summary>
        /// 获取工作区域
        /// </summary>
        /// <returns></returns>
        protected virtual RectangleF GetClientRectangleF()
        {
            return new RectangleF(0, 0, this.Width, this.Height);
        }

        /// <summary>
        /// 获取显示区域
        /// </summary>
        protected virtual RectangleF GetDispRectangleF()
        {
            if (_clientRectf.IsEmpty)
            {
                return default;
            }
            if (!Initialized)
            {
                return default;
            }
            var pt = ClientToDispPoint(new PointF(_clientRectf.X, _clientRectf.Height));
            var width = _clientRectf.Width / _zoom;
            var height = _clientRectf.Height / _zoom;
            return new RectangleF(pt, new SizeF(width, height));
        }

        #endregion

        #region 鼠标左键按下拖动

        /// <summary>
        /// 当鼠标左键按下时允许拖动
        /// </summary>
        [Browsable(true)]
        [Description("当鼠标左键按下时允许拖动")]
        [DefaultValue(true)]
        public bool AllowMoveWhenMouseLeftDown
        {
            get => _allowMoveWhenMouseLeftDown;
            set => _allowMoveWhenMouseLeftDown = value;
        }
        private bool _allowMoveWhenMouseLeftDown = true;

        protected bool _hasMouseLeftDown = false;//鼠标左键是否按下
        protected Point _mouseLeftDownMovePoint;//鼠标左键按下移动点

        /// <summary>
        /// 判断鼠标左键是否按下
        /// </summary>
        protected virtual bool HasMouseLeftDown(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                _hasMouseLeftDown = true;
                _mouseLeftDownMovePoint = e.Location;
                return true;
            }
            return false;
        }

        /// <summary>
        /// 鼠标左键按下移动
        /// </summary>
        /// <param name="e"></param>
        protected virtual bool MouseLeftDownMove(MouseEventArgs e)
        {
            if (_hasMouseLeftDown)
            {
                if (this.AllowMoveWhenMouseLeftDown)
                {
                    if (this.Initialized)
                    {
                        var pt = new PointF(e.X - _mouseLeftDownMovePoint.X, e.Y - _mouseLeftDownMovePoint.Y);
                        _dxo += pt.X / _zoom;
                        _dyo += pt.Y / _zoom;
                        _mouseLeftDownMovePoint = e.Location;
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 判断鼠标左键是否弹起
        /// </summary>
        protected virtual bool HasMouseLeftUp(MouseEventArgs e)
        {
            if (_hasMouseLeftDown)
            {
                _hasMouseLeftDown = false;
                return true;
            }
            return false;
        }

        #endregion

        #region 鼠标右键按下拖动

        /// <summary>
        /// 当鼠标右键按下时允许拖动
        /// </summary>
        [Browsable(true)]
        [Description("当鼠标右键按下时允许拖动")]
        [DefaultValue(true)]
        public bool AllowMoveWhenMouseRightDown
        {
            get => _allowMoveWhenMouseRightDown;
            set => _allowMoveWhenMouseRightDown = value;
        }
        private bool _allowMoveWhenMouseRightDown = true;

        protected bool _hasMouseRightDown = false;//鼠标右键是否按下
        protected Point _mouseRightDownMovePoint;//鼠标右键按下移动点

        /// <summary>
        /// 判断鼠标右键是否按下
        /// </summary>
        protected virtual bool HasMouseRightDown(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                _hasMouseRightDown = true;
                _mouseRightDownMovePoint = e.Location;
                return true;
            }
            return false;
        }

        /// <summary>
        /// 鼠标右键按下移动
        /// </summary>
        protected virtual bool MouseRightDownMove(MouseEventArgs e)
        {
            if (_hasMouseRightDown)
            {
                if (this.AllowMoveWhenMouseRightDown)
                {
                    if (this.Initialized)
                    {
                        var pt = new PointF(e.X - _mouseRightDownMovePoint.X, e.Y - _mouseRightDownMovePoint.Y);
                        _dxo += pt.X / _zoom;
                        _dyo += pt.Y / _zoom;
                        _mouseRightDownMovePoint = e.Location;
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 判断鼠标左键是否弹起
        /// </summary>
        protected virtual bool HasMouseRightUp(MouseEventArgs e)
        {
            if (_hasMouseRightDown)
            {
                _hasMouseRightDown = false;
                return true;
            }
            return false;
        }

        #endregion

        #region 鼠标左键双击恢复自适应

        /// <summary>
        /// 当鼠标双击时允许自适应
        /// </summary>
        [Browsable(true)]
        [Description("当鼠标双击时允许自适应")]
        [DefaultValue(true)]
        public bool AllowZoomAllWhenMouseLeftDoubleClick
        {
            get => _allowZoomAllWhenMouseLeftDoubleClick;
            set => _allowZoomAllWhenMouseLeftDoubleClick = value;
        }
        private bool _allowZoomAllWhenMouseLeftDoubleClick = true;

        /// <summary>
        /// 鼠标双击时自适应
        /// </summary>
        protected virtual bool ZoomAllWhenMouseLeftDoubleClick(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                if (e.Clicks > 1)
                {
                    if (this.AllowZoomAllWhenMouseLeftDoubleClick)
                    {
                        if (this.Initialized)
                        {
                            ZoomAll();
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        #endregion

        #region 鼠标悬停

        /// <summary>
        /// 允许鼠标悬停
        /// </summary>
        [Browsable(true)]
        [Description("允许鼠标悬停")]
        [DefaultValue(true)]
        public bool AllowMouseHover
        {
            get => _allowMouseHover;
            set => _allowMouseHover = value;
        }
        private bool _allowMouseHover = true;
        private List<Parter> _lastHoverList = null;//最后一次悬停列表

        /// <summary>
        /// 悬停
        /// 如果发生改变就返回true
        /// </summary>
        protected virtual bool Hover(MouseEventArgs e)
        {
            if (this.AllowMouseHover)
            {
                if (this.Initialized)
                {
                    var pt = ClientToDispPoint(e.Location);
                    var hoverList = _network.Hover(pt);
                    if (hoverList == null || hoverList.Count < 1)
                    {
                        if (_lastHoverList == null || _lastHoverList.Count < 1)
                        {
                            return false;
                        }
                    }
                    _lastHoverList = hoverList;
                    return true;
                }
            }
            if (_lastHoverList == null || _lastHoverList.Count < 1)
            {
                return false;
            }
            return true;
        }

        #endregion

        #region 鼠标左键点击选择

        /// <summary>
        /// 允许鼠标左键单击选择
        /// </summary>
        [Browsable(true)]
        [Description("允许鼠标左键单击选择")]
        [DefaultValue(true)]
        public bool AllowMouseLeftSingleClickSelect
        {
            get => _allowMouseLeftSingleClickSelect;
            set => _allowMouseLeftSingleClickSelect = value;
        }
        private bool _allowMouseLeftSingleClickSelect = true;
        private List<Parter> _lastMouseLeftClickSelectList = null;//最后一次鼠标左键单击选择列表


        /// <summary>
        /// 当鼠标左键单击时选择
        /// </summary>
        protected virtual bool SelectWhenMouseLeftSingleClick(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                if (e.Clicks == 1)
                {
                    if (this.Initialized)
                    {
                        var pt = ClientToDispPoint(e.Location);
                        var selectList = _network.Select(pt);
                        if (selectList == null || selectList.Count < 1)
                        {
                            if (_lastMouseLeftClickSelectList == null || _lastMouseLeftClickSelectList.Count < 1)
                            {
                                return false;
                            }
                        }
                        _lastMouseLeftClickSelectList = selectList;
                        return true;
                    }
                }
            }
            if (_lastMouseLeftClickSelectList == null || _lastMouseLeftClickSelectList.Count < 1)
            {
                return false;
            }
            return true;
        }

        #endregion

        #region 鼠标滚轮滚动缩放

        /// <summary>
        /// 当鼠标滚轮滚动时允许缩放
        /// </summary>
        [Browsable(true)]
        [Description("当鼠标滚轮滚动时允许缩放")]
        [DefaultValue(true)]
        public bool AllowZoomWhenMouseWheelRoll
        {
            get => _allowZoomWhenMouseWheelRoll;
            set => _allowZoomWhenMouseWheelRoll = value;
        }
        private bool _allowZoomWhenMouseWheelRoll = true;

        /// <summary>
        /// 当鼠标滚轮滚动时缩放
        /// </summary>
        protected virtual bool ZoomWhenMouseWheelRoll(MouseEventArgs e)
        {
            if (e.Delta != 0)
            {
                if (this.AllowZoomWhenMouseWheelRoll)
                {
                    if (this.Initialized)
                    {
                        ZoomToPoint(e);
                        return true;
                    }
                }
            }
            return false;
        }

        #endregion

        #region 释放资源

        /// <summary>
        /// 释放资源
        /// </summary>
        protected virtual void DisposeResources()
        {
            if (_cache != null)
            {
                _cache.Dispose();
            }

        }

        #endregion



        /// <summary>
        /// 重绘
        /// </summary>
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            DrawCustomBorder(e.Graphics);
            DrawCache();
            ApplyCache(e.Graphics);

        }

        /// <summary>
        /// 界面尺寸发生改变
        /// </summary>
        /// <param name="eventargs"></param>
        protected override void OnResize(EventArgs eventargs)
        {
            base.OnResize(eventargs);
            _clientRectf = GetClientRectangleF();
            ZoomAll();
            CreateCache();
            this.Invalidate();
        }

        /// <summary>
        /// 鼠标按下
        /// </summary>
        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
            HasMouseLeftDown(e);
            HasMouseRightDown(e);
        }

        /// <summary>
        /// 鼠标移动
        /// </summary>
        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);
            var hoverResult = Hover(e);
            var hasMouseLeftDownMove = MouseLeftDownMove(e);
            var hasMouseRightDownMove = MouseRightDownMove(e);
            if (hoverResult || hasMouseLeftDownMove || hasMouseRightDownMove)
            {
                this.Invalidate();
            }
        }

        /// <summary>
        /// 鼠标弹起
        /// </summary>
        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
            var hasMouseLeftUp = HasMouseLeftUp(e);
            var hasMouseRightUp = HasMouseRightUp(e);
            var mouseLeftSingleClickSelectResult = SelectWhenMouseLeftSingleClick(e);
            if (hasMouseLeftUp || hasMouseRightUp || mouseLeftSingleClickSelectResult)
            {
                this.Invalidate();
            }
        }

        //鼠标滚轮滚动
        protected override void OnMouseWheel(MouseEventArgs e)
        {
            base.OnMouseWheel(e);
            var zoomWhenMouseWheelRollResult = ZoomWhenMouseWheelRoll(e);
            if (zoomWhenMouseWheelRollResult)
            {
                this.Refresh();
            }
        }

        /// <summary>
        /// 鼠标双击
        /// </summary>
        protected override void OnMouseDoubleClick(MouseEventArgs e)
        {
            base.OnMouseDoubleClick(e);
            var zoomAllWhenMouseLeftDoubleClickResult = ZoomAllWhenMouseLeftDoubleClick(e);
            if (zoomAllWhenMouseLeftDoubleClickResult)
            {
                this.Invalidate();
            }
        }

    }
}