// *********************************
// Message from Original Author:
//
// 2008 Jose Menendez Poo
// Please give me credit if you use this code. It's all I ask.
// Contact me for more info: menendezpoo@gmail.com
// *********************************
//
// Original project from http://ribbon.codeplex.com/
// Continue to support and maintain by http://officeribbon.codeplex.com/

using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;

namespace System.Windows.Forms
{
    [Designer(typeof(RibbonComboBoxDesigner))]
    public class RibbonComboBox
        : RibbonTextBox, IContainsRibbonComponents, IDropDownRibbonItem
    {
        #region Fields
        // Steve
        private RibbonItem _selectedItem;
        private readonly Set<RibbonItem> _assignedHandlers = new Set<RibbonItem>();
        #endregion

        #region Events

        /// <summary>
        /// Raised when the DropDown is about to be displayed
        /// </summary>
        public event EventHandler DropDownShowing;

        public event RibbonItemEventHandler DropDownItemClicked;
        public delegate void RibbonItemEventHandler(object sender, RibbonItemEventArgs e);

        #endregion

        #region Ctor

        public RibbonComboBox()
        {
            DropDownItems = new RibbonItemCollection();
            DropDownItems.SetOwnerItem(this);
            DropDownVisible = false;
            AllowTextEdit = true;
            DrawIconsBar = true;
            DropDownMaxHeight = 0;
            _disableTextboxCursor = true;
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                RemoveHandlers();
            }
            base.Dispose(disposing);
        }

        #endregion

        #region Properties

        /// <summary>
        /// Gets or sets the maximum height for the dropdown window.  0 = autosize.  If the size is smaller than the contents then scrollbars will be shown.
        /// </summary>
        [DefaultValue(0)]
        [Category("Behavior")]
        [Description("Gets or sets the maximum height for the dropdown window.  0 = Autosize.  If the size is smaller than the contents then scrollbars will be shown.")]
        public int DropDownMaxHeight { get; set; }

        /// <summary>
        /// Gets or sets a value indicating if the DropDown portion of the combo box is currently shown.
        /// </summary>
        [Browsable(false)]
        [DefaultValue(false)]
        [Description("Indicates if the dropdown window is currently visible")]
        public bool DropDownVisible { get; private set; }

        /// <summary>
        /// Gets or sets a value indicating if the DropDown should be resizable
        /// </summary>
        [DefaultValue(false)]
        [Category("Drop Down")]
        [Description("Makes the DropDown resizable with a grip on the corner")]
        public bool DropDownResizable { get; set; }

        /// <summary>
        /// Overriden.
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public override Rectangle TextBoxTextBounds
        {
            get
            {
                Rectangle r = base.TextBoxTextBounds;

                r.Width -= DropDownButtonBounds.Width;

                return r;
            }
        }

        /// <summary>
        /// Gets the collection of items to be displayed on the dropdown
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Category("Drop Down")]
        public RibbonItemCollection DropDownItems { get; }

        // Steve
        /// <summary>
        /// Gets the selected of item on the dropdown
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public RibbonItem SelectedItem
        {
            get
            {
                if (_selectedItem == null)
                {
                    foreach (RibbonItem item in DropDownItems)
                    {
                        if (item.Text == TextBoxText)
                        {
                            _selectedItem = item;
                            return item;
                        }
                    }
                    return null;
                }

                if (DropDownItems.Contains(_selectedItem))
                {
                    return _selectedItem;
                }

                _selectedItem = null;
                return null;
            }
            //Steve
            set
            {
                if (value == null)
                {
                    _selectedItem = null;
                    TextBoxText = String.Empty;
                }
                else if (value.GetType().BaseType == typeof(RibbonItem))
                {
                    if (DropDownItems.Contains(value))
                    {
                        _selectedItem = value;
                        TextBoxText = _selectedItem.Text;
                    }
                    else
                    {
                        //_dropDownItems.Add(value);
                        _selectedItem = value;
                        TextBoxText = _selectedItem.Text;
                    }
                }
            }
        }

        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public int SelectedIndex
        {
            get
            {
                if (_selectedItem != null)
                {
                    return DropDownItems.IndexOf(_selectedItem);
                }
                else
                {
                    return -1;
                }
            }
            set
            {
                if (value == -1)
                {
                    SelectedItem = null;
                }
                else
                {
                    if ((DropDownItems.Count > 0) &&
                        (value >= 0) &&
                        (value < DropDownItems.Count))
                    {
                        SelectedItem = DropDownItems[value];
                    }
                    else
                    {
                        throw new ArgumentOutOfRangeException(nameof(SelectedIndex));
                    }
                }
            }
        }

        // Kevin
        /// <summary>
        /// Gets or sets the value of selected item on the dropdown.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string SelectedValue
        {
            get
            {
                if (_selectedItem == null)
                {
                    return null;
                }

                return _selectedItem.Value;
            }
            set
            {
                foreach (RibbonItem item in DropDownItems)
                {
                    if (String.Compare(item.Value, value, false) == 0)
                    {
                        if (_selectedItem != item)
                        {
                            _selectedItem = item;
                            TextBoxText = _selectedItem.Text;
                            RibbonItemEventArgs arg = new RibbonItemEventArgs(item);
                            OnDropDownItemClicked(ref arg);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Gets the DropDown of the button
        /// </summary>
        internal RibbonDropDown DropDown { get; private set; }

        #endregion

        #region Methods

        /// <summary>
        /// Raises the <see cref="DropDownShowing"/> event;
        /// </summary>
        /// <param name="e"></param>
        public void OnDropDownShowing(EventArgs e)
        {
            if (DropDownShowing != null)
            {
                DropDownShowing(this, e);
            }
        }

        /// <summary>
        /// Creates the DropDown menu
        /// </summary>
        protected virtual void CreateDropDown()
        {
            DropDown = new RibbonDropDown(this, DropDownItems, Owner);
        }

        /// <summary>
        /// Gets or sets if the icons bar should be drawn
        /// </summary>
        [Category("Drop Down")]
        [DisplayName("DrawDropDownIconsBar")]
        [DefaultValue(true)]
        public bool DrawIconsBar { get; set; }

        /// <summary>
        /// Shows the DropDown
        /// </summary>
        public virtual void ShowDropDown()
        {
            if (!DropDownVisible)
            {
                AssignHandlers();
                OnDropDownShowing(EventArgs.Empty);

                //Highlight (select) the item on the drop down that matches the ComboBox text.
                foreach (RibbonItem item in DropDownItems)
                {
                    item.SetSelected(item == SelectedItem);
                }

                CreateDropDown();

                DropDown.DropDownMaxHeight = DropDownMaxHeight;
                DropDown.ShowSizingGrip = DropDownResizable;
                DropDown.DrawIconsBar = DrawIconsBar;
                DropDown.Closed += DropDown_Closed;

                Point location = OnGetDropDownMenuLocation();
                DropDown.Show(location);
                DropDownVisible = true;
            }
        }

        private void DropDown_Closed(object sender, EventArgs e)
        {
            DropDownVisible = false;

            //Steve - when popup closed, un-highlight the dropdown arrow and redraw
            DropDownButtonPressed = false;
            //Kevin - Unselect it as well
            DropDownButtonSelected = false;

            SetSelected(false);

            RedrawItem();
        }

        private void AssignHandlers()
        {
            foreach (RibbonItem item in DropDownItems)
            {
                if (_assignedHandlers.Contains(item) == false)
                {
                    item.Click += DropDownItem_Click;
                    _assignedHandlers.Add(item);
                }
            }
        }

        private void RemoveHandlers()
        {
            foreach (RibbonItem item in _assignedHandlers)
            {
                item.Click -= DropDownItem_Click;
            }
            _assignedHandlers.Clear();
        }

        private void DropDownItem_Click(object sender, EventArgs e)
        {
            // Steve
            _selectedItem = (sender as RibbonItem);

            TextBoxText = (sender as RibbonItem).Text;
            //Kevin Carbis
            RibbonItemEventArgs ev = new RibbonItemEventArgs(sender as RibbonItem);
            OnDropDownItemClicked(ref ev);
        }


        #endregion

        #region Overrides

        protected override bool ClosesDropDownAt(Point p)
        {
            return false;
        }

        protected override void InitTextBox(TextBox t)
        {
            base.InitTextBox(t);

            t.Width -= DropDownButtonBounds.Width;
        }

        public override void SetBounds(Rectangle bounds)
        {
            base.SetBounds(bounds);

            DropDownButtonBounds = Rectangle.FromLTRB(
                bounds.Right - 15,
                bounds.Top,
                bounds.Right + 1,
                bounds.Bottom + 1);
        }

        public virtual void OnDropDownItemClicked(ref RibbonItemEventArgs e)
        {
            if (DropDownItemClicked != null)
            {
                DropDownItemClicked(this, e);
            }
        }

        public override void OnMouseMove(MouseEventArgs e)
        {
            if (!Enabled) return;

            base.OnMouseMove(e);

            bool mustRedraw = false;

            if (DropDownButtonBounds.Contains(e.X, e.Y))
            {
                Owner.Cursor = Cursors.Default;

                mustRedraw = !DropDownButtonSelected;

                DropDownButtonSelected = true;
            }
            else if (TextBoxBounds.Contains(e.X, e.Y))
            {
                Owner.Cursor = AllowTextEdit ? Cursors.IBeam : Cursors.Default;

                mustRedraw = DropDownButtonSelected;

                DropDownButtonSelected = false;
            }
            else
            {
                Owner.Cursor = Cursors.Default;
            }

            if (mustRedraw)
            {
                RedrawItem();
            }
        }

        public override void OnMouseDown(MouseEventArgs e)
        {
            if (!Enabled) return;
            // Steve - if allowtextedit is false, allow the textbox to bring up the popup
            if (DropDownButtonBounds.Contains(e.X, e.Y) || (TextBoxBounds.Contains(e.X, e.Y) != AllowTextEdit))
            {
                DropDownButtonPressed = true;

                ShowDropDown();
            }
            else if (TextBoxBounds.Contains(e.X, e.Y) && AllowTextEdit)
            {
                StartEdit();
            }
        }

        public override void OnMouseUp(MouseEventArgs e)
        {
            if (!Enabled) return;

            base.OnMouseUp(e);

            //Steve - pressed if set false when popup is closed
            //_dropDownPressed = false;
        }

        public override void OnMouseLeave(MouseEventArgs e)
        {
            if (!Enabled) return;

            base.OnMouseLeave(e);

            DropDownButtonSelected = false;

        }

        /// <summary>
        /// Gets the location where the dropdown menu will be shown
        /// </summary>
        /// <returns></returns>
        internal virtual Point OnGetDropDownMenuLocation()
        {
            Point location = Point.Empty;

            if (Canvas is RibbonDropDown)
            {
                location = Canvas.PointToScreen(new Point(TextBoxBounds.Left, Bounds.Bottom));
            }
            else
            {
                location = Owner.PointToScreen(new Point(TextBoxBounds.Left, Bounds.Bottom));
            }

            return location;
        }

        #endregion

        #region IContainsRibbonComponents Members

        public IEnumerable<Component> GetAllChildComponents()
        {
            return DropDownItems.ToArray();
        }

        #endregion

        #region IDropDownRibbonItem Members

        /// <summary>
        /// Gets or sets the bounds of the DropDown button
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle DropDownButtonBounds { get; private set; }

        /// <summary>
        /// Gets a value indicating if the DropDown is currently visible
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool DropDownButtonVisible => DropDownVisible;

        /// <summary>
        /// Gets a value indicating if the DropDown button is currently selected
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool DropDownButtonSelected { get; private set; }

        /// <summary>
        /// Gets a value indicating if the DropDown button is currently pressed
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool DropDownButtonPressed { get; private set; }

        internal override void SetOwner(Ribbon owner)
        {
            base.SetOwner(owner);

            DropDownItems.SetOwner(owner);
        }

        internal override void SetOwnerPanel(RibbonPanel ownerPanel)
        {
            base.SetOwnerPanel(ownerPanel);

            DropDownItems.SetOwnerPanel(ownerPanel);
        }

        internal override void SetOwnerTab(RibbonTab ownerTab)
        {
            base.SetOwnerTab(ownerTab);

            DropDownItems.SetOwnerTab(OwnerTab);
        }

        internal override void SetOwnerItem(RibbonItem ownerItem)
        {
            base.SetOwnerItem(ownerItem);
        }

        internal override void ClearOwner()
        {
            List<RibbonItem> oldItems = new List<RibbonItem>(DropDownItems);

            base.ClearOwner();

            foreach (RibbonItem item in oldItems)
            {
                item.ClearOwner();
            }
        }

        #endregion
    }
}