using System;
using System.Collections;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media;

namespace Developpez.Dotnet.Windows.Behaviors
{
    /// <summary>
    /// Fournit des propriétés attachées pour gérer l'autocomplétion dans une TextBox
    /// </summary>
    public static class AutoCompleteBehavior
    {
        #region Attached properties
        
        /// <summary>
        /// Identifiant de la propriété attachée ItemsSource
        /// </summary>
        public static readonly DependencyProperty ItemsSourceProperty =
            DependencyProperty.RegisterAttached(
              "ItemsSource",
              typeof(IEnumerable),
              typeof(AutoCompleteBehavior),
              new UIPropertyMetadata(
                null,
                ItemsSourceChanged));

        /// <summary>
        /// Identifiant de la propriété attachée DisplayMemberPath
        /// </summary>
        public static readonly DependencyProperty DisplayMemberPathProperty =
            DependencyProperty.RegisterAttached("DisplayMemberPath", typeof(string), typeof(AutoCompleteBehavior), new UIPropertyMetadata(string.Empty));

        /// <summary>
        /// Identifiant de la propriété attachée SearchMemberPath
        /// </summary>
        public static readonly DependencyProperty SearchMemberPathProperty =
            DependencyProperty.RegisterAttached("SearchMemberPath", typeof(string), typeof(AutoCompleteBehavior), new UIPropertyMetadata(string.Empty));

        /// <summary>
        /// Identifiant de la propriété attachée ComparisonType
        /// </summary>
        public static readonly DependencyProperty ComparisonTypeProperty =
            DependencyProperty.RegisterAttached("ComparisonType", typeof(StringComparison), typeof(AutoCompleteBehavior), new UIPropertyMetadata(StringComparison.CurrentCultureIgnoreCase));

        /// <summary>
        /// Identifiant de la propriété attachée Suggest
        /// </summary>
        public static readonly DependencyProperty SuggestProperty =
            DependencyProperty.RegisterAttached("Suggest", typeof(bool), typeof(AutoCompleteBehavior), new UIPropertyMetadata(false));

        /// <summary>
        /// Identifiant de la propriété attachée MatchMode
        /// </summary>
        public static readonly DependencyProperty MatchModeProperty =
            DependencyProperty.RegisterAttached("MatchMode", typeof(StringMatchMode), typeof(AutoCompleteBehavior), new UIPropertyMetadata(StringMatchMode.StartsWith));

        /// <summary>
        /// Identifiant de la propriété attachée ItemTemplate
        /// </summary>
        public static readonly DependencyProperty ItemTemplateProperty =
            DependencyProperty.RegisterAttached("ItemTemplate", typeof(DataTemplate), typeof(AutoCompleteBehavior), new UIPropertyMetadata(null));

        private static readonly DependencyPropertyKey AutoCompletePopupPropertyKey =
            DependencyProperty.RegisterAttachedReadOnly("AutoCompletePopup", typeof(AutoCompletePopup), typeof(AutoCompleteBehavior), new UIPropertyMetadata(null));

        #endregion

        #region Attached property accessors

        /// <summary>
        /// Obtient la valeur de la propriété attachée ItemsSource pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut obtenir la valeur de la propriété</param>
        /// <returns>La liste utilisée pour l'autocomplétion</returns>
        [AttachedPropertyBrowsableForType(typeof(TextBox))]
        public static IEnumerable GetItemsSource(TextBox obj)
        {
            return (IEnumerable)obj.GetValue(ItemsSourceProperty);
        }

        /// <summary>
        /// Définit la valeur de la propriété attachée ItemsSource pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut définir la valeur de la propriété</param>
        /// <param name="value">La liste à utiliser pour l'autocomplétion</param>
        public static void SetItemsSource(TextBox obj, IEnumerable value)
        {
            obj.SetValue(ItemsSourceProperty, value);
        }

        /// <summary>
        /// Obtient la valeur de la propriété attachée ItemTemplate pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut obtenir la valeur de la propriété</param>
        /// <returns>Le DataTemplate utilisé pour les éléments de la liste</returns>
        [AttachedPropertyBrowsableForType(typeof(TextBox))]
        public static DataTemplate GetItemTemplate(DependencyObject obj)
        {
            return (DataTemplate)obj.GetValue(ItemTemplateProperty);
        }

        /// <summary>
        /// Définit la valeur de la propriété attachée ItemTemplate pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut définir la valeur de la propriété</param>
        /// <param name="value">Le DataTemplate à utiliser pour les éléments de la liste</param>
        public static void SetItemTemplate(DependencyObject obj, DataTemplate value)
        {
            obj.SetValue(ItemTemplateProperty, value);
        }

        /// <summary>
        /// Obtient la valeur de la propriété attachée DisplayMemberPath pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut obtenir la valeur de la propriété</param>
        /// <returns>Le membre des éléments de la liste à afficher</returns>
        [AttachedPropertyBrowsableForType(typeof(TextBox))]
        public static string GetDisplayMemberPath(DependencyObject obj)
        {
            return (string)obj.GetValue(DisplayMemberPathProperty);
        }

        /// <summary>
        /// Définit la valeur de la propriété attachée DisplayMemberPath pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut définir la valeur de la propriété</param>
        /// <param name="value">Le membre des éléments de la liste à afficher</param>
        public static void SetDisplayMemberPath(DependencyObject obj, string value)
        {
            obj.SetValue(DisplayMemberPathProperty, value);
        }

        /// <summary>
        /// Obtient la valeur de la propriété attachée SearchMemberPath pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut obtenir la valeur de la propriété</param>
        /// <returns>Le membre des éléments de la liste utilisé pour la recherche</returns>
        [AttachedPropertyBrowsableForType(typeof(TextBox))]
        public static string GetSearchMemberPath(DependencyObject obj)
        {
            return (string)obj.GetValue(SearchMemberPathProperty);
        }

        /// <summary>
        /// Définit la valeur de la propriété attachée SearchMemberPath pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut définir la valeur de la propriété</param>
        /// <param name="value">Le membre des éléments de la liste à utiliser pour la recherche</param>
        public static void SetSearchMemberPath(DependencyObject obj, string value)
        {
            obj.SetValue(SearchMemberPathProperty, value);
        }

        /// <summary>
        /// Obtient la valeur de la propriété attachée Suggest pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut obtenir la valeur de la propriété</param>
        /// <returns>True si la suite du texte est suggérée automatiquement, sinon false</returns>
        [AttachedPropertyBrowsableForType(typeof(TextBox))]
        public static bool GetSuggest(DependencyObject obj)
        {
            return (bool)obj.GetValue(SuggestProperty);
        }

        /// <summary>
        /// Définit la valeur de la propriété attachée Suggest pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut définir la valeur de la propriété</param>
        /// <param name="value">True pour suggérer automatiquement la suite du texte, sinon false</param>
        public static void SetSuggest(DependencyObject obj, bool value)
        {
            obj.SetValue(SuggestProperty, value);
        }

        /// <summary>
        /// Obtient la valeur de la propriété attachée MatchMode pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut obtenir la valeur de la propriété</param>
        /// <returns>Le mode de correspondance de chaine utilisé pour la recherche</returns>
        [AttachedPropertyBrowsableForType(typeof(TextBox))]
        public static StringMatchMode GetMatchMode(DependencyObject obj)
        {
            return (StringMatchMode)obj.GetValue(MatchModeProperty);
        }

        /// <summary>
        /// Définit la valeur de la propriété attachée MatchMode pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut définir la valeur de la propriété</param>
        /// <param name="value">Le mode de correspondance de chaine à utiliser pour la recherche</param>
        public static void SetMatchMode(DependencyObject obj, StringMatchMode value)
        {
            obj.SetValue(MatchModeProperty, value);
        }

        /// <summary>
        /// Obtient la valeur de la propriété attachée ComparisonType pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut obtenir la valeur de la propriété</param>
        /// <returns>Le type de comparaison de chaine pour le filtrage</returns>
        [AttachedPropertyBrowsableForType(typeof(TextBox))]
        public static StringComparison GetComparisonType(DependencyObject obj)
        {
            return (StringComparison)obj.GetValue(ComparisonTypeProperty);
        }

        /// <summary>
        /// Définit la valeur de la propriété attachée ComparisonType pour l'élément spécifié.
        /// </summary>
        /// <param name="obj">L'objet pour lequel on veut définir la valeur de la propriété</param>
        /// <param name="value">Le type de comparaison de chaine pour le filtrage</param>
        public static void SetComparisonType(DependencyObject obj, StringComparison value)
        {
            obj.SetValue(ComparisonTypeProperty, value);
        }

        #endregion

        private static void ItemsSourceChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            TextBox textBox = o as TextBox;
            if (textBox == null)
                return;

            if (e.OldValue != null && e.NewValue == null)
            {
                var popup = (AutoCompletePopup)textBox.GetValue(AutoCompletePopupPropertyKey.DependencyProperty);
                if (popup != null)
                    popup.Dispose();
            }
            else if (e.OldValue == null && e.NewValue != null)
            {
                new AutoCompletePopup(textBox);
            }
        }

        private class AutoCompletePopup : Popup, IDisposable
        {
            private readonly ListBox _listBox;
            private readonly TextBox _textBox;
            private string _currentSearch;
            private bool _textChanging;
            private bool _deleting;

            public AutoCompletePopup(TextBox textBox)
            {
                _textBox = textBox;
                SetBinding(
                    MinWidthProperty,
                    new Binding
                    {
                        Path = new PropertyPath("ActualWidth"),
                        Source = textBox
                    });
                StaysOpen = true;

                _listBox = new ListBox();

                _listBox.SetBinding(
                    ItemsControl.ItemsSourceProperty,
                    new Binding
                    {
                        Path = new PropertyPath(ItemsSourceProperty),
                        Source = _textBox
                    });

                _listBox.SetBinding(
                    ItemsControl.DisplayMemberPathProperty,
                    new Binding
                    {
                        Path = new PropertyPath(DisplayMemberPathProperty),
                        Source = _textBox
                    });

                _listBox.SetBinding(
                    ItemsControl.ItemTemplateProperty,
                    new Binding
                    {
                        Path = new PropertyPath(ItemTemplateProperty),
                        Source = _textBox
                    });

                _listBox.AddHandler(Mouse.MouseDownEvent, new MouseButtonEventHandler(_listBox_MouseLeftButtonDown), true);

                Child = _listBox;
                PlacementTarget = _textBox;
                Placement = PlacementMode.Bottom;
                MaxHeight = 200;
                AllowsTransparency = true;
                SetResourceReference(PopupAnimationProperty, SystemParameters.ComboBoxPopupAnimationKey);
                Focusable = false;

                _textBox.LostFocus += _textBox_LostFocus;
                _textBox.TextChanged += _textBox_TextChanged;
                _textBox.PreviewKeyDown += _textBox_PreviewKeyDown;
                Window window = Window.GetWindow(_textBox);
                if (window != null)
                    window.Deactivated += window_Deactivated;

                _textBox.SetValue(AutoCompletePopupPropertyKey, this);
            }

            protected override void OnOpened(EventArgs e)
            {
                base.OnOpened(e);
                RefreshFilter();
            }

            private void RefreshFilter()
            {
                var view = CollectionViewSource.GetDefaultView(_listBox.ItemsSource);
                if (view != null)
                {
                    view.SortDescriptions.Clear();
                    string displayMemberPath = GetDisplayMemberPath(_textBox);
                    if (!string.IsNullOrEmpty(displayMemberPath))
                        view.SortDescriptions.Add(new System.ComponentModel.SortDescription(displayMemberPath, System.ComponentModel.ListSortDirection.Ascending));
                    if (string.IsNullOrEmpty(_textBox.Text))
                    {
                        view.Filter = null;
                    }
                    else
                    {
                        view.Filter = FilterItem;
                    }
                }
            }

            private bool FilterItem(object obj)
            {
                if (string.IsNullOrEmpty(_currentSearch))
                    return true;

                var comparisonType = GetComparisonType(_textBox);
                var matchMode = GetMatchMode(_textBox);

                string itemText = GetItemText(obj);
                if (itemText != null)
                {
                    switch (matchMode)
                    {
                        case StringMatchMode.StartsWith:
                            return itemText.StartsWith(_currentSearch, comparisonType);
                        case StringMatchMode.EndsWith:
                            return itemText.EndsWith(_currentSearch, comparisonType);
                        case StringMatchMode.Contains:
                            return itemText.Contains(_currentSearch, comparisonType);
                        default:
                            break;
                    }
                }
                return false;
            }

            private string GetItemText(object obj)
            {
                string path = GetSearchMemberPath(_textBox);
                if (string.IsNullOrEmpty(path))
                    path = GetDisplayMemberPath(_textBox);
                if (!string.IsNullOrEmpty(path) && obj != null)
                {
                    obj = PropertyPathHelper.GetValue(obj, path);
                }
                if (obj != null)
                    return obj.ToString();
                return null;
            }

            private void _listBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
            {
                if (IsInListBoxItem(e.OriginalSource as DependencyObject))
                {
                    ChooseSelectedText();
                    IsOpen = false;
                }
            }

            private static bool IsInListBoxItem(DependencyObject o)
            {
                if (o == null)
                    return false;

                if (o is ListBoxItem)
                    return true;
                DependencyObject parent = VisualTreeHelper.GetParent(o);
                return IsInListBoxItem(parent);
            }

            private void window_Deactivated(object sender, EventArgs e)
            {
                IsOpen = false;
            }

            private void _textBox_TextChanged(object sender, RoutedEventArgs e)
            {
                if (_textChanging)
                    return;

                string searchText = _textBox.Text;
                int start = _textBox.SelectionStart;
                int length = _textBox.SelectionLength;
                if (length != 0)
                    searchText = _textBox.Text.Substring(0, _textBox.SelectionStart);

                IsOpen = true;

                if (searchText != _currentSearch)
                {
                    _currentSearch = searchText;
                    RefreshFilter();
                }

                if (GetSuggest(_textBox) && !_deleting)
                {
                    object firstSuggestion = _listBox.Items.Cast<object>().FirstOrDefault();
                    if (firstSuggestion != null)
                    {
                        string suggestedText = GetItemText(firstSuggestion);
                        if (!string.IsNullOrEmpty(suggestedText))
                        {
                            try
                            {
                                _textChanging = true;
                                _textBox.Text = suggestedText;
                                _textBox.Select(start, suggestedText.Length - start);
                            }
                            finally
                            {
                                _textChanging = false;
                            }
                        }
                    }
                }
                _deleting = false;
            }

            private void _textBox_LostFocus(object sender, RoutedEventArgs e)
            {
                IsOpen = false;
            }

            private void _textBox_PreviewKeyDown(object sender, KeyEventArgs e)
            {
                switch (e.Key)
                {
                    case Key.Down:
                        IsOpen = true;
                        MoveSelection(1);
                        break;
                    case Key.Up:
                        IsOpen = true;
                        MoveSelection(-1);
                        break;
                    case Key.Escape:
                        IsOpen = false;
                        break;
                    case Key.Enter:
                        ChooseSelectedText();
                        IsOpen = false;
                        break;
                    case Key.Delete:
                    case Key.Back:
                        _deleting = true;
                        break;
                }
            }

            private void MoveSelection(int direction)
            {
                if (direction < 0)
                {
                    if (_listBox.SelectedIndex < 0)
                        _listBox.SelectedIndex = _listBox.Items.Count - 1;
                    else
                       _listBox.SelectedIndex--;
                }
                else if (direction > 0)
                {
                    if (_listBox.SelectedIndex < 0)
                        _listBox.SelectedIndex = 0;
                    else
                        _listBox.SelectedIndex++;
                }
                _listBox.ScrollIntoView(_listBox.SelectedItem);
            }

            private void ChooseSelectedText()
            {
                string itemText = GetItemText(_listBox.SelectedItem);
                if (itemText != null)
                    _textBox.Text = itemText;
            }

            public void Dispose()
            {
                _textBox.LostFocus -= _textBox_LostFocus;
                _textBox.TextChanged -= _textBox_TextChanged;
                _textBox.PreviewKeyDown -= _textBox_PreviewKeyDown;

                Window window = Window.GetWindow(_textBox);
                if (window != null)
                    window.Deactivated -= window_Deactivated;

                _textBox.ClearValue(AutoCompletePopupPropertyKey);
            }
        }
    }
}