using System;
using System.Windows.Forms;
using System.Drawing;
using System.ComponentModel;
using FastReport.Design;
using FastReport.Utils;
using FastReport.DevComponents.DotNetBar;
using FastReport.Controls;
using System.Collections.Generic;

namespace FastReport
{
    /// <summary>
    /// The base class for the context menu item.
    /// </summary>
    [ToolboxItem(false)]
    public class ContextMenuItem : ButtonItem, IToolbarItem
    {
        bool qatItem = false;
        /// <summary>
        /// Gets a collection of menu items.
        /// </summary>
        public SubItemsCollection DropDownItems
        {
            get { return SubItems; }
        }

        /// <summary>
        /// Gets or sets "Check on click" property.
        /// </summary>
        public bool CheckOnClick
        {
            get { return AutoCheckOnClick; }
            set { AutoCheckOnClick = value; }
        }

        /// <summary>
        /// Sets bold font.
        /// </summary>
        public void SetFontBold()
        {
            FontBold = true;
            HotFontBold = true;
        }

        /// <summary>
        /// Gets or sets a value indicating whether the item will be added to the toolbar.
        /// </summary>
        public bool QatItem
        {
            get { return qatItem; }
            set
            {
                qatItem = value;
                if (value)
                {
                    Tooltip = Text;
                }
                else
                {
                    Tooltip = "";
                }
            }
        }
    }

    /// <summary>
    /// The base class for the context menu of the report component.
    /// </summary>
    /// <remarks>
    /// This class represents a context menu of the report component that is displayed when the object 
    /// is right-clicked in the designer.
    /// </remarks>
    [ToolboxItem(false)]
    public class ContextMenuBase : ContextMenuBar
    {
        #region Fields
        private ContextMenuItem mnuContextRoot;
        private ItemContainer toolbar;
        private List<ButtonItem> items;
        #endregion

        #region Properties
        /// <summary>
        /// The reference to the report designer.
        /// </summary>
        public Designer Designer { get; }

        /// <summary>
        /// Gets a collection of menu items.
        /// </summary>
        /// <remarks>
        /// You should add new items to this collection.
        /// </remarks>
        public new List<ButtonItem> Items => items;

        /// <summary>
        /// Gets or sets the image list.
        /// </summary>
        public ImageList ImageList
        {
            get => Images;
            set
            {
                Images = value;
                UpdateItems();
            }
        }

        public event CancelEventHandler Opening;
        #endregion

        private void UpdateItems()
        {
            foreach (BaseItem item in Items)
            {
                ButtonItem b = item as ButtonItem;
                if (b != null && b.ImageIndex != -1)
                {
                    // looks like this is the only way to completely refresh the image displayed (including disabled images).
                    b.Image = Designer.GetImage(b.ImageIndex);
                }
            }
        }

        #region Protected Methods
        /// <summary>
        /// This method is called to reflect changes in the designer.
        /// </summary>
        protected virtual void Change()
        {
            Designer.SetModified(null, "Change");
        }

        /// <summary>
        /// Creates a new menu item.
        /// </summary>
        /// <param name="text">Item's text.</param>
        /// <returns>New item.</returns>
        protected ContextMenuItem CreateMenuItem(string text)
        {
            return CreateMenuItem(-1, text, null);
        }

        /// <summary>
        /// Creates a new menu item.
        /// </summary>
        /// <param name="text">Item's text.</param>
        /// <param name="click">Click handler.</param>
        /// <returns>New item.</returns>
        protected ContextMenuItem CreateMenuItem(string text, EventHandler click)
        {
            return CreateMenuItem(-1, text, click);
        }

        /// <summary>
        /// Creates a new menu item.
        /// </summary>
        /// <param name="imageIndex">Item's image index.</param>
        /// <param name="text">Item's text.</param>
        /// <param name="click">Click handler.</param>
        /// <returns>New item.</returns>
        protected ContextMenuItem CreateMenuItem(int imageIndex, string text, EventHandler click)
        {
            ContextMenuItem item = new ContextMenuItem();
            if (imageIndex != -1)
                item.Image = Designer.GetImage(imageIndex);
            item.Text = text;

            if (click != null)
                item.Click += click;
            return item;
        }
        #endregion

        /// <summary>
        /// Clears menu items.
        /// </summary>
        public void Clear()
        {
            mnuContextRoot.SubItems.Clear();
            toolbar.SubItems.Clear();
        }

        /// <summary>
        /// Adds an item to this menu.
        /// </summary>
        /// <param name="menuItem">Menu item to add.</param>
        public void AddItem(ButtonItem menuItem) => mnuContextRoot.SubItems.Add(menuItem);

        /// <summary>
        /// Returns true if menu is empty.
        /// </summary>
        public bool IsEmpty => mnuContextRoot.SubItems.Count == 0;

        /// <summary>
        /// Displays context menu.
        /// </summary>
        /// <param name="parent">Parent control.</param>
        /// <param name="location">Location.</param>
        public void Show(Control parent, Point location)
        {
            foreach (ButtonItem button in Items)
            {
                if (button is ContextMenuItem && (button as ContextMenuItem).QatItem)
                {
                    toolbar.SubItems.Add(button);
                }
                else
                {
                    mnuContextRoot.SubItems.Add(button);
                }
            }

            if (mnuContextRoot.SubItems.Count > 2)
            {
                mnuContextRoot.SubItems[1].BeginGroup = toolbar.SubItems.Count > 0;
                mnuContextRoot.SubItems[2].BeginGroup = toolbar.SubItems.Count > 0;
            }
            toolbar.Visible = toolbar.SubItems.Count > 0;

            mnuContextRoot.PopupMenu(parent.PointToScreen(location));
        }

        /// <summary>
        /// Updates the menu style.
        /// </summary>
        public void UpdateUIStyle()
        {
            toolbar.BackgroundStyle.BackColor = UIStyleUtils.GetControlColor(Designer.UIStyle);
            Style = UIStyleUtils.GetDotNetBarStyle(Designer.UIStyle);
        }

        /// <summary>
        /// Initializes a new instance of the <b>ComponentBaseMenu</b> class with default settings. 
        /// </summary>
        /// <param name="designer">The reference to a report designer.</param>
        public ContextMenuBase(Designer designer)
        {
            Designer = designer;
            Font = Designer.LogicalToDevice(DrawUtils.DefaultFont);
            mnuContextRoot = new ContextMenuItem();
            items = new List<ButtonItem>();
            base.Items.Add(mnuContextRoot);

            mnuContextRoot.PopupOpen += (s, e) =>
            {
                var args = new CancelEventArgs(false);
                Opening?.Invoke(this, args);
                e.Cancel = args.Cancel;
            };

            toolbar = new ItemContainer();
            toolbar.LayoutOrientation = eOrientation.Horizontal;
            mnuContextRoot.SubItems.Add(toolbar);
            UpdateUIStyle();
        }
    }
}