#region

using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Windows.Forms;
using CSFrameworkV5.Business;
using CSFrameworkV5.Common;

#endregion

namespace CSFrameworkV5.Library.UserControls
{
    /// <summary>
    ///     提供透明图片功能的基础控件
    ///     版权：www.csframework.com
    /// </summary>
    public class ucOpacityBase : Control
    {
        private Brush _brushBg;
        private float _iBorderThickness = 1f;
        private float _iOpacity = 1f;
        private Pen _penFg;

        public ucOpacityBase()
        {
            SetStyle(ControlStyles.SupportsTransparentBackColor |
                     ControlStyles.Opaque, true);
            BackColor = Color.Transparent;
            BackgroundBrush = Brushes.Transparent;
            ForegroundPen = Pens.Black;

            TabStop = false; //不自动设置焦点
        }

        #region Propertys

        #region HideParent

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override string Text
        {
            get => base.Text;
            set => base.Text = value;
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override Image BackgroundImage
        {
            get => base.BackgroundImage;
            set => base.BackgroundImage = value;
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override ImageLayout BackgroundImageLayout
        {
            get => base.BackgroundImageLayout;
            set => base.BackgroundImageLayout = value;
        }

        #endregion

        public override Color BackColor
        {
            get => base.BackColor;
            set
            {
                base.BackColor = value;
                ResetBgBrush();
            }
        }

        public override Color ForeColor
        {
            get => base.ForeColor;
            set
            {
                base.ForeColor = value;
                ResetFgPen();
            }
        }

        public float BorderThickness
        {
            get => _iBorderThickness;
            set
            {
                if (value < 0) throw new Exception("Out off range");

                _iBorderThickness = value;
                ResetFgPen();
                ResetDrawRect();
            }
        }

        public float Opacity
        {
            get => _iOpacity;
            set
            {
                if (value > 1 || value < 0)
                    throw new Exception("Out of range,the Value be in [0,1]");

                _iOpacity = value;
                ResetBrushes();
            }
        }

        protected override CreateParams CreateParams
        {
            get
            {
                var cp = base.CreateParams;
                cp.ExStyle = 0x20;
                return cp;
            }
        }

        protected virtual Brush BackgroundBrush
        {
            get => _brushBg;
            set => _brushBg = value;
        }

        protected virtual Pen ForegroundPen
        {
            get => _penFg;
            set => _penFg = value;
        }

        protected virtual RectangleF DrawRect { get; set; }

        #endregion

        #region Methods

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
        }

        protected override void OnSizeChanged(EventArgs e)
        {
            base.OnSizeChanged(e);
            ResetDrawRect();
        }

        protected override void OnPaddingChanged(EventArgs e)
        {
            base.OnPaddingChanged(e);
            ResetDrawRect();
        }

        protected void ResetBrushes()
        {
            ResetBgBrush();
            ResetFgPen();
        }

        protected void ResetBgBrush()
        {
            BackgroundBrush =
                new SolidBrush(GetOpacityColor(BackColor, Opacity));
        }

        protected void ResetFgPen()
        {
            ForegroundPen = new Pen(GetOpacityColor(ForeColor, Opacity),
                BorderThickness);
        }

        protected Color GetOpacityColor(Color baseColor, float op)
        {
            return Color.FromArgb(Convert.ToInt32(op * baseColor.A), baseColor);
        }

        private void ResetDrawRect()
        {
            var dbwidth = 2 * BorderThickness;
            var halfwidth = BorderThickness / 2;
            var paddingWhith = Padding.Left + Padding.Right;
            var paddingHeight = Padding.Top + Padding.Bottom;
            if (dbwidth > Width - paddingWhith ||
                dbwidth > Height - paddingHeight)
                DrawRect = Bounds;
            else
                DrawRect = new RectangleF(Padding.Left + halfwidth,
                    Padding.Top + halfwidth,
                    Width - BorderThickness - paddingWhith,
                    Height - BorderThickness - paddingHeight);
        }

        #endregion
    }

    /// <summary>
    ///     透明图片组件
    /// </summary>
    public class ucOpacityImage : ucOpacityBase
    {
        private ImageFillMode _fillMode = ImageFillMode.Zoom;
        private Image _image;

        protected override RectangleF DrawRect
        {
            get => base.DrawRect;
            set
            {
                base.DrawRect = value;
                ResetPaintImage();
            }
        }

        /// <summary>
        ///     图像填充模式
        /// </summary>
        public ImageFillMode FillMode
        {
            get => _fillMode;
            set
            {
                _fillMode = value;
                ResetPaintImage();
            }
        }

        /// <summary>
        ///     加载图像
        /// </summary>
        public Image Image
        {
            get => _image;
            set
            {
                _image = value;
                ResetPaintImage();
            }
        }

        protected Image PaintImage { get; private set; }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            if (PaintImage != null)
            {
                e.Graphics.DrawImage(PaintImage, Point.Empty);
            }
            else
            {
                if (_image != null) e.Graphics.DrawImage(_image, Point.Empty);
            }
        }

        /// <summary>
        ///     使用缩放的方式重新显示图片
        /// </summary>
        public void RefreshImage()
        {
            Width++;
            Width--;
        }

        /// <summary>
        ///     重绘图像
        /// </summary>
        private void ResetPaintImage()
        {
            if (PaintImage != null)
            {
                PaintImage.Dispose();
                PaintImage = null;
            }

            if (Image != null && Image.Width > 0 && Image.Height > 0 &&
                DrawRect.Width > 0 && DrawRect.Height > 0)
            {
                PaintImage = new Bitmap((int)DrawRect.Width,
                    (int)DrawRect.Height);
                using (var g = Graphics.FromImage(PaintImage))
                {
                    var ima = new ImageAttributes();
                    var cm = new ColorMatrix();
                    cm.Matrix33 = Opacity;
                    ima.SetColorMatrix(cm);
                    var pt = Point.Empty;
                    switch (FillMode)
                    {
                        case ImageFillMode.Center: //居中图像
                            pt = new Point(
                                (int)(DrawRect.Width - Image.Width) / 2,
                                (int)(DrawRect.Height - Image.Height) / 2);
                            g.DrawImage(Image, new Rectangle(pt, Image.Size), 0,
                                0, Image.Width, Image.Height,
                                GraphicsUnit.Pixel, ima);
                            break;
                        case ImageFillMode.Strength: //自由扩展图像
                            g.DrawImage(Image, Rectangle.Round(DrawRect), 0, 0,
                                Image.Width, Image.Height,
                                GraphicsUnit.Pixel, ima);
                            break;
                        case ImageFillMode.Title: //平铺图像
                            ima.SetWrapMode(WrapMode.Tile);
                            var brush = new TextureBrush(Image,
                                new Rectangle(0, 0, Image.Width, Image.Height),
                                ima);
                            g.FillRectangle(brush, DrawRect);
                            brush.Dispose();
                            break;
                        case ImageFillMode.Zoom: //缩放图像
                            float scale = 1;
                            if (Image.Width > 0 && Image.Height > 0 &&
                                DrawRect.Width > 0 && DrawRect.Height > 0)
                            {
                                var f1 = DrawRect.Width / Image.Width;
                                var f2 = DrawRect.Height / Image.Height;
                                scale = f1 > f2 ? f2 : f1;
                                var zWidth = scale * Image.Width;
                                var zHeight = scale * Image.Height;
                                var zoomRect = new Rectangle(0, 0, (int)zWidth,
                                    (int)zHeight);
                                g.DrawImage(Image, zoomRect, 0, 0, Image.Width,
                                    Image.Height, GraphicsUnit.Pixel, ima);
                            }

                            break;
                    }
                }
            }
            else
            {
                PaintImage = null;
            }
        }

        public void ShowImage(bllBaseBusiness BLL)
        {
            if (BLL.DataBindRow == null)
            {
                Image = null;
            }
            else
            {
                if (BLL.IsApproved(BLL.DataBindRow))
                    Image = Globals.LoadImage("已审核.gif");
                else
                    Image = Globals.LoadImage("未审核.gif");
            }

            RefreshImage();
        }
    }

    /// <summary>
    ///     图像填充类型
    /// </summary>
    public enum ImageFillMode
    {
        /// <summary>
        ///     缩放图像
        /// </summary>
        Zoom,

        /// <summary>
        ///     平铺图像
        /// </summary>
        Title,

        /// <summary>
        ///     自由扩展图像
        /// </summary>
        Strength,

        /// <summary>
        ///     居中图像
        /// </summary>
        Center
    }
}