using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Globalization;
using System.Windows.Forms;

namespace DevComponents.Instrumentation
{
    [TypeConverter(typeof(GaugeFrameConvertor))]
    public class GaugeFrame : IDisposable
    {
        #region Events

        [Description("Occurs when the Gauge Frame is changed.")]
        public event EventHandler<EventArgs> GaugeFrameChanged;

        [Description("Occurs before the Gauge Frame is rendered.")]
        public event EventHandler<PreRenderFrameEventArgs> PreRenderFrame;

        [Description("Occurs after the Gauge Frame has been rendered.")]
        public event EventHandler<PostRenderFrameEventArgs> PostRenderFrame;

        [Description("Occurs when the Gauge Frame Region should be set.")]
        public event EventHandler<SetFrameRegionEventArgs> SetGaugeFrameRegion;

        #endregion

        #region Private variables

        private GaugeFrameStyle _Style;

        private float _InnerBevel;
        private float _OuterBevel;
        private float _RoundRectangleArc;

        private float _BackSigmaFocus;
        private float _BackSigmaScale;
        private float _FrameSigmaFocus;
        private float _FrameSigmaScale;

        private GradientFillColor _BackColor;
        private GradientFillColor _FrameColor;

        private bool _ClipOuterFrame;
        private bool _AddGlassEffect;

        private Image _Image;

        private GaugeControl _GaugeControl;

        private bool _AutoCenter;
        private bool _NeedRecalcLayout;

        private Rectangle _Bounds;
        private Rectangle _BackBounds;
        private PointF _Center;

        private GaugeFrameRenderer _Renderer;

        #endregion

        public GaugeFrame(GaugeControl gaugeControl)
        {
            _GaugeControl = gaugeControl;

            Style = GaugeFrameStyle.None;

            _InnerBevel = .035f;
            _OuterBevel = .05f;
            _RoundRectangleArc = .125f;

            _BackSigmaFocus = 1;
            _BackSigmaScale = 1;
            _FrameSigmaFocus = .15f;
            _FrameSigmaScale = 1;

            BackColor = new GradientFillColor(Color.Silver, Color.Gray, 45);
            FrameColor = new GradientFillColor(Color.Gainsboro, Color.Gray, 45);
        }

        #region Public properties

        #region AbsBevelInside

        /// <summary>
        /// Gets the calculated inside bevel dimension for the frame
        /// </summary>
        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int AbsBevelInside
        {
            get
            {
                int n = MinDimension;

                return (_InnerBevel < .5f) ?
                    (int)(n * _InnerBevel) : n / 2;
            }
        }

        #endregion

        #region AbsBevelOutside

        /// <summary>
        /// Gets the calculated outside bevel dimension for the frame
        /// </summary>
        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int AbsBevelOutside
        {
            get
            {
                int n = MinDimension;

                return (_OuterBevel < .5f) ?
                    (int)(n * _OuterBevel) : n / 2;
            }
        }

        #endregion

        #region AddGlassEffect

        /// <summary>
        /// Gets or sets whether to add a Glass Effect to the frame
        /// </summary>
        [Browsable(true)]
        [Category("Appearance"), DefaultValue(false)]
        [Description("Indicates whether to add a Glass Effect to the frame.")]
        public bool AddGlassEffect
        {
            get { return (_AddGlassEffect); }

            set
            {
                if (_AddGlassEffect != value)
                {
                    _AddGlassEffect = value;

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #region BackBounds

        /// <summary>
        /// Gets the background bounding rectangle
        /// </summary>
        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle BackBounds
        {
            get { return (_BackBounds); }
            internal set { _BackBounds = value; }
        }

        #endregion

        #region BackColor

        /// <summary>
        /// Gets or sets the background Color of the Gauge.
        /// </summary>
        [Browsable(true),Category("Appearance")]
        [Description("Indicates the background Color of the Gauge.")]
        public GradientFillColor BackColor
        {
            get
            {
                if (_BackColor == null)
                {
                    _BackColor = new GradientFillColor();
                    _BackColor.ColorTableChanged += BackColor_ColorTableChanged;
                }

                return (_BackColor);
            }

            set
            {
                if (_BackColor != null)
                    _BackColor.ColorTableChanged -= BackColor_ColorTableChanged;

                _BackColor = value;

                if (_BackColor != null)
                    _BackColor.ColorTableChanged += BackColor_ColorTableChanged;

                OnGaugeFrameChanged();
            }
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        internal virtual bool ShouldSerializeBackColor()
        {
            return (BackColor.IsEqualTo(Color.Silver,
                Color.Gray, 45, GradientFillType.Auto, Color.Empty, 0) == false);
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        internal virtual void ResetBackColor()
        {
            BackColor = new GradientFillColor(Color.Silver, Color.Gray, 45);
        }

        #endregion

        #region BackSigmaFocus

        /// <summary>
        /// Gets or sets the SigmaBellShape Focus used when Center filling the frame.
        /// </summary>
        [Browsable(true)]
        [Category("Appearance"), DefaultValue(1f)]
        [Description("Indicates the SigmaBellShape Focus used when Center filling the frame.")]
        [Editor("DevComponents.Instrumentation.Design.WidthMaxRangeValueEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
        public float BackSigmaFocus
        {
            get { return (_BackSigmaFocus); }

            set
            {
                if (value < 0 || value > 1)
                    throw new ArgumentException("Value must be between 0 and 1.");

                if (_BackSigmaFocus != value)
                {
                    _BackSigmaFocus = value;

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #region BackSigmaScale

        /// <summary>
        /// Gets or sets the SigmaBellShape Scale used when Center filling the frame.
        /// </summary>
        [Browsable(true)]
        [Category("Appearance"), DefaultValue(1f)]
        [Description("Indicates the SigmaBellShape Scale used when Center filling the frame.")]
        [Editor("DevComponents.Instrumentation.Design.WidthMaxRangeValueEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
        public float BackSigmaScale
        {
            get { return (_BackSigmaScale); }

            set
            {
                if (value < 0 || value > 1)
                    throw new ArgumentException("Value must be between 0 and 1.");

                if (_BackSigmaScale != value)
                {
                    _BackSigmaScale = value;

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #region Bounds

        /// <summary>
        /// Gets the bounding frame rectangle
        /// </summary>
        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle Bounds
        {
            get { return (_Bounds); }
            internal set { _Bounds = value; }
        }

        #endregion

        #region Center

        /// <summary>
        /// Gets the center of the gauge frame
        /// </summary>
        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public PointF Center
        {
            get { return (_Center); }
            internal set { _Center = value; }
        }

        #endregion

        #region InnerBevel

        /// <summary>
        /// Gets or sets the inner frame bevel width, measured as a percentage of the width/height.
        /// </summary>
        [Browsable(true)]
        [Category("Appearance"), DefaultValue(.035f)]
        [Description("Indicates the inner frame bevel width, measured as a percentage of the width/height.")]
        [Editor("DevComponents.Instrumentation.Design.HalfRadiusRangeValueEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
        public float InnerBevel
        {
            get { return (_InnerBevel); }

            set
            {
                if (_InnerBevel != value)
                {
                    if (value < 0 || value > .5f)
                        throw new ArgumentException("Value must be between 0 and .5");

                    _InnerBevel = value;

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #region OuterBevel

        /// <summary>
        /// Gets or sets the outer frame bevel width, measured as a percentage of the width/height.
        /// </summary>
        [Browsable(true)]
        [Category("Appearance"), DefaultValue(.05f)]
        [Description("Indicates the outer frame bevel width, measured as a percentage of the width/height.")]
        [Editor("DevComponents.Instrumentation.Design.HalfRadiusRangeValueEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
        public float OuterBevel
        {
            get { return (_OuterBevel); }

            set
            {
                if (value < 0 || value > .5f)
                    throw new ArgumentException("Value must be between 0 and .5");

                if (_OuterBevel != value)
                {
                    _OuterBevel = value;

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #region ClipOuterFrame

        /// <summary>
        /// Gets and sets whether the frame exterior is clipped.
        /// </summary>
        [Browsable(true), Category("Appearance"), DefaultValue(false)]
        [Description("Indicates whether the frame exterior is clipped.")]
        public bool ClipOuterFrame
        {
            get { return (_ClipOuterFrame); }

            set
            {
                if (_ClipOuterFrame != value)
                {
                    _ClipOuterFrame = value;

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #region FrameColor

        /// <summary>
        /// Gets or sets the Frame Color of the Gauge.
        /// </summary>
        [Browsable(true), Category("Appearance")]
        [Description("Indicates the Frame Color of the Gauge.")]
        public GradientFillColor FrameColor
        {
            get
            {
                if (_FrameColor == null)
                {
                    _FrameColor = new GradientFillColor();
                    _FrameColor.ColorTableChanged += FrameColor_ColorTableChanged;
                }

                return (_FrameColor);
            }

            set
            {
                if (_FrameColor != null)
                    _FrameColor.ColorTableChanged -= FrameColor_ColorTableChanged;

                _FrameColor = value;

                if (_FrameColor != null)
                    _FrameColor.ColorTableChanged += FrameColor_ColorTableChanged;

                OnGaugeFrameChanged();
            }
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        internal virtual bool ShouldSerializeFrameColor()
        {
            return (FrameColor.IsEqualTo(Color.Gainsboro,
                Color.Gray, 45, GradientFillType.Auto, Color.Empty, 0) == false);
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        internal void ResetFrameColor()
        {
            FrameColor = new GradientFillColor(Color.Gainsboro, Color.Gray, 45);
        }

        #endregion

        #region Image

        /// <summary>
        /// Gets of sets the Image to use for the Gauge Frame
        /// </summary>
        [Browsable(true)]
        [Category("Appearance"), DefaultValue(null)]
        [Description("Indicates the Image to use for the Gauge Frame.")]
        public Image Image
        {
            get { return (_Image); }

            set
            {
                if (_Image != value)
                {
                    _Image = value;

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #region FrameSigmaFocus

        /// <summary>
        /// Gets or sets the SigmaBellShape.Focus used when Center filling the frame.
        /// </summary>
        [Browsable(true)]
        [Category("Appearance"), DefaultValue(.15f)]
        [Description("Indicates the SigmaBellShape.Focus used when Center filling the frame.")]
        [Editor("DevComponents.Instrumentation.Design.WidthMaxRangeValueEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
        public float FrameSigmaFocus
        {
            get { return (_FrameSigmaFocus); }

            set
            {
                if (value < 0 || value > 1)
                    throw new ArgumentException("Value must be between 0 and 1.");

                if (_FrameSigmaFocus != value)
                {
                    _FrameSigmaFocus = value;

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #region FrameSigmaScale

        /// <summary>
        /// Gets or sets the SigmaBellShape.Scale used when Center filling the frame.
        /// </summary>
        [Browsable(true)]
        [Category("Appearance"), DefaultValue(1f)]
        [Description("Indicates the SigmaBellShape.Scale used when Center filling the frame.")]
        [Editor("DevComponents.Instrumentation.Design.WidthMaxRangeValueEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
        public float FrameSigmaScale
        {
            get { return (_FrameSigmaScale); }

            set
            {
                if (value < 0 || value > 1)
                    throw new ArgumentException("Value must be between 0 and 1.");

                if (_FrameSigmaScale != value)
                {
                    _FrameSigmaScale = value;

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #region GaugeControl

        /// <summary>
        /// Gets the parent GaugeControl.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public GaugeControl GaugeControl
        {
            get { return (_GaugeControl); }
        }

        #endregion

        #region RoundRectangleArc

        /// <summary>
        /// Gets or sets the arc radius used when drawing RoundRectangle
        /// frames, measured as a percentage of the width/height.
        /// </summary>
        [Browsable(true)]
        [Category("Appearance"), DefaultValue(.125f)]
        [Description("Indicates the arc radius used when drawing RoundRectangle frames, measured as a percentage of the width/height.")]
        [Editor("DevComponents.Instrumentation.Design.WidthMaxRangeValueEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
        public float RoundRectangleArc
        {
            get { return (_RoundRectangleArc); }

            set
            {
                if (_RoundRectangleArc != value)
                {
                    if (value < 0 || value > 1f)
                        throw new ArgumentException("Radius must be between 0 and 1");

                    _RoundRectangleArc = value;

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #region Style

        /// <summary>
        /// Gets or sets the frame Style.
        /// </summary>
        [Browsable(true)]
        [Category("Appearance"), DefaultValue(GaugeFrameStyle.None)]
        [Description("Indicates the frame Style.")]
        public GaugeFrameStyle Style
        {
            get { return (_Style); }

            set
            {
                if (_Style != value)
                {
                    _Style = value;
                    _AutoCenter = false;

                    switch (_Style)
                    {
                        case GaugeFrameStyle.Circular:
                            _AutoCenter = true;
                            _Renderer = new GaugeFrameCircularRenderer(this);
                            break;

                        case GaugeFrameStyle.Rectangular:
                            _Renderer = new GaugeFrameRectangularRenderer(this);
                            break;

                        case GaugeFrameStyle.RoundedRectangular:
                            _Renderer = new GaugeFrameRoundRectRenderer(this);
                            break;

                        default:
                            _Renderer = null;
                            break;
                    }

                    OnGaugeFrameChanged();
                }
            }
        }

        #endregion

        #endregion

        #region Internal properties

        #region AutoCenter

        internal bool AutoCenter
        {
            get { return (_AutoCenter); }
        }

        #endregion

        #region Renderer

        internal GaugeFrameRenderer Renderer
        {
            get { return (_Renderer); }
            set { _Renderer = value; }
        }

        #endregion

        #region MinDimension

        internal int MinDimension
        {
            get { return (Math.Min(_Bounds.Width, _Bounds.Height)); }
        }

        #endregion

        #region NeedRecalcLayout

        internal bool NeedRecalcLayout
        {
            get { return (_NeedRecalcLayout); }
            set { _NeedRecalcLayout = value; }
        }

        #endregion

        #endregion

        #region Event processing

        #region BackColor_ColorTableChanged

        void BackColor_ColorTableChanged(object sender, EventArgs e)
        {
            OnGaugeFrameChanged();
        }

        #endregion

        #region FrameColor_ColorTableChanged

        void FrameColor_ColorTableChanged(object sender, EventArgs e)
        {
            OnGaugeFrameChanged();
        }

        #endregion

        #endregion

        #region OnGaugeFrameChanged

        private void OnGaugeFrameChanged()
        {
            _NeedRecalcLayout = true;

            if (GaugeFrameChanged != null)
                GaugeFrameChanged(this, EventArgs.Empty);
        }

        #endregion

        #region RecalcLayout

        internal void RecalcLayout()
        {
            if (_NeedRecalcLayout == true)
            {
                int n = Math.Min(_GaugeControl.Width, _GaugeControl.Height);

                if (_Style == GaugeFrameStyle.Circular)
                {
                    // Allow a couple of extra pixels 
                    // for better antialiasing with dark back colors...

                    n -= 2;

                    int x = (_GaugeControl.Width - n) / 2;
                    int y = (_GaugeControl.Height - n) / 2;

                    n = Math.Max(n, 1);

                    _Bounds = new Rectangle(x, y, n, n);
                }
                else
                {
                    _Bounds = new Rectangle(Point.Empty, _GaugeControl.Bounds.Size);
                }

                _Center = new PointF(_Bounds.X + _Bounds.Width / 2, _Bounds.Y + _Bounds.Height / 2);

                int m = AbsBevelInside + AbsBevelOutside;

                _BackBounds = _Bounds;
                _BackBounds.Inflate(-m, -m);

                if (_ClipOuterFrame == true)
                    OnSetFrameRegion();
                else
                    _GaugeControl.Region = null;

                _NeedRecalcLayout = false;
            }
        }

        #endregion

        #region OnPaint

        internal void OnPaint(PaintEventArgs e)
        {
            RecalcLayout();

            if (OnPreRenderFrame(e) == false)
            {
                if (_Image != null)
                {
                    e.Graphics.DrawImage(_Image, _Bounds);
                }
                else
                {
                    if (_Renderer != null)
                        _Renderer.RenderFrame(e);
                }
            }

            OnPostRenderFrame(e);
        }

        #region OnPreRenderFrame

        private bool OnPreRenderFrame(PaintEventArgs e)
        {
            if (PreRenderFrame != null)
            {
                PreRenderFrameEventArgs args =
                    new PreRenderFrameEventArgs(e.Graphics, _Bounds);

                PreRenderFrame(this, args);

                return (args.Cancel);
            }

            return (false);
        }

        #endregion

        #region OnPostRenderFrame

        private void OnPostRenderFrame(PaintEventArgs e)
        {
            if (PostRenderFrame != null)
            {
                PostRenderFrameEventArgs args =
                    new PostRenderFrameEventArgs(e.Graphics, _Bounds);

                PostRenderFrame(this, args);
            }
        }

        #endregion

        #endregion

        #region OnSetFrameRegion

        private void OnSetFrameRegion()
        {
            if (SetGaugeFrameRegion != null)
            {
                SetFrameRegionEventArgs args =
                    new SetFrameRegionEventArgs(_Bounds);

                SetGaugeFrameRegion(this, args);

                if (args.Cancel == true)
                    return;
            }

            if (_Renderer != null)
                _Renderer.SetFrameRegion();
            else
                _GaugeControl.Region = null;
        }

        #endregion

        #region PreRenderContent

        internal void PreRenderContent(PaintEventArgs e)
        {
            if (_Renderer != null)
                _Renderer.PreRenderContent(e);
        }

        #endregion

        #region PostRenderContent

        internal void PostRenderContent(PaintEventArgs e)
        {
            if (_Renderer != null)
                _Renderer.PostRenderContent(e);
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            if (_BackColor != null)
                _BackColor.ColorTableChanged -= BackColor_ColorTableChanged;

            if (_FrameColor != null)
                _FrameColor.ColorTableChanged -= FrameColor_ColorTableChanged;
        }

        #endregion
    }

    #region GaugeFrameConvertor

    public class GaugeFrameConvertor : ExpandableObjectConverter
    {
        public override object ConvertTo(
            ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string))
            {
                GaugeFrame gf = value as GaugeFrame;

                if (gf != null)
                {
                    switch (gf.Style)
                    {
                        case GaugeFrameStyle.Circular:
                            return ("Circular");

                        case GaugeFrameStyle.Rectangular:
                            return ("Rectangular");

                        case GaugeFrameStyle.RoundedRectangular:
                            return ("Rounded Rectangular");

                        default:
                            return ("None");
                    }
                }
            }

            return (base.ConvertTo(context, culture, value, destinationType));
        }
    }

    #endregion

    #region Enums

    public enum GaugeFrameStyle
    {
        None,

        Circular,
        Rectangular,
        RoundedRectangular,
    }

    #endregion

    #region EventArgs

    #region GetFrameRegionEventArgs

    /// <summary>
    /// SetFrameRegionEventArgs
    /// </summary>
    public class SetFrameRegionEventArgs : CancelEventArgs
    {
        #region Private variables

        private Region _Region;
        private Rectangle _Bounds;

        #endregion

        public SetFrameRegionEventArgs(Rectangle bounds)
        {
            _Bounds = bounds;
        }

        #region Public properties

        #region Bounds

        /// <summary>
        /// Gets the Region Bounds
        /// </summary>
        public Rectangle Bounds
        {
            get { return (_Bounds); }
        }

        #endregion

        #region Region

        /// <summary>
        /// Gets or sets the frame Region
        /// </summary>
        public Region Region
        {
            get { return (_Region); }
            set { _Region = value; }
        }

        #endregion

        #endregion
    }

    #endregion

    #region PostRenderFrameEventArgs

    /// <summary>
    /// PostRenderFrameEventArgs
    /// </summary>
    public class PostRenderFrameEventArgs : EventArgs
    {
        #region Private variables

        private Graphics _Graphics;
        private Rectangle _Bounds;

        #endregion

        public PostRenderFrameEventArgs(Graphics graphics, Rectangle bounds)
        {
            _Graphics = graphics;
            _Bounds = bounds;
        }

        #region Public properties

        #region Bounds

        /// <summary>
        /// Gets the Frame Bounds
        /// </summary>
        public Rectangle Bounds
        {
            get { return (_Bounds); }
        }

        #endregion

        #region Graphics

        /// <summary>
        /// Gets the Graphics object to use for the render
        /// </summary>
        public Graphics Graphics
        {
            get { return (_Graphics); }
        }

        #endregion

        #endregion
    }

    #endregion

    #region PreRenderFrameEventArgs

    public class PreRenderFrameEventArgs : CancelEventArgs
    {
        #region Private variables

        private Graphics _Graphics;
        private Rectangle _Bounds;

        #endregion

        public PreRenderFrameEventArgs(Graphics graphics, Rectangle bounds)
        {
            _Graphics = graphics;
            _Bounds = bounds;
        }

        #region Public properties

        public Graphics Graphics
        {
            get { return (_Graphics); }
        }

        public Rectangle Bounds
        {
            get { return (_Bounds); }
        }

        #endregion
    }

    #endregion

    #endregion
}