using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using Xamarin.Forms;

namespace Tizen.Xamarin.Forms.Extension
{
    /// <summary>
    /// The ContextPopup class allows a contextual popup to be anchored at a view.
    /// </summary>
    /// <example>
    /// <code>
    /// ContextPopup popup = new ContextPopup
    /// {
    ///     DirectionPriorities = new ContextPopupDirectionPriorities(ContextPopupDirection.Down, ContextPopupDirection.Right, ContextPopupDirection.Left, ContextPopupDirection.Up),
    /// };
    /// popup.Items.Add(new ContextPopupItem("Text only item"));
    /// popup.Items.Add(new ContextPopupItem("Home icon", "home"));
    /// popup.Items.Add(new ContextPopupItem("Chat", StandardIconResource.MenuChat.Name));
    /// popup.SelectedIndexChanged += (s, e) =>
    /// {
    ///     var ctxPopup = s as ContextPopup;
    ///     Debug.WriteLine("Item with index {0} selected", ctxPopup.SelectedIndex);
    ///     Debug.WriteLine("It has label: " + (ctxPopup.SelectedItem as ContextPopupItem).Label);
    /// };
    ///
    /// Button btn = new Button
    /// {
    ///     Text = "Toggle popup"
    /// };
    /// btn.Clicked += (s, e) =>
    /// {
    ///     popup.Show(s as Button);
    /// };
    /// </code>
    /// </example>
    public class ContextPopup : BindableObject
    {
        IContextPopup _contextPopup;

        ObservableCollection<ContextPopupItem> _items;

        static ContextPopupDirectionPriorities _priorities =
            new ContextPopupDirectionPriorities(ContextPopupDirection.Up, ContextPopupDirection.Left, ContextPopupDirection.Right, ContextPopupDirection.Down);

        [Obsolete("OrientationProperty is obsolete as of version 2.3.5-r256-001. The orientation is always vertical.")]
        public static readonly BindableProperty OrientationProperty = BindableProperty.Create(nameof(Orientation), typeof(ContextPopupOrientation), typeof(ContextPopup),
            defaultValue: ContextPopupOrientation.Vertical);

        /// <summary>
        /// BindableProperty. Identifies the IsAutoHidingEnabled bindable property.
        /// </summary>
        public static readonly BindableProperty IsAutoHidingEnabledProperty = BindableProperty.Create(nameof(IsAutoHidingEnabled), typeof(bool), typeof(ContextPopup), defaultValue: true);

        /// <summary>
        /// BindableProperty. Identifies the DirectionPriorities bindable property.
        /// </summary>
        public static readonly BindableProperty DirectionPrioritiesProperty = BindableProperty.Create(nameof(DirectionPriorities), typeof(ContextPopupDirectionPriorities),
            typeof(ContextPopup), defaultValue: _priorities);

        /// <summary>
        /// BindableProperty. Identifies the SelectedIndex bindable property.
        /// </summary>
        public static readonly BindableProperty SelectedIndexProperty = BindableProperty.Create(nameof(SelectedIndex), typeof(int), typeof(ContextPopup), defaultValue: -1,
            propertyChanged: OnSelectedIndexChanged, coerceValue: CoerceSelectedIndex);

        /// <summary>
        /// BindableProperty. Identifies the SelectedItem bindable property.
        /// </summary>
        public static readonly BindableProperty SelectedItemProperty = BindableProperty.Create(nameof(SelectedItem), typeof(object), typeof(ContextPopup), null,
            propertyChanged: OnSelectedItemChanged);

        [Obsolete("ItemsSourceProperty is obsolete as of version 2.3.5-r256-001. Please use Items instead.")]
        public static readonly BindableProperty ItemsSourceProperty = BindableProperty.Create(nameof(ItemsSource), typeof(IList), typeof(ContextPopup), default(IList));

        /// <summary>
        /// The constructor, which creates a new ContextPopup instance.
        /// </summary>
        public ContextPopup()
        {
            _contextPopup = DependencyService.Get<IContextPopup>(DependencyFetchTarget.NewInstance);

            _contextPopup.Dismissed += (s, e) => Dismissed?.Invoke(this, EventArgs.Empty);
            _contextPopup.ItemSelected += (s, e) => ItemSelected?.Invoke(this, EventArgs.Empty);

            _items = new ObservableCollection<ContextPopupItem>();
            _items.CollectionChanged += ItemsCollectionChanged;

            SetBinding(IsAutoHidingEnabledProperty, new Binding(nameof(IsAutoHidingEnabled), mode: BindingMode.TwoWay, source: _contextPopup));
            SetBinding(DirectionPrioritiesProperty, new Binding(nameof(DirectionPriorities), mode: BindingMode.TwoWay, source: _contextPopup));
            SetBinding(SelectedItemProperty, new Binding(nameof(SelectedItem), mode: BindingMode.TwoWay, source: _contextPopup));
        }

        /// <summary>
        /// Occurs when the ContextPopup is dismissed.
        /// </summary>
        public event EventHandler Dismissed;

        /// <summary>
        /// Occurs when the index of the selected ContextPopupItem changes.
        /// </summary>
        public event EventHandler SelectedIndexChanged;

        /// <summary>
        /// Occurs when a ContextPopupItem is selected.
        /// </summary>
        public event EventHandler ItemSelected;

        [Obsolete("Orientation is obsolete as of version 2.3.5-r256-001. The orientation is always vertical.")]
        public ContextPopupOrientation Orientation
        {
            get { return (ContextPopupOrientation)GetValue(OrientationProperty); }
            set { SetValue(OrientationProperty, value); }
        }

        /// <summary>
        /// Gets or sets whether ContextPopup should be hidden automatically or not when parent of ContextPopup is resized.
        /// </summary>
        /// <remarks>
        /// Setting IsAutoHidingEnabled to false will not be dismissed automatically whenever such as mouse clicked its background area, language i s changed, and its parent geometry is updated(changed).
        /// </remarks>
        public bool IsAutoHidingEnabled
        {
            get { return (bool)GetValue(IsAutoHidingEnabledProperty); }
            set { SetValue(IsAutoHidingEnabledProperty, value); }
        }

        /// <summary>
        /// Gets or sets the direction priorities for the ContextPopup.<br>
        /// The position of the ContextPopup depends on the available space.
        /// Therefore, DirectionPriorities are used to specify desired first, second, third, and fourth priorities for positioning the ContextPopup.
        /// </summary>
        public ContextPopupDirectionPriorities DirectionPriorities
        {
            get { return (ContextPopupDirectionPriorities)GetValue(DirectionPrioritiesProperty); }
            set { SetValue(DirectionPrioritiesProperty, value); }
        }

        /// <summary>
        /// Gets or sets the index of the selected item of the ContextPopup.
        /// It is -1 when no item is selected.
        /// </summary>
        public int SelectedIndex
        {
            get { return (int)GetValue(SelectedIndexProperty); }
            set { SetValue(SelectedIndexProperty, value); }
        }

        /// <summary>
        /// Gets or sets the selected item of the ContextPopup.
        /// </summary>
        public ContextPopupItem SelectedItem
        {
            get { return (ContextPopupItem)GetValue(SelectedItemProperty); }
            set { SetValue(SelectedItemProperty, value); }
        }

        [Obsolete("ItemsSource is obsolete as of version 2.3.5-r256-001. Please use Items instead.")]
        public IList ItemsSource
        {
            get { return (IList)GetValue(ItemsSourceProperty); }
            set { SetValue(ItemsSourceProperty, value); }
        }

        /// <summary>
        /// Gets the list of items in the ContextPopup.
        /// </summary>
        public IList<ContextPopupItem> Items
        {
            get
            {
                return _items;
            }
        }

        /// <summary>
        /// Shows the ContextPopup. The ContextPopup is positioned at the horizontal and the vertical position of a specific anchor.
        /// </summary>
        /// <param name="anchor">The view to which the popup should be anchored.</param>
        public void Show(View anchor)
        {
            Show(anchor, 0, 0);
        }

        /// <summary>
        /// Shows the ContextPopup. The ContextPopup is positioned at the horizontal and the vertical position of a specific anchor with offsets.
        /// </summary>
        /// <param name="anchor">The view to which the popup should be anchored.</param>
        /// <param name="xOffset">The horizontal offset from the anchor.</param>
        /// <param name="yOffset">The vertical offset from the anchor.</param>
        public void Show(View anchor, int xOffset, int yOffset)
        {
            _contextPopup.Show(anchor, xOffset, yOffset);
        }

        /// <summary>
        /// Shows the ContextPopup. The ContextPopup is positioned at the horizontal and the vertical position of a specific anchor with offsets.
        /// </summary>
        /// <param name="anchor">The view to which the popup should be anchored.</param>
        /// <param name="xOffset">The horizontal offset from the anchor.</param>
        /// <param name="yOffset">The vertical offset from the anchor.</param>
        public void Show(View anchor, double xOffset, double yOffset)
        {
            Show(anchor, (int)xOffset, (int)yOffset);
        }

        /// <summary>
        /// Dismisses the ContextPopup.
        /// </summary>
        public void Dismiss()
        {
            _contextPopup.Dismiss();
        }

        /// <summary>
        /// Gets the direction of the ContextPopup if it is shown.
        /// This method returns false if it is not shown and the output argument is a default value.
        /// </summary>
        /// <param name="direction">The direction of the ContextPopup.</param>
        /// <returns>true if the ContextPopup is shown, false otherwise.</returns>
        public bool TryGetContextPopupDirection(out ContextPopupDirection direction)
        {
            direction = default(ContextPopupDirection);
            return _contextPopup.TryGetContextPopupDirection(out direction);
        }

        void ItemsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    AddItems(e);
                    break;

                case NotifyCollectionChangedAction.Remove:
                    RemoveItems(e);
                    break;

                default: // Move, replace, reset
                    ResetItems();
                    break;
            }

            SelectedIndex = SelectedIndex.Clamp(-1, Items.Count - 1);
            UpdateSelectedItem();
        }

        void ResetItems()
        {
            _contextPopup.ClearItems();
        }

        void RemoveItems(NotifyCollectionChangedEventArgs e)
        {
            _contextPopup.RemoveItems(e.OldItems.OfType<ContextPopupItem>());
        }

        void AddItems(NotifyCollectionChangedEventArgs e)
        {
            _contextPopup.AddItems(e.NewItems.OfType<ContextPopupItem>());
        }

        static void OnSelectedIndexChanged(BindableObject bindable, object oldValue, object newValue)
        {
            var contextPopup = (ContextPopup)bindable;
            contextPopup.UpdateSelectedItem();
            contextPopup.SelectedIndexChanged?.Invoke(contextPopup, EventArgs.Empty);
        }

        static object CoerceSelectedIndex(BindableObject bindable, object value)
        {
            var contextPopup = (ContextPopup)bindable;
            return contextPopup.Items == null ? -1 : ((int)value).Clamp(-1, contextPopup.Items.Count - 1);
        }

        void UpdateSelectedItem()
        {
            if (SelectedIndex == -1)
            {
                SelectedItem = null;
                return;
            }

            SelectedItem = Items[SelectedIndex];
        }

        static void OnSelectedItemChanged(BindableObject bindable, object oldValue, object newValue)
        {
            var contextPopup = (ContextPopup)bindable;
            contextPopup.UpdateSelectedIndex(newValue);
        }

        void UpdateSelectedIndex(object selectedItem)
        {
            SelectedIndex = Items.IndexOf(selectedItem as ContextPopupItem);
        }
    }

    internal static class NumericExtensions
    {
        public static int Clamp(this int self, int min, int max)
        {
            return Math.Min(max, Math.Max(self, min));
        }
    }
}