using System;
using System.Text;
using System.Windows.Forms;
using System.Drawing;

namespace DevComponents.DotNetBar.ScrollBar
{
    public class ScrollBarCore : IDisposable
    {
        #region Private Variables
        private Rectangle m_DisplayRectangle = Rectangle.Empty;
        private eOrientation m_Orientation = eOrientation.Vertical;

        // Default thumb sizes...
        private Size m_VThumbSize = new Size(Dpi.Width15, Dpi.Height17);
        private Size m_HThumbSize = new Size(Dpi.Width17, Dpi.Height15);
        private Rectangle m_ThumbDecrease = Rectangle.Empty;
        private Rectangle m_ThumbIncrease = Rectangle.Empty;
        private Rectangle m_Track = Rectangle.Empty;
        private eScrollPart m_MouseOverPart = eScrollPart.None;

        private Control m_ParentControl = null;
        private bool m_MouseDown = false;
        private Timer m_ClickTimer = null;
        private int m_MouseDownTrackOffset = 0;
        private Bitmap m_CashedView = null;
        private bool m_ViewExpired = true;
        private bool m_PassiveScrollBar = false;
        private bool m_IsAppScrollBarStyle = false;
        public event EventHandler ValueChanged;
        private bool m_IsScrollBarParent = false;
        private bool m_IsAdvScrollBar = false;
        private int m_AutoClickCount = 0;
        public event ScrollEventHandler Scroll;
        #endregion

        #region Internal Implementation
        public ScrollBarCore() : this(null) { }

        public ScrollBarCore(Control parentControl) : this(parentControl, false) { }

        public ScrollBarCore(Control parentControl, bool isPassive)
        {
            m_ParentControl = parentControl;
            m_IsScrollBarParent = m_ParentControl is System.Windows.Forms.ScrollBar || m_ParentControl is ScrollBarAdv;
            m_IsAdvScrollBar = m_ParentControl is ScrollBarAdv;
            m_PassiveScrollBar = isPassive;
            DisposeCashedView();
        }

        internal void DisposeCashedView()
        {
            if (m_CashedView != null)
            {
                m_CashedView.Dispose();
                m_CashedView = null;
            }
        }

        private ScrollBarPainter GetScrollBarPainter()
        {
            ScrollBarPainter scp = null;
            if (StyleManager.IsMetro(StyleManager.Style))
            {
                DevComponents.DotNetBar.Metro.Rendering.MetroScrollBarPainter painter = new DevComponents.DotNetBar.Metro.Rendering.MetroScrollBarPainter();
                painter.ColorTable = ((Rendering.Office2007Renderer)Rendering.GlobalManager.Renderer).ColorTable;
                painter.AppStyleScrollBar = m_IsAppScrollBarStyle;
                scp = painter;
            }
            else
            {
                Office2007ScrollBarPainter painter = new Office2007ScrollBarPainter();
                painter.ColorTable = ((Rendering.Office2007Renderer)Rendering.GlobalManager.Renderer).ColorTable;
                painter.AppStyleScrollBar = m_IsAppScrollBarStyle;
                scp = painter;
            }
            return scp;
        }

        private bool _IsPainting = false;
        public void Paint(ItemPaintArgs p)
        {
            if (_IsPainting) return;

            _IsPainting = true;
            try
            {
                if (m_DisplayRectangle.IsEmpty || m_DisplayRectangle.Width <= 0 || m_DisplayRectangle.Height <= 0 || p.Graphics == null) return;

                ScrollBarPainter painter = GetScrollBarPainter();

                if (m_CashedView == null)
                {
                    try
                    {
                        m_CashedView = new Bitmap(m_DisplayRectangle.Width, m_DisplayRectangle.Height, p.Graphics);
                    }
                    catch
                    {
                        return;
                    }
                    m_CashedView.MakeTransparent();
                    m_ViewExpired = true;
                }

                if (!m_ViewExpired)
                {
                    Bitmap cachedView = m_CashedView;
                    if (cachedView != null)
                        p.Graphics.DrawImageUnscaled(cachedView, m_DisplayRectangle.Location);
                    return;
                }

                using (Graphics g = Graphics.FromImage(m_CashedView))
                {
                    if (!m_DisplayRectangle.Location.IsEmpty)
                        g.TranslateTransform(-m_DisplayRectangle.X, -m_DisplayRectangle.Y);
                    eScrollBarState state = m_Enabled ? eScrollBarState.Normal : eScrollBarState.Disabled;
                    if (m_Enabled && (m_MouseOverPart != eScrollPart.None || IsFocused)) state = eScrollBarState.ControlMouseOver;
                    bool rtl = false;
                    if (m_ParentControl != null) rtl = m_ParentControl.RightToLeft == RightToLeft.Yes;
                    painter.PaintBackground(g, m_DisplayRectangle, state, m_Orientation == eOrientation.Horizontal, m_SideBorderOnly, rtl);

                    eScrollThumbPosition tp = eScrollThumbPosition.Top;
                    if (m_Orientation == eOrientation.Horizontal) tp = eScrollThumbPosition.Left;
                    if (m_MouseOverPart == eScrollPart.ThumbDecrease && m_Enabled)
                    {
                        if (m_MouseDown)
                            state = eScrollBarState.Pressed;
                        else
                            state = eScrollBarState.PartMouseOver;
                    }
                    painter.PaintThumb(g, m_ThumbDecrease, tp, state);

                    tp = eScrollThumbPosition.Bottom;
                    if (m_MouseOverPart == eScrollPart.ThumbIncrease && m_Enabled)
                    {
                        if (m_MouseDown)
                            state = eScrollBarState.Pressed;
                        else
                            state = eScrollBarState.PartMouseOver;
                    }
                    else if (m_MouseOverPart != eScrollPart.None && m_Enabled)
                        state = eScrollBarState.ControlMouseOver;

                    if (m_Orientation == eOrientation.Horizontal) tp = eScrollThumbPosition.Right;
                    painter.PaintThumb(g, m_ThumbIncrease, tp, state);

                    if (m_MouseOverPart == eScrollPart.Track && m_Enabled)
                    {
                        if (m_MouseDown)
                            state = eScrollBarState.Pressed;
                        else
                            state = eScrollBarState.PartMouseOver;
                    }
                    else if ((m_MouseOverPart != eScrollPart.None || this.IsFocused) && m_Enabled)
                        state = eScrollBarState.ControlMouseOver;
                    if (m_Orientation == eOrientation.Horizontal)
                        painter.PaintTrackHorizontal(g, m_Track, state);
                    else
                        painter.PaintTrackVertical(g, m_Track, state);
                }

                p.Graphics.DrawImageUnscaled(m_CashedView, m_DisplayRectangle.Location);
                m_ViewExpired = false;
            }
            finally
            {
                _IsPainting = false;
            }
        }

        private bool IsFocused
        {
            get
            {
                if (m_IsAdvScrollBar && m_ParentControl.Focused)
                    return true;

                return false;
            }
        }

        public void MouseMove(MouseEventArgs e)
        {
            if (!m_Enabled)
                return;

            Point p = new Point(e.X, e.Y);
            if (m_MouseDown && m_MouseOverPart == eScrollPart.Track)
            {
                if (!m_PassiveScrollBar)
                {
                    // Update Track position based on mouse position...
                    int i = ValueFromMouseCoordinates(p);
                    SetValue(i, ScrollEventType.ThumbTrack);
                    //this.Value = i;
                }
                return;
            }

            if (e.Button != MouseButtons.None && m_MouseOverPart!=eScrollPart.None) return;

            if (m_DisplayRectangle.Contains(p))
            {
                eScrollPart part = eScrollPart.Control;
                if (m_ThumbDecrease.Contains(p))
                    part = eScrollPart.ThumbDecrease;
                else if (m_ThumbIncrease.Contains(p))
                    part = eScrollPart.ThumbIncrease;
                else if (m_Track.Contains(p))
                    part = eScrollPart.Track;

                if (m_MouseOverPart != part)
                {
                    m_MouseOverPart = part;
                    this.Invalidate();
                }
            }
            else if (m_MouseOverPart != eScrollPart.None)
            {
                m_MouseOverPart = eScrollPart.None;
                this.Invalidate();
            }
        }

        private int ValueFromMouseCoordinates(Point p)
        {
            if (m_Orientation == eOrientation.Vertical)
            {
                int trackY = p.Y - m_MouseDownTrackOffset;
                trackY = Math.Max(trackY, m_ThumbDecrease.Bottom);
                trackY = Math.Min(trackY, m_ThumbIncrease.Y - GetTrackSize());
                trackY -= m_ThumbDecrease.Bottom;

                int totalSize = GetAvailableTrackArea() - GetTrackSize();
                return (int)((this.GetMaximumValue() - this.Minimum) * ((float)trackY / (float)totalSize));
            }
            else
            {
                int trackX = p.X - m_MouseDownTrackOffset;
                trackX = Math.Max(trackX, m_ThumbDecrease.Right);
                trackX = Math.Min(trackX, m_ThumbIncrease.X - GetTrackSize());
                trackX -= m_ThumbDecrease.Right;

                int totalSize = GetAvailableTrackArea() - GetTrackSize();
                return (int)((this.GetMaximumValue() - this.Minimum) * ((float)trackX / (float)totalSize));
            }
        }

        public void MouseLeave()
        {
            if (m_MouseOverPart != eScrollPart.None)
            {
                if (m_MouseDown && (m_MouseOverPart == eScrollPart.Track || m_MouseOverPart != eScrollPart.None && m_PassiveScrollBar))
                    return;
                m_MouseOverPart = eScrollPart.None;
                this.Invalidate();
            }
        }

        public void MouseDown(MouseEventArgs e)
        {
            if (m_MouseOverPart != eScrollPart.None)
            {
                m_MouseDown = true;
                if (m_PassiveScrollBar)
                {
                    m_ViewExpired = true;
                    return;
                }

                if(m_Orientation == eOrientation.Vertical)
                    m_MouseDownTrackOffset = e.Y - m_Track.Y;
                else
                    m_MouseDownTrackOffset = e.X - m_Track.X;

                if (m_MouseOverPart == eScrollPart.ThumbDecrease)
                    SetValue(this.Value - m_SmallChange, ScrollEventType.SmallDecrement);
                else if (m_MouseOverPart == eScrollPart.ThumbIncrease)
                    SetValue(this.Value + m_SmallChange, ScrollEventType.SmallIncrement);
                else if (m_MouseOverPart == eScrollPart.Track)
                {
                    this.Invalidate();
                    if (m_ParentControl != null)
                        m_ParentControl.Capture = true;
                }
                else if (m_MouseOverPart == eScrollPart.Control)
                {
                    MousePageDown(new Point(e.X, e.Y));
                }

                SetupClickTimer();
            }
        }

        private void MousePageDown(Point p)
        {
            if (m_Orientation == eOrientation.Vertical && (p.Y<m_Track.Y || p.Y>m_Track.Bottom) || 
                m_Orientation == eOrientation.Horizontal && (p.X<m_Track.X || p.X>m_Track.Right))
            {
                if (m_Orientation == eOrientation.Vertical && m_Track.Y > p.Y || m_Orientation == eOrientation.Horizontal && m_Track.X > p.X)
                    SetValue(this.Value - this.LargeChange, ScrollEventType.LargeDecrement);
                else
                {
                    if (m_IsScrollBarParent)
                    {
                        if (this.Value + this.LargeChange > this.GetMaximumValue())
                        {
                            SetValue(this.GetMaximumValue(), ScrollEventType.LargeIncrement);
                        }
                        else
                            SetValue(this.Value + this.LargeChange, ScrollEventType.LargeIncrement);
                    }
                    else
                        SetValue(this.Value + this.LargeChange, ScrollEventType.LargeIncrement);
                }
            }
        }

        public bool IsMouseDown
        {
            get { return m_MouseDown; }
        }

        public void MouseUp(MouseEventArgs e)
        {
            if (m_ParentControl != null && m_ParentControl.Capture)
                m_ParentControl.Capture = false;

            if(m_MouseDown)
            {
                if (m_MouseOverPart != eScrollPart.None && _RaiseEndScroll)
                {
#if FRAMEWORK20
                    if(m_MouseOverPart == eScrollPart.Track)
                        OnScroll(new ScrollEventArgs(ScrollEventType.ThumbPosition, this.Value, this.Value, this.ScrollOrientation));
                    OnScroll(new ScrollEventArgs(ScrollEventType.EndScroll, this.Value, this.Value, this.ScrollOrientation));
#else
					if(m_MouseOverPart == eScrollPart.Track)
						OnScroll(new ScrollEventArgs(ScrollEventType.ThumbPosition, this.Value));
					OnScroll(new ScrollEventArgs(ScrollEventType.EndScroll, this.Value));
#endif
                    _RaiseEndScroll = false;
                }
                DisposeTimer();
                m_MouseDown = false;
                this.Invalidate();
            }

            if (!this.DisplayRectangle.Contains(e.X, e.Y))
                MouseLeave();
        }

        private ScrollOrientation ScrollOrientation
        {
            get
            {
                return this.Orientation == eOrientation.Horizontal ? ScrollOrientation.HorizontalScroll : ScrollOrientation.VerticalScroll;
            }
        }

        private void DisposeTimer()
        {
            Timer clickTimer = m_ClickTimer;
            m_ClickTimer = null;
            if (clickTimer != null)
            {
                clickTimer.Enabled = false;
                clickTimer.Tick -= new EventHandler(ClickTimer_Tick);
                clickTimer.Dispose();
            }
        }

        private void SetupClickTimer()
        {
            if (m_ClickTimer != null) return;
            m_AutoClickCount = 0;
            m_ClickTimer = new Timer();
            m_ClickTimer.Interval = 100;
            m_ClickTimer.Tick += new EventHandler(ClickTimer_Tick);
            m_ClickTimer.Enabled = true;
        }

        private void ClickTimer_Tick(object sender, EventArgs e)
        {
            Control parentControl = m_ParentControl;
            if (m_MouseDown && m_MouseOverPart == eScrollPart.ThumbDecrease)
            {
                SetValue(this.Value - m_SmallChange, ScrollEventType.SmallDecrement);
            }
            else if (m_MouseDown && m_MouseOverPart == eScrollPart.ThumbIncrease)
            {
                SetValue(this.Value + m_SmallChange, ScrollEventType.SmallIncrement);
            }
            else if (m_MouseDown && m_MouseOverPart == eScrollPart.Control && parentControl != null)
            {
                Point p = parentControl.PointToClient(Control.MousePosition);
                if (m_Track.Contains(p))
                {
                    DisposeTimer();
                    m_MouseDown = false;
                }
                else
                    MousePageDown(p);
            }
            m_AutoClickCount++;
            if (m_AutoClickCount > 4 && m_ClickTimer != null && m_ClickTimer.Interval > 20)
            {
                m_ClickTimer.Interval -= 10;
            }
        }

        private void Invalidate()
        {
            m_ViewExpired = true;
            Control parentControl = m_ParentControl;
            if (parentControl != null && !m_PassiveScrollBar)
            {
                parentControl.Invalidate(m_DisplayRectangle);
                parentControl.Update();
            }
        }

        private bool m_HasBorder = true;
        internal bool HasBorder
        {
            get { return m_HasBorder; }
            set { m_HasBorder = value; }
        }

        private bool m_SideBorderOnly = false;
        internal bool SideBorderOnly
        {
            get { return m_SideBorderOnly; }
            set { m_SideBorderOnly = value; }
        }

        private void UpdateLayout()
        {
            if (m_PassiveScrollBar)
                return;

            Rectangle r = m_DisplayRectangle;
            if(m_HasBorder)
                r.Inflate(-1, -1);

            if (m_Orientation == eOrientation.Vertical)
            {
                m_ThumbDecrease = new Rectangle(r.X, r.Y, r.Width, m_VThumbSize.Height);
                m_ThumbIncrease = new Rectangle(r.X, r.Bottom - m_VThumbSize.Height, r.Width, m_VThumbSize.Height);
                int i = GetTrackSize();
                m_Track = new Rectangle(r.X, r.Y + GetTrackPosition(), r.Width, i);
            }
            else
            {
                m_ThumbDecrease = new Rectangle(r.X, r.Y, m_HThumbSize.Width, r.Height);
                m_ThumbIncrease = new Rectangle(r.Right - m_HThumbSize.Width, r.Y, m_HThumbSize.Width, r.Height);
                int i = GetTrackSize();
                m_Track = new Rectangle(r.X + GetTrackPosition(), r.Y, i, r.Height);

            }
            if(!(m_ParentControl is System.Windows.Forms.ScrollBar))
                this.Invalidate();
        }

        public virtual void ScaleItem(SizeF factor)
        {
            m_VThumbSize = new Size(Dpi.Width15, Dpi.Height17);
            m_HThumbSize = new Size(Dpi.Width17, Dpi.Height15);
        }

        private int GetTrackSize()
        {
            int i = 0;
            int size = GetAvailableTrackArea();
            //Rectangle r = m_DisplayRectangle;
            //r.Inflate(-1, -1);

            i = (int)(size * ((float)m_LargeChange / (float)(m_Maximum - m_Minimum + 1)));
            //i = (int)(size / ((float)m_Maximum / (float)m_LargeChange));
            //if (m_Orientation == eOrientation.Horizontal)
            //{
            //    i = (int)(r.Width * ((float)m_LargeChange / (float)m_Maximum));
            //}
            //else
            //{
            //    i = (int)(r.Height * ((float)m_LargeChange / (float)m_Maximum));
            //}
            i = Math.Max(14, i);
            i = Math.Min(i, size);

            return i;
        }

        private int GetAvailableTrackArea()
        {
            Rectangle r = m_DisplayRectangle;
            if(m_HasBorder)
                r.Inflate(-1, -1);

            int size = r.Height;

            if (m_Orientation == eOrientation.Horizontal)
            {
                size = r.Width - m_HThumbSize.Width * 2;
            }
            else
            {
                size -= m_VThumbSize.Height * 2;
            }

            return Math.Max(size, 8);
        }

        private int GetTrackPosition()
        {
            int trackSize = GetTrackSize();
            int totalSize = GetAvailableTrackArea() - trackSize;
            int i = Math.Min(totalSize, Math.Max((int)(totalSize * ((float)m_Value / (float)GetMaximumValue())), 0));
            if (m_Orientation == eOrientation.Vertical)
                i += m_VThumbSize.Height;
            else
                i += m_HThumbSize.Width;
            return i;
        }

        public Rectangle ThumbDecreaseRectangle
        {
            get { return m_ThumbDecrease; }
            set
            {
                m_ThumbDecrease = value;
                DisposeCashedView();
            }
        }

        public Rectangle ThumbIncreaseRectangle
        {
            get { return m_ThumbIncrease; }
            set
            {
                m_ThumbIncrease = value;
                DisposeCashedView();
            }
        }

        public Rectangle TrackRectangle
        {
            get { return m_Track; }
            set
            {
                m_Track = value;
                DisposeCashedView();
            }
        }

        public Rectangle DisplayRectangle
        {
            get { return m_DisplayRectangle; }
            set
            {
                m_DisplayRectangle = value;
                DisposeCashedView();
                UpdateLayout();
            }
        }

        public eOrientation Orientation
        {
            get { return m_Orientation; }
            set
            { 
                m_Orientation = value;
                DisposeCashedView();
            }
        }

        private int m_Minimum = 0;
        public int Minimum
        {
            get { return m_Minimum; }
            set 
            {
                m_Minimum = value;
                DisposeCashedView();
                UpdateLayout();
            }
        }

        private int m_Maximum = 0;
        public int Maximum
        {
            get { return m_Maximum; }
            set
            {
                m_Maximum = value;
                DisposeCashedView();
                UpdateLayout();
            }
        }

        private int m_SmallChange = 1;
        public int SmallChange
        {
            get { return m_SmallChange; }
            set { m_SmallChange = value; }
        }

        private int m_LargeChange = 16;
        public int LargeChange
        {
            get { return m_LargeChange; }
            set
            {
                m_LargeChange = value;
                DisposeCashedView();
                UpdateLayout();
            }
        }

        private int m_Value = 0;
        public int Value
        {
            get { return m_Value; }
            set
            {
                value = NormalizeValue(value);
                if (m_Value == value && (!m_IsScrollBarParent || m_IsAdvScrollBar)) return;

                m_Value = value;
                if (m_PassiveScrollBar) return;
                DisposeCashedView();
                UpdateLayout();
                if (ValueChanged != null)
                    ValueChanged(this, new EventArgs());
                this.Invalidate();
            }
        }

        private bool _RaiseEndScroll = false;
        private void SetValue(int value, ScrollEventType type)
        {
            value = NormalizeValue(value);
#if FRAMEWORK20
            OnScroll(new ScrollEventArgs(type, m_Value, value, this.ScrollOrientation));
#else
			OnScroll(new ScrollEventArgs(type, value));
#endif
            Value = value;
            _RaiseEndScroll = true;
        }

        private int NormalizeValue(int value)
        {
            int max = m_IsAdvScrollBar ? GetMaximumValue() : m_Maximum;
            if (value < m_Minimum) value = m_Minimum;
            if (value > max) value = max;
            return value;
        }

        private void OnScroll(ScrollEventArgs e)
        {
            ScrollEventHandler h = this.Scroll;
            if (h != null)
                h(this, e);
        }

        internal int GetMaximumValue()
        {
            if (m_IsScrollBarParent)
            {
                return m_Maximum - m_LargeChange + 1;
            }
            else
                return m_Maximum;
        }
        
        internal eScrollPart MouseOverPart
        {
            get
            {
                return m_MouseOverPart;
            }
            set
            {
                m_MouseOverPart = value;
            }
        }

        private bool m_Visible = true;
        public bool Visible
        {
            get { return m_Visible; }
            set { m_Visible = value; }
        }

        public Control ParentControl
        {
            get { return m_ParentControl; }
            set 
            { 
                m_ParentControl = value;
                if (m_ParentControl == null) DisposeTimer();
            }
        }

        private bool m_Enabled = true;
        public bool Enabled
        {
            get { return m_Enabled; }
            set
            {
                if (m_Enabled != value)
                {
                    m_Enabled = value;
                    this.Invalidate();
                }
            }
        }

        public bool IsAppScrollBarStyle
        {
            get { return m_IsAppScrollBarStyle; }
            set { m_IsAppScrollBarStyle = value; DisposeCashedView(); }
        }

        internal enum eScrollPart
        {
            ThumbIncrease,
            ThumbDecrease,
            Track,
            Control,
            None
        }

        internal bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            if (keyData == Keys.PageDown)
            {
                SetValue(this.Value + m_LargeChange, ScrollEventType.LargeIncrement);
                return true;
            }
            else if (keyData == Keys.PageUp)
            {
                SetValue(this.Value - m_LargeChange, ScrollEventType.LargeIncrement);
                return true;
            }
            else if (keyData == Keys.Up || keyData == Keys.Left)
            {
                SetValue(this.Value - m_SmallChange, ScrollEventType.SmallDecrement);
                return true;
            }
            else if (keyData == Keys.Down || keyData == Keys.Right)
            {
                SetValue(this.Value + m_SmallChange, ScrollEventType.SmallIncrement);
                return true;
            }
            else if (keyData == Keys.Home)
            {
                SetValue(m_Minimum, ScrollEventType.First);
                return true;
            }
            else if (keyData == Keys.End)
            {
                SetValue(m_Maximum, ScrollEventType.Last);
                return true;
            }


            return false;
        }
        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            DisposeTimer();
            DisposeCashedView();
            m_ParentControl = null;
        }

        #endregion

        internal void InvalidateScrollBar()
        {
            DisposeCashedView();
            Control parentControl = m_ParentControl;
            if (parentControl != null)
                parentControl.Invalidate();
        }
    }

#if !FRAMEWORK20
	public enum ScrollOrientation
	{
		HorizontalScroll,
		VerticalScroll
	}
#endif
}