using System;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using DevComponents.DotNetBar.SuperGrid.Style;

namespace DevComponents.DotNetBar.SuperGrid
{
    /// <summary>
    /// Represents the base grid item.
    /// </summary>
    [DesignTimeVisible(false), ToolboxItem(false)]
    public abstract class GridElement : Component, INotifyPropertyChanged
    {
        #region Events

        /// <summary>
        /// Occurs when display/rendering of the item is invalidated.
        /// </summary>
        public event EventHandler RenderInvalid;

        /// <summary>
        /// Occurs when layout of the item is invalidated.
        /// </summary>
        public event EventHandler LayoutInvalid;

        /// <summary>
        /// Occurs when parent of the item has changed.
        /// </summary>
        public event EventHandler ParentChanged;

        #endregion

        #region Static variables

        static Point _mouseDownPoint;

        #endregion

        #region Private variables

        private Es _States;
        private Rectangle _BoundsRelative = Rectangle.Empty;

        private GridElement _Parent;
        private SuperGridControl _SuperGrid;
        private GridPanel _GridPanel;

        private object _Tag;

        #endregion

        #region Constructor

        /// <summary>
        /// GridElement
        /// </summary>
        protected GridElement()
        {
            SetState(Es.AllowSelection, true);
            SetState(Es.NeedsMeasured, true);
            SetState(Es.Visible, true);
        }

        #endregion

        #region Abstract methods

        /// <summary>
        /// Performs the arrange pass layout of the item when
        /// the final position and size of the item has been set.
        /// </summary>
        /// <param name="layoutInfo">Layout information.</param>
        /// <param name="stateInfo"></param>
        /// <param name="layoutBounds"></param>
        protected abstract void ArrangeOverride(
            GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Rectangle layoutBounds);

        /// <summary>
        /// Performs the layout of the item
        /// and sets the Size property to size that item will take.
        /// </summary>
        /// <param name="layoutInfo">Layout information.</param>
        /// <param name="stateInfo"></param>
        /// <param name="constraintSize"></param>
        protected abstract void MeasureOverride(
            GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Size constraintSize);

        /// <summary>
        /// Performs drawing of the item and its children.
        /// </summary>
        /// <param name="renderInfo">Holds contextual rendering information.</param>
        protected abstract void RenderOverride(GridRenderInfo renderInfo);

        #endregion

        #region Internal properties

        #region Capture

        internal virtual bool Capture
        {
            get { return (CapturedItem != null); }

            set
            {
                if (SuperGrid != null)
                    CapturedItem = (value == true) ? this : null;
            }
        }

        #endregion

        #region CapturedItem

        internal GridElement CapturedItem
        {
            get
            {
                if (SuperGrid != null)
                    return (SuperGrid.CapturedItem);

                return (null);
            }

            set
            {
                if (SuperGrid != null)
                    SuperGrid.CapturedItem = value;
            }
        }

        #endregion

        #region CViewRect

        /// <summary>
        /// Client View Rectangle
        /// </summary>
        internal Rectangle CViewRect
        {
            get
            {
                if (SuperGrid != null)
                    return (SuperGrid.CViewRect);

                return (Rectangle.Empty);
            }
        }

        #endregion

        #region HScrollBounds

        /// <summary>
        /// Horizontal Scroll Bounds
        /// </summary>
        internal Rectangle HScrollBounds
        {
            get
            {
                Rectangle r = BoundsRelative;
                r.X -= HScrollOffset;

                return (r);
            }
        }

        #endregion

        #region HScrollOffset

        internal int HScrollOffset
        {
            get
            {
                SuperGridControl sgc = SuperGrid;

                return (sgc != null)
                    ? sgc.HScrollOffset : 0;
            }
        }

        #endregion

        #region IsMouseDown

        /// <summary>
        /// Gets whether mouse is down
        /// </summary>
        internal virtual bool IsMouseDown
        {
            get { return (Control.MouseButtons != MouseButtons.None); }
        }

        #endregion

        #region IsVFrozen

        ///<summary>
        /// IsFrozen
        ///</summary>
        internal bool IsVFrozen
        {
            get
            {
                if (SuperGrid != null)
                {
                    GridPanel panel = SuperGrid.PrimaryGrid;

                    return (BoundsRelative.Y < panel.FixedRowHeight);
                }

                return (false);
            }
        }

        #endregion

        #region MouseDownPoint

        /// <summary>
        /// Gets the mouse down Point
        /// </summary>
        internal virtual Point MouseDownPoint
        {
            get { return (_mouseDownPoint); }
            set { _mouseDownPoint = value; }
        }

        #endregion

        #region NeedsMeasured

        /// <summary>
        /// Get or sets whether item needs measured
        /// </summary>
        internal virtual bool NeedsMeasured
        {
            get { return (TestState(Es.NeedsMeasured)); }
            set { SetState(Es.NeedsMeasured, value); }
        }

        #endregion

        #region ScrollBounds

        /// <summary>
        /// Horizontal and Vertical Scroll Bounds
        /// </summary>
        internal Rectangle ScrollBounds
        {
            get
            {
                Rectangle r = BoundsRelative;
                r.X -= HScrollOffset;
                r.Y -= VScrollOffset;

                return (r);
            }
        }

        #endregion

        #region SViewRect

        /// <summary>
        /// Scrollable View Rectangle
        /// </summary>
        internal Rectangle SViewRect
        {
            get
            {
                if (SuperGrid != null)
                    return (SuperGrid.SViewRect);

                return (Rectangle.Empty);
            }
        }

        #endregion

        #region ViewRect

        /// <summary>
        /// View Rectangle
        /// </summary>
        internal Rectangle ViewRect
        {
            get
            {
                if (SuperGrid != null)
                    return (SuperGrid.ViewRect);

                return (Rectangle.Empty);
            }
        }

        #endregion

        #region VScrollBounds

        /// <summary>
        /// Vertical Scroll Bounds
        /// </summary>
        internal Rectangle VScrollBounds
        {
            get
            {
                Rectangle r = BoundsRelative;
                r.Y -= VScrollOffset;

                return (r);
            }
        }

        #endregion

        #region VScrollOffset

        internal int VScrollOffset
        {
            get
            {
                SuperGridControl cgc = SuperGrid;

                return (cgc != null)
                    ? cgc.VScrollOffset : 0;
            }
        }

        #endregion

        #endregion

        #region Public properties

        #region AllowSelection

        /// <summary>
        /// Gets or sets whether the element can be selected
        /// </summary>
        [DefaultValue(true), Category("Behavior")]
        [Description("Indicates whether the element can be selected")]
        public virtual bool AllowSelection
        {
            get { return (TestState(Es.AllowSelection)); }

            set
            {
                if (AllowSelection != value)
                {
                    SetState(Es.AllowSelection, value);

                    OnPropertyChangedEx("AllowSelection", VisualChangeType.Render);
                }
            }
        }

        #endregion

        #region Bounds

        ///<summary>
        /// Gets the scroll adjusted bounds
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual Rectangle Bounds
        {
            get { return (BoundsRelative); }
        }

        #endregion

        #region BoundsRelative

        /// <summary>
        /// Gets or sets the relative bounds of the item.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual Rectangle BoundsRelative
        {
            get { return (_BoundsRelative); }
            internal set { _BoundsRelative = value; }
        }

        #endregion

        #region GridPanel

        /// <summary>
        /// Gets the parent GridPanel
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public GridPanel GridPanel
        {
            get { return (GetParentGridPanel()); }
            internal set { _GridPanel = value; }
        }

        #region GetParentGridPanel

        private GridPanel GetParentGridPanel()
        {
            if (_GridPanel != null)
                return (_GridPanel);

            GridElement parent = this;

            while (parent != null)
            {
                if (parent is GridPanel)
                    return ((GridPanel)parent);

                parent = parent.Parent;
            }

            return (null);
        }

        #endregion

        #endregion

        #region IsLayoutValid

        /// <summary>
        /// Gets whether layout for the item is valid.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual bool IsLayoutValid
        {
            get { return (TestState(Es.LayoutValid)); }
            internal set { SetState(Es.LayoutValid, value); }
        }

        #endregion

        #region IsMouseOver

        /// <summary>
        /// Gets whether mouse is over the element.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual bool IsMouseOver
        {
            get { return (TestState(Es.MouseOver)); }
            internal set { SetState(Es.MouseOver, value); }
        }

        #endregion

        #region LocationRelative

        /// <summary>
        /// Gets or sets the relative location of the item.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Point LocationRelative
        {
            get { return _BoundsRelative.Location; }
            internal set { _BoundsRelative.Location = value; }
        }

        #endregion

        #region Parent

        /// <summary>
        /// Gets or sets the parent of the item.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual GridElement Parent
        {
            get { return (_Parent); }

            internal set
            {
                if (_Parent != value)
                {
                    GridElement oldParent = value;
                    _Parent = value;

                    if (value == null)
                    {
                        if (SuperGrid != null)
                        {
                            if (SuperGrid.ActiveElement == this)
                                SuperGrid.ActiveElement = null;
                        }
                    }                        

                    OnParentChanged(oldParent, value);
                }
            }
        }

        #endregion

        #region Size

        /// <summary>
        /// Gets or sets the Size of the item.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Size Size
        {
            get { return (_BoundsRelative.Size); }
            internal set { _BoundsRelative.Size = value; }
        }

        #endregion

        #region SuperGrid

        /// <summary>
        /// Gets the parent super grid control.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public SuperGridControl SuperGrid
        {
            get { return GetParentSuperGrid(); }
            internal set { _SuperGrid = value; }
        }

        #region GetParentSuperGrid

        private SuperGridControl GetParentSuperGrid()
        {
            if (_SuperGrid != null)
                return (_SuperGrid);

            GridElement parent = _Parent;

            while (parent != null)
            {
                if (parent.SuperGrid != null)
                    return (_SuperGrid = parent.SuperGrid);

                parent = parent.Parent;
            }

            return (null);
        }

        #endregion

        #endregion

        #region Tag

        ///<summary>
        /// Gets or sets user-defined data associated with the object
        ///</summary>
        [DefaultValue(null)]
        [Description("User-defined data associated with the object")]
        [TypeConverter(typeof(StringConverter))]
        public object Tag
        {
            get { return (_Tag); }
            set { _Tag = value; }
        }

        #endregion

        #region Visible

        /// <summary>
        /// Get or sets whether the item is visible
        /// </summary>
        [DefaultValue(true), Category("Appearance")]
        [Description("Indicates whether item is visible")]
        public virtual bool Visible
        {
            get { return (TestState(Es.Visible)); }

            set
            {
                if (Visible != value)
                {
                    SetState(Es.Visible, value);

                    OnPropertyChangedEx("Visible", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #endregion

        #region TestState

        private bool TestState(Es state)
        {
            return ((_States & state) == state);
        }

        #endregion

        #region SetState

        private void SetState(Es state, bool value)
        {
            if (value == true)
                _States |= state;
            else
                _States &= ~state;
        }

        #endregion

        #region OnEvent processing

        #region OnLayoutInvalid

        /// <summary>
        /// Raises LayoutInvalid event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnLayoutInvalid(EventArgs e)
        {
            EventHandler handler = LayoutInvalid;

            if (handler != null)
                handler(this, e);
        }

        #endregion

        #region OnParentChanged

        /// <summary>
        /// Called after parent of the item has changed.
        /// </summary>
        /// <param name="oldParent">Reference to old parent.</param>
        /// <param name="newParent">Reference to new parent.</param>
        protected virtual void OnParentChanged(GridElement oldParent, GridElement newParent)
        {
            OnParentChanged(EventArgs.Empty);
        }

        /// <summary>
        /// Raises ParentChanged event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnParentChanged(EventArgs e)
        {
            EventHandler handler = ParentChanged;

            if (handler != null)
                handler(this, e);
        }

        #endregion

        #region OnRenderInvalid

        /// <summary>
        /// Raises RenderInvalid event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnRenderInvalid(EventArgs e)
        {
            EventHandler handler = RenderInvalid;

            if (handler != null)
                handler(this, e);
        }

        #endregion

        #endregion

        #region Measure

        /// <summary>
        /// This method is used by the items internally to invoke the measure pass to
        /// get item size. Override MeasureOverride method to perform actual measuring.
        /// </summary>
        /// <param name="layoutInfo">Holds contextual layout information.</param>
        /// <param name="stateInfo"></param>
        /// <param name="constraintSize"></param>
        internal void Measure(
            GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Size constraintSize)
        {
            MeasureOverride(layoutInfo, stateInfo, constraintSize);

            NeedsMeasured = false;
        }

        #endregion

        #region Arrange

        /// <summary>
        /// This method is used by the items internally to invoke the arrange pass after
        /// location and size of the item has been set. Override ArrangeOverride method
        /// to perform internal arranging.
        /// </summary>
        /// <param name="layoutInfo"></param>
        /// <param name="stateInfo"></param>
        /// <param name="layoutBounds"></param>
        internal void Arrange(
            GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Rectangle layoutBounds)
        {
            IsLayoutValid = true;

            _BoundsRelative = layoutBounds;

            ArrangeOverride(layoutInfo, stateInfo, layoutBounds);
        }

        #endregion

        #region Render

        /// <summary>
        /// This method is used by the items internally to invoke the rendering
        /// for the item. Override RenderOverride method to perform actual rendering.
        /// </summary>
        /// <param name="renderInfo">Holds contextual rendering information.</param>
        internal void Render(GridRenderInfo renderInfo)
        {
            RenderOverride(renderInfo);
        }

        #endregion

        #region InvalidateLayout

        /// <summary>
        /// Invalidates the layout for the item.
        /// </summary>
        public virtual void InvalidateLayout()
        {
            IsLayoutValid = false;

            if (_Parent != null)
            {
                _Parent.InvalidateLayout();
            }
            else
            {
                if (SuperGrid != null)
                    SuperGrid.Invalidate();
            }

            OnLayoutInvalid(EventArgs.Empty);
        }

        #endregion

        #region InvalidateRender

        /// <summary>
        /// Invalidates the display state of the item
        /// </summary>
        public virtual void InvalidateRender()
        {
            SuperGridControl grid = SuperGrid;

            if (grid != null)
            {
                if (grid.InvokeRequired)
                    grid.BeginInvoke(new MethodInvoker(delegate { grid.InvalidateRender(this); }));
                else
                    grid.InvalidateRender(this);
            }
            
            OnRenderInvalid(EventArgs.Empty);
        }

        /// <summary>
        /// Invalidates the display state of the item
        /// </summary>
        public virtual void InvalidateRender(Rectangle bounds)
        {
            SuperGridControl grid = SuperGrid;

            if (grid != null)
                grid.InvalidateRender(bounds);

            OnRenderInvalid(EventArgs.Empty);
        }

        #endregion

        #region Mouse Handling

        #region OnMouseEnter

        /// <summary>
        /// Called by top-level control to pass message into the grid
        /// element. To handle it override corresponding On - virtual method.
        /// </summary>
        /// <param name="e"></param>
        internal virtual void InternalMouseEnter(EventArgs e)
        {
            IsMouseOver = true;

            OnMouseEnter(e);
        }

        /// <summary>
        /// Called when mouse enter the element.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnMouseEnter(EventArgs e)
        {
        }

        #endregion

        #region OnMouseLeave

        /// <summary>
        /// Called by top-level control to pass message into the grid
        /// element. To handle it override corresponding On - virtual method.
        /// </summary>
        /// <param name="e"></param>
        internal virtual void InternalMouseLeave(EventArgs e)
        {
            IsMouseOver = false;

            OnMouseLeave(e);
        }

        /// <summary>
        /// Called when mouse leaves the element.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnMouseLeave(EventArgs e)
        {
        }

        #endregion

        #region OnMouseHover

        /// <summary>
        /// Called by top-level control to pass message into the grid
        /// element. To handle it override corresponding On - virtual method.
        /// </summary>
        /// <param name="e"></param>
        internal virtual void InternalMouseHover(EventArgs e)
        {
            OnMouseHover(e);
        }

        /// <summary>
        /// Called when mouse hovers over the element.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnMouseHover(EventArgs e)
        {
        }

        #endregion

        #region OnMouseDown

        /// <summary>
        /// Called by top-level control to pass message into the grid
        /// element. To handle it override corresponding On - virtual method.
        /// </summary>
        /// <param name="e"></param>
        internal virtual void InternalMouseDown(MouseEventArgs e)
        {
            MouseDownPoint = e.Location;

            OnMouseDown(e);
        }

        /// <summary>
        /// Called when mouse button is pressed over the element.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnMouseDown(MouseEventArgs e)
        {
        }

        #endregion

        #region OnMouseUp

        /// <summary>
        /// Called by top-level control to pass message into the grid
        /// element. To handle it override corresponding On - virtual method.
        /// </summary>
        /// <param name="e"></param>
        internal virtual void InternalMouseUp(MouseEventArgs e)
        {
            Capture = false;

            OnMouseUp(e);
        }

        /// <summary>
        /// Called when mouse button is released over the element.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnMouseUp(MouseEventArgs e)
        {
        }

        #endregion

        #region OnMouseMove

        /// <summary>
        /// Called by top-level control to pass message into the grid
        /// element. To handle it override corresponding On - virtual method.
        /// </summary>
        /// <param name="e"></param>
        internal virtual void InternalMouseMove(MouseEventArgs e)
        {
            OnMouseMove(e);
        }

        /// <summary>
        /// Called when mouse is moved over the element.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnMouseMove(MouseEventArgs e)
        {
        }

        #endregion

        #region OnMouseClick

        /// <summary>
        /// Called by top-level control to pass message into the grid
        /// element. To handle it override corresponding On - virtual method.
        /// </summary>
        /// <param name="e"></param>
        internal virtual void InternalMouseClick(MouseEventArgs e)
        {
            OnMouseClick(e);
        }
        /// <summary>
        /// Called when mouse is clicked on the element.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnMouseClick(MouseEventArgs e)
        {
        }

        #endregion

        #region OnMouseDoubleClick

        /// <summary>
        /// Called by top-level control to pass message into the grid
        /// element. To handle it override corresponding On - virtual method.
        /// </summary>
        /// <param name="e"></param>
        internal virtual void InternalMouseDoubleClick(MouseEventArgs e)
        {
            OnMouseDoubleClick(e);
        }

        /// <summary>
        /// Called when mouse is double clicked on the element.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnMouseDoubleClick(MouseEventArgs e)
        {
        }

        #endregion

        #region PostInternalMouseMove

        internal void PostInternalMouseMove()
        {
            SuperGrid.PostInternalMouseMove();
        }

        #endregion

        #endregion

        #region Keyboard handling

        /// <summary>
        /// Called by top-level control to pass message into the grid
        /// element. To handle it override corresponding On - virtual method.
        /// </summary>
        /// <param name="keyData"></param>
        internal virtual void InternalKeyDown(Keys keyData)
        {
            OnKeyDown(keyData);
        }

        /// <summary>
        /// Called when mouse button is pressed over the element.
        /// </summary>
        /// <param name="keyData"></param>
        protected virtual void OnKeyDown(Keys keyData)
        {
        }

        #endregion

        #region EnsureVisible

        ///<summary>
        /// EnsureVisible
        ///</summary>
        public void EnsureVisible()
        {
            EnsureVisible(false);
        }

        ///<summary>
        /// EnsureVisible
        ///</summary>
        ///<param name="center"></param>
        public virtual void EnsureVisible(bool center)
        {
        }

        #endregion

        #region CancelCapture

        ///<summary>
        /// Cancels any inprogress operations that may
        /// have the mouse captured (resize, reorder).
        ///</summary>
        public virtual void CancelCapture()
        {
            if (CapturedItem == this)
                Capture = false;
        }

        #endregion

        #region IsDesignerHosted

        internal bool IsDesignerHosted
        {
            get
            {
                if (SuperGrid != null)
                    return (SuperGrid.IsDesignerHosted);

                return (false);
            }
        }

        #endregion

        #region INotifyPropertyChanged Members

        /// <summary>
        /// Occurs when property value has changed.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Raises the PropertyChanged event.
        /// </summary>
        /// <param name="e">Event arguments</param>
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            PropertyChangedEventHandler eh = PropertyChanged;

            if (eh != null)
                eh(this, e);
        }

        /// <summary>
        /// Default PropertyChanged processing
        /// </summary>
        /// <param name="s"></param>
        protected void OnPropertyChanged(string s)
        {
            if (PropertyChanged != null)
                OnPropertyChanged(new PropertyChangedEventArgs(s));
        }

        /// <summary>
        /// Default PropertyChanged processing
        /// </summary>
        /// <param name="s"></param>
        /// <param name="changeType">invalidate</param>
        protected void OnPropertyChangedEx(string s, VisualChangeType changeType)
        {
            OnPropertyChanged(s);

            if (changeType == VisualChangeType.Layout)
                InvalidateLayout();
            else
                InvalidateRender();
        }

        #endregion

        #region ElementStates

        [Flags]
        private enum Es
        {
            AllowSelection = (1 << 0),
            LayoutValid = (1 << 1),
            MouseOver = (1 << 2),
            NeedsMeasured = (1 << 3),
            Visible = (1 << 4),
        }

        #endregion

    }
}