using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;
using Tango.BL.Entities;
using Tango.Core;
using Tango.Core.DI;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.Events;
using Tango.FSE.Common.Navigation;
using Tango.FSE.Common.Notifications;
using Tango.FSE.Common.Threading;
using Tango.FSE.UI.ViewModels;
using Tango.FSE.UI.Views;
using Tango.PMR.Diagnostics;
using Tango.PPC.Shared.Events;

namespace Tango.FSE.UI.Events
{
    /// <summary>
    /// Represents the <see cref="IEventsProvider"/> default implementation.
    /// </summary>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    /// <seealso cref="Tango.FSE.Common.Events.IEventsProvider" />
    public class DefaultEventsProvider : ExtendedObject, IEventsProvider
    {
        private Dictionary<MachinesEvent, SnackbarItem> _snackbarItems;
        private const int MAX_HISTORY = 100;

        private IMachineProvider MachineProvider { get; set; }

        [TangoInject]
        private IDispatcherProvider Dispatcher { get; set; }

        [TangoInject]
        private INotificationProvider NotificationProvider { get; set; }

        private INavigationManager NavigationManager { get; set; }

        /// <summary>
        /// Gets or sets the events history (resolved events).
        /// </summary>
        public ObservableCollection<MachinesEvent> EventsHistory { get; set; }

        /// <summary>
        /// Gets or sets the current active events.
        /// </summary>
        public ObservableCollection<MachinesEvent> ActiveEvents { get; set; }

        /// <summary>
        /// Gets or sets the active events view.
        /// </summary>
        public ICollectionView ActiveEventsView { get; set; }

        /// <summary>
        /// Gets or sets the events history view.
        /// </summary>
        public ICollectionView EventsHistoryView { get; set; }

        /// <summary>
        /// Gets a value indicating whether there are any active events currently.
        /// </summary>
        public bool HasActiveEvents
        {
            get { return ActiveEvents.Count > 0; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultEventsProvider"/> class.
        /// </summary>
        /// <param name="machineProvider">The machine provider.</param>
        public DefaultEventsProvider(IMachineProvider machineProvider, INavigationManager navigationManager)
        {
            _snackbarItems = new Dictionary<MachinesEvent, SnackbarItem>();

            //Active Events.
            ActiveEvents = new ObservableCollection<MachinesEvent>();
            ActiveEvents.CollectionChanged += ActiveEvents_CollectionChanged;

            ActiveEventsView = CollectionViewSource.GetDefaultView(ActiveEvents);
            ActiveEventsView.SortDescriptions.Add(new SortDescription(nameof(MachinesEvent.Category), ListSortDirection.Descending));

            //Events History
            EventsHistory = new ObservableCollection<MachinesEvent>();

            EventsHistoryView = CollectionViewSource.GetDefaultView(EventsHistory);
            EventsHistoryView.SortDescriptions.Add(new SortDescription(nameof(MachinesEvent.DateTime), ListSortDirection.Descending));

            MachineProvider = machineProvider;
            MachineProvider.MachineOperator.MachineEventsStateProvider.NewEvents += MachineEventsStateProvider_NewEvents;
            MachineProvider.MachineOperator.MachineEventsStateProvider.EventsResolved += MachineEventsStateProvider_EventsResolved;
            MachineProvider.MachineDisconnected += MachineProvider_MachineDisconnected;
            MachineProvider.MachineConnected += MachineProvider_MachineConnected;

            NavigationManager = navigationManager;
            NavigationManager.Navigating += NavigationManager_Navigating;
        }

        private void NavigationManager_Navigating(object sender, NavigationToEventArgs e)
        {
            if (e.ToVM != null && e.ToVM.GetType() == typeof(EventsViewVM))
            {
                foreach (var item in _snackbarItems.ToList())
                {
                    NotificationProvider.PopSnackbarItem(item.Value);
                    _snackbarItems.Remove(item.Key);
                }
            }
        }

        private void MachineProvider_MachineConnected(object sender, MachineConnectedEventArgs e)
        {
            if (e.DifferentFromPrevious)
            {
                Dispatcher.Invoke(() =>
                {
                    EventsHistory.Clear();
                });
            }
        }

        private void MachineProvider_MachineDisconnected(object sender, MachineDisconnectedEventArgs e)
        {
            Dispatcher.Invoke(() =>
            {
                ActiveEvents.Clear();
            });
        }

        private void MachineEventsStateProvider_EventsResolved(object sender, IEnumerable<MachinesEvent> events)
        {
            Dispatcher.Invoke(() =>
            {
                foreach (var ev in events.ToList())
                {
                    if (!ev.EventType.Persistent)
                    {
                        ActiveEvents.Remove(ev);
                        EventsHistory.Insert(0, ev);
                    }

                    if (EventsHistory.Count > MAX_HISTORY)
                    {
                        EventsHistory.Remove(EventsHistory.Last());
                    }

                    if (!ev.EventType.Persistent)
                    {
                        if (_snackbarItems.ContainsKey(ev))
                        {
                            NotificationProvider.PopSnackbarItem(_snackbarItems[ev]);
                            _snackbarItems.Remove(ev);
                        }
                    }
                }
            });
        }

        private void MachineEventsStateProvider_NewEvents(object sender, IEnumerable<MachinesEvent> events)
        {
            Dispatcher.Invoke(() =>
            {
                foreach (var ev in events.ToList())
                {
                    if (!ev.EventType.Persistent)
                    {
                        ActiveEvents.Insert(0, ev);
                    }
                    else
                    {
                        EventsHistory.Insert(0, ev);
                    }

                    if (NavigationManager.CurrentVM != null && NavigationManager.CurrentVM.GetType() == typeof(EventsViewVM))
                    {
                        continue;
                    }

                    MessageType messageType = MessageType.Info;
                    TimeSpan timeout = TimeSpan.FromSeconds(10);

                    switch (ev.Category)
                    {
                        case Tango.BL.Enumerations.EventTypeCategories.Info:
                            messageType = MessageType.Info;
                            break;
                        case Tango.BL.Enumerations.EventTypeCategories.Warning:
                            messageType = MessageType.Warning;
                            break;
                        case Tango.BL.Enumerations.EventTypeCategories.Error:
                            messageType = MessageType.Error;
                            break;
                        case Tango.BL.Enumerations.EventTypeCategories.Critical:
                            messageType = MessageType.Error;
                            timeout = TimeSpan.FromSeconds(30);
                            break;
                        case Tango.BL.Enumerations.EventTypeCategories.Success:
                            messageType = MessageType.Success;
                            break;
                    }

                    var item = NotificationProvider.PushSnackbarItem(
                        messageType,
                        ev.EventType.GetEventText(Tango.BL.Entities.EventType.EventTextType.Title, MachineProvider.Machine),
                        true,
                        ev.EventType.Name + "\n" + ev.EventType.GetEventText(Tango.BL.Entities.EventType.EventTextType.Description, MachineProvider.Machine),
                        timeout,
                        null,
                        () =>
                        {
                            NavigationManager.NavigateWithObject<InternalModule, EventsView, EventsViewVM.NavigationObject>(new EventsViewVM.NavigationObject()
                            {
                                SelectedEvent = ev
                            });
                        });

                    _snackbarItems[ev] = item;
                }
            });
        }

        private void ActiveEvents_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            RaisePropertyChanged(nameof(HasActiveEvents));
        }

        public async Task PushEmulatedEvent(Event ev, TimeSpan timeout)
        {
            await MachineProvider.MachineOperator.SendGenericRequest<PushEmulatedEventRequest, PushEmulatedEventResponse>(new PushEmulatedEventRequest()
            {
                Event = ev,
                Timeout = timeout
            });
        }
    }
}