using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using Tango.Core.Commands;
using Tango.Core.EventArguments;
using Tango.SharedUI;
using Tango.Touch.Keyboard;

namespace Tango.Touch.Controls
{
    public class TouchPanel : ContentControl
    {
        private TouchListBox _combobox_list;
        private Grid _combobox_grid;
        private TouchIconButton _comboBoxCloseButton;
        private TouchCalendar _calendar;
        private Grid _calendar_grid;
        private bool _isDialogGridMaskMouseDown;
        protected Border _dialogBorder;

        static TouchPanel()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(TouchPanel), new FrameworkPropertyMetadata(typeof(TouchPanel)));
        }

        public TouchPanel()
        {
            ComboBoxPickedCommand = new RelayCommand((x) =>
            {
                CurrentComboBox.SetResultFromTouchPanel(x);
                CurrentComboBox = null;
            });

            DateSelectedCommand = new RelayCommand(() =>
            {
                CurrentDatePicker.SetResultFromTouchPanel(_calendar.SelectedDate.Value);
                CurrentDatePicker = null;
            });

            CancelDateCommand = new RelayCommand(() =>
            {
                CurrentDatePicker = null;
            });

            this.RegisterForMouseOrTouchDown(OnMouseDown);
        }

        private void OnMouseDown(object sender, MouseOrTouchEventArgs e)
        {
            var element = e.OriginalSource as FrameworkElement;

            if (element != null && GetPreventFocusSteal(element)) return;
            if (element != null && element.FindAncestor(x => GetPreventFocusSteal(x as FrameworkElement)) != null) return;
            if (element != null && (element.Focusable || element.FindAncestor<TouchKeyboard>() != null)) return;

            Focus(); //TODO: Notice that this does not cause trouble. (Originally inserted for stealing focus from pop-ups)
        }

        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();

            _combobox_list = GetTemplateChild("PART_ComboBoxList") as TouchListBox;
            _combobox_grid = GetTemplateChild("PART_combobox_grid") as Grid;
            _comboBoxCloseButton = GetTemplateChild("PART_comboboxCloseButton") as TouchIconButton;
            _calendar_grid = GetTemplateChild("PART_datepicker_grid") as Grid;
            _calendar = GetTemplateChild("PART_calendar") as TouchCalendar;
            _dialogBorder = GetTemplateChild("PART_dialogBorder") as Border;
            var gridDialogsMask = GetTemplateChild("PART_gridDialogsMask") as Grid;
            gridDialogsMask.MouseUp += GridDialogsMask_MouseUp;
            gridDialogsMask.MouseDown += GridDialogsMask_MouseDown;

            _comboBoxCloseButton.RegisterForPreviewMouseOrTouchUp(OnComboBoxClose);
            _combobox_grid.RegisterForMouseOrTouchDown(OnComboBoxGridDown);
            _calendar_grid.RegisterForMouseOrTouchDown(OnCalendarGridDown);

            _calendar.SelectionMode = CalendarSelectionMode.SingleDate;
            _calendar.SelectedDatesChanged += _calendar_SelectedDatesChanged;
        }

        private void GridDialogsMask_MouseDown(object sender, MouseButtonEventArgs e)
        {
            _isDialogGridMaskMouseDown = true;
        }

        private void GridDialogsMask_MouseUp(object sender, MouseButtonEventArgs e)
        {
            if (_isDialogGridMaskMouseDown)
            {
                if (e.Source == sender)
                {
                    try
                    {
                        if ((CurrentDialog.DataContext as DialogViewVM).CanClose)
                        {
                            (CurrentDialog.DataContext as DialogViewVM).CloseCommand?.Execute(null);
                        }
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"Error in touch panel {ex.ToString()}");
                    }
                }
            }

            _isDialogGridMaskMouseDown = false;
        }

        private void _calendar_SelectedDatesChanged(object sender, SelectionChangedEventArgs e)
        {
            Mouse.Capture(null);
            ReleaseAllTouchCaptures();
        }

        private void OnCalendarGridDown(object sender, MouseOrTouchEventArgs e)
        {
            if (e.Source == _calendar_grid)
            {
                CurrentDatePicker = null;
            }
        }

        private void OnComboBoxGridDown(object sender, MouseOrTouchEventArgs e)
        {
            if (e.Source == _combobox_grid)
            {
                CurrentComboBox = null;
            }
        }

        private void OnComboBoxClose(object sender, MouseOrTouchEventArgs e)
        {
            CurrentComboBox = null;
        }

        private async void OnCurrentComboBoxChanged()
        {
            if (CurrentComboBox != null)
            {
                await Task.Delay(100);
                if (CurrentComboBox != null)
                {
                    if (CurrentComboBox.SelectedItem != null)
                    {
                        _combobox_list.ScrollToItem(CurrentComboBox.SelectedItem);
                    }
                    else
                    {
                        _combobox_list.ScrollViewer.ScrollToTop();
                    }
                }
            }
        }

        private void OnCurrentDatePickerChanged()
        {
            if (CurrentDatePicker != null)
            {
                _calendar.SelectedDate = CurrentDatePicker.SelectedDate;
                _calendar.DisplayDateStart = CurrentDatePicker.DisplayDateStart;
                _calendar.DisplayDateEnd = CurrentDatePicker.DisplayDateEnd;
            }
        }

        internal RelayCommand ComboBoxPickedCommand
        {
            get { return (RelayCommand)GetValue(ComboBoxPickedCommandProperty); }
            set { SetValue(ComboBoxPickedCommandProperty, value); }
        }
        internal static readonly DependencyProperty ComboBoxPickedCommandProperty =
            DependencyProperty.Register("ComboBoxPickedCommand", typeof(RelayCommand), typeof(TouchPanel), new PropertyMetadata(null));


        internal TouchComboBox CurrentComboBox
        {
            get { return (TouchComboBox)GetValue(CurrentComboBoxProperty); }
            set { SetValue(CurrentComboBoxProperty, value); }
        }
        internal static readonly DependencyProperty CurrentComboBoxProperty =
            DependencyProperty.Register("CurrentComboBox", typeof(TouchComboBox), typeof(TouchPanel), new PropertyMetadata(null, (d, e) => (d as TouchPanel).OnCurrentComboBoxChanged()));

        internal TouchDatePicker CurrentDatePicker
        {
            get { return (TouchDatePicker)GetValue(CurrentDatePickerProperty); }
            set { SetValue(CurrentDatePickerProperty, value); }
        }
        internal static readonly DependencyProperty CurrentDatePickerProperty =
            DependencyProperty.Register("CurrentDatePicker", typeof(TouchDatePicker), typeof(TouchPanel), new PropertyMetadata(null, (d, e) => (d as TouchPanel).OnCurrentDatePickerChanged()));

        internal RelayCommand DateSelectedCommand
        {
            get { return (RelayCommand)GetValue(DateSelectedCommandProperty); }
            set { SetValue(DateSelectedCommandProperty, value); }
        }
        internal static readonly DependencyProperty DateSelectedCommandProperty =
            DependencyProperty.Register("DateSelectedCommand", typeof(RelayCommand), typeof(TouchPanel), new PropertyMetadata(null));

        internal RelayCommand CancelDateCommand
        {
            get { return (RelayCommand)GetValue(CancelDateCommandProperty); }
            set { SetValue(CancelDateCommandProperty, value); }
        }
        internal static readonly DependencyProperty CancelDateCommandProperty =
            DependencyProperty.Register("CancelDateCommand", typeof(RelayCommand), typeof(TouchPanel), new PropertyMetadata(null));



        public bool HasMessageBox
        {
            get { return (bool)GetValue(HasMessageBoxProperty); }
            set { SetValue(HasMessageBoxProperty, value); }
        }
        public static readonly DependencyProperty HasMessageBoxProperty =
            DependencyProperty.Register("HasMessageBox", typeof(bool), typeof(TouchPanel), new PropertyMetadata(false));

        public MessageBoxVM CurrentMessageBox
        {
            get { return (MessageBoxVM)GetValue(CurrentMessageBoxProperty); }
            set { SetValue(CurrentMessageBoxProperty, value); }
        }
        public static readonly DependencyProperty CurrentMessageBoxProperty =
            DependencyProperty.Register("CurrentMessageBox", typeof(MessageBoxVM), typeof(TouchPanel), new PropertyMetadata(null));

        public bool HasDialog
        {
            get { return (bool)GetValue(HasDialogProperty); }
            set { SetValue(HasDialogProperty, value); }
        }
        public static readonly DependencyProperty HasDialogProperty =
            DependencyProperty.Register("HasDialog", typeof(bool), typeof(TouchPanel), new PropertyMetadata(false));

        public FrameworkElement CurrentDialog
        {
            get { return (FrameworkElement)GetValue(CurrentDialogProperty); }
            set { SetValue(CurrentDialogProperty, value); }
        }
        public static readonly DependencyProperty CurrentDialogProperty =
            DependencyProperty.Register("CurrentDialog", typeof(FrameworkElement), typeof(TouchPanel), new PropertyMetadata(null,(d,e) => (d as TouchPanel).OnCurrentDialogChanged(e.NewValue as FrameworkElement)));

        public FrameworkElement TaskBarElement
        {
            get { return (FrameworkElement)GetValue(TaskBarElementProperty); }
            set { SetValue(TaskBarElementProperty, value); }
        }
        public static readonly DependencyProperty TaskBarElementProperty =
            DependencyProperty.Register("TaskBarElement", typeof(FrameworkElement), typeof(TouchPanel), new PropertyMetadata(null));

        public bool IsBusy
        {
            get { return (bool)GetValue(IsBusyProperty); }
            set { SetValue(IsBusyProperty, value); }
        }
        public static readonly DependencyProperty IsBusyProperty =
            DependencyProperty.Register("IsBusy", typeof(bool), typeof(TouchPanel), new PropertyMetadata(false));

        public String BusyMessage
        {
            get { return (String)GetValue(BusyMessageProperty); }
            set { SetValue(BusyMessageProperty, value); }
        }
        public static readonly DependencyProperty BusyMessageProperty =
            DependencyProperty.Register("BusyMessage", typeof(String), typeof(TouchPanel), new PropertyMetadata(null));

        protected virtual void OnCurrentDialogChanged(FrameworkElement frameworkElement)
        {
            
        }

        #region Attached Properties

        #region Prevent Focus Steal

        /// <summary>
        /// The prevent scroll property
        /// </summary>
        public static readonly DependencyProperty PreventFocusStealProperty =
            DependencyProperty.RegisterAttached("PreventFocusSteal",
            typeof(bool), typeof(TouchPanel),
            new FrameworkPropertyMetadata(false));

        /// <summary>
        /// Sets the PreventFocusSteal attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetPreventFocusSteal(FrameworkElement element, bool value)
        {
            element.SetValue(PreventFocusStealProperty, value);
        }

        /// <summary>
        /// Gets the PreventFocusSteal attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static bool GetPreventFocusSteal(FrameworkElement element)
        {
            if (element != null)
            {
                return (bool)element.GetValue(PreventFocusStealProperty);
            }
            else
            {
                return false;
            }
        }

        #endregion

        #endregion
    }
}