using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.PPC.Common;
using Tango.PPC.Common.Notifications;
using Tango.PPC.Common.Notifications.NotificationItems;
using Tango.PPC.Events.Enumerations;
using System.Data.Entity;
using Tango.Integration.Operation;

namespace Tango.PPC.Events.ViewModels
{
    /// <summary>
    /// Represents the main view VM and entry point for <see cref="Events.EventsModule"/>.
    /// </summary>
    /// <seealso cref="Tango.PPC.Common.PPCViewModel" />
    public class MainViewVM : PPCViewModel
    {
        private List<KeyValuePair<EventTypes, NotificationItem>> _notifications;

        private EventsSource _selectedEventsSource;
        public EventsSource SelectedEventsSource
        {
            get { return _selectedEventsSource; }
            set { _selectedEventsSource = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<MachinesEvent> _currentEvents;
        /// <summary>
        /// Gets or sets the current events.
        /// </summary>
        public ObservableCollection<MachinesEvent> CurrentEvents
        {
            get { return _currentEvents; }
            set { _currentEvents = value; RaisePropertyChangedAuto(); }
        }

        private MachinesEvent _selectedEvent;
        /// <summary>
        /// Gets or sets the selected event.
        /// </summary>
        public MachinesEvent SelectedEvent
        {
            get { return _selectedEvent; }
            set { _selectedEvent = value; RaisePropertyChangedAuto(); }
        }


        private ObservableCollection<MachinesEvent> _historyEvents;
        /// <summary>
        /// Gets or sets the history events.
        /// </summary>
        public ObservableCollection<MachinesEvent> HistoryEvents
        {
            get { return _historyEvents; }
            set { _historyEvents = value; RaisePropertyChangedAuto(); }
        }

        private MachinesEvent _selectedHistoryEvent;
        /// <summary>
        /// Gets or sets the selected event.
        /// </summary>
        public MachinesEvent SelectedHistoryEvent
        {
            get { return _selectedHistoryEvent; }
            set { _selectedHistoryEvent = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MainViewVM"/> class.
        /// </summary>
        public MainViewVM()
        {
            CurrentEvents = new ObservableCollection<MachinesEvent>();
            _notifications = new List<KeyValuePair<EventTypes, NotificationItem>>();
        }

        /// <summary>
        /// Called when the application has been started
        /// </summary>
        public override void OnApplicationStarted()
        {
            EventLogger.EventReceived += EventLogger_EventReceived;
            EventLogger.EventResolved += EventLogger_EventResolved;
        }

        public override async void OnApplicationReady()
        {
            base.OnApplicationReady();

            using (var db = ObservablesContext.CreateDefault())
            {
                var last_week = DateTime.UtcNow.AddDays(-7);
                HistoryEvents = (await db.MachinesEvents.Where(x => x.MachineGuid == MachineProvider.Machine.Guid && x.DateTime > last_week).Take(100).Include(x => x.EventType).Where(x => (EventTypeNotificationTimes)x.EventType.EventNotificationTime != EventTypeNotificationTimes.None || x.EventType.Code == (int)EventTypes.JOB_FAILED || x.EventType.Code == (int)EventTypes.JOB_STARTED || x.EventType.Code == (int)EventTypes.JOB_COMPLETED || x.EventType.Code == (int)EventTypes.JOB_ABORTED).ToListAsync()).OrderByDescending(x => x.DateTime).ToObservableCollection();
            }

            MachineProvider.MachineOperator.StatusChanged += MachineOperator_StatusChanged;
        }

        private void MachineOperator_StatusChanged(object sender, MachineStatuses status)
        {
            if (status == MachineStatuses.Disconnected)
            {
                foreach (var notification in _notifications.ToList())
                {
                    NotificationProvider.PopNotification(notification.Value);
                }

                _notifications.Clear();

                InvokeUI(() =>
                {
                    CurrentEvents.Clear();
                });
            }
        }

        private void EventLogger_EventReceived(object sender, MachinesEvent ev)
        {
            InvokeUI(() =>
            {
                if (ev.NotificationTime != EventTypeNotificationTimes.None)
                {
                    if (!ev.EventType.Persistent)
                    {
                        CurrentEvents.Insert(0, ev);
                    }
                    else
                    {
                        HistoryEvents.Insert(0, ev);
                    }

                    var notificationItem = new MessageNotificationItem();
                    notificationItem.CanClose = ev.EventType.Persistent;
                    notificationItem.Message = ev.EventType.GetEventText(EventType.EventTextType.Title, MachineProvider.Machine);
                    notificationItem.ExpandedMessage = ev.EventType.GetEventText(EventType.EventTextType.Description, MachineProvider.Machine);
                    notificationItem.Pressed += async (_, __) =>
                    {
                        if (!ev.EventType.Persistent)
                        {
                            SelectedEventsSource = EventsSource.CURRENT;
                        }
                        else
                        {
                            SelectedEventsSource = EventsSource.HISTORY;
                            notificationItem.Dispose();
                        }

                        SelectedEvent = ev;
                        await NavigationManager.NavigateTo<EventsModule>();
                    };

                    switch (ev.Category)
                    {
                        case EventTypeCategories.Info:
                            notificationItem.MessageType = MessageNotificationItem.MessageNotificationItemTypes.Info;
                            notificationItem.Priority = NotificationItem.NotificationPriority.Normal;
                            break;
                        case EventTypeCategories.Warning:
                            notificationItem.MessageType = MessageNotificationItem.MessageNotificationItemTypes.Warning;
                            notificationItem.Priority = NotificationItem.NotificationPriority.High;
                            break;
                        case EventTypeCategories.Error:
                            notificationItem.MessageType = MessageNotificationItem.MessageNotificationItemTypes.Error;
                            notificationItem.Priority = NotificationItem.NotificationPriority.VeryHigh;
                            break;
                        case EventTypeCategories.Critical:
                            notificationItem.MessageType = MessageNotificationItem.MessageNotificationItemTypes.Critical;
                            notificationItem.Priority = NotificationItem.NotificationPriority.Critical;
                            break;
                        case EventTypeCategories.Success:
                            notificationItem.MessageType = MessageNotificationItem.MessageNotificationItemTypes.Success;
                            notificationItem.Priority = NotificationItem.NotificationPriority.VeryHigh;
                            break;
                    }

                    NotificationProvider.PushNotification(notificationItem);
                    _notifications.Add(new KeyValuePair<EventTypes, NotificationItem>(ev.EventType.Type, notificationItem));

                }
                else if (ev.IsJobProgressEvent())
                {
                    HistoryEvents.Insert(0, ev);
                }
            });
        }

        private void EventLogger_EventResolved(object sender, MachinesEvent ev)
        {
            InvokeUI(() =>
            {
                if (ev.NotificationTime != EventTypeNotificationTimes.None && !ev.EventType.Persistent)
                {
                    CurrentEvents.Remove(ev);
                    HistoryEvents.Insert(0, ev);

                    foreach (var item in _notifications.ToList().Where(x => x.Key == ev.EventType.Type))
                    {
                        _notifications.Remove(item);
                        NotificationProvider.PopNotification(item.Value);
                    }

                    if (HistoryEvents.Count > 100)
                    {
                        HistoryEvents.Remove(HistoryEvents.Last());
                    }
                }
            });
        }

        public override void OnNavigatedTo()
        {
            base.OnNavigatedTo();
            NotificationProvider.NotificationsVisible = false;
        }

        public override void OnNavigatedFrom()
        {
            base.OnNavigatedFrom();
            NotificationProvider.NotificationsVisible = true;
        }
    }
}