using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core;
using Tango.Core.DI;
using Tango.FSE.BL;
using Tango.FSE.Common.FSEApplication;
using Tango.FSE.Common.Notifications;
using Tango.Integration.Operation;
using Tango.PMR.Diagnostics;

namespace Tango.FSE.Common.Connection
{
    /// <summary>
    /// Represents the default machine events state provider.
    /// </summary>
    /// <seealso cref="Tango.Integration.Operation.IMachineEventsStateProvider" />
    public class FSEMachineEventsStateProvider : ExtendedObject, IMachineEventsStateProvider
    {
        private static Dictionary<EventTypes, Tango.BL.Entities.EventType> _eventTypesGuids;
        private bool _initialized;

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private FSEServicesContainer Services { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private INotificationProvider NotificationProvider { get; set; }

        private ReadOnlyObservableCollection<MachinesEvent> _events;
        /// <summary>
        /// Gets the current machine events.
        /// </summary>
        public ReadOnlyObservableCollection<MachinesEvent> Events
        {
            get
            {
                return _events;
            }
            private set
            {
                _events = value;
                RaisePropertyChangedAuto();
                RaisePropertyChanged(nameof(HasEvents));
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether this instance has events.
        /// </summary>
        public bool HasEvents
        {
            get
            {
                return Events.Count > 0;
            }
        }

        /// <summary>
        /// Occurs when new events are available.
        /// </summary>
        public event EventHandler<IEnumerable<MachinesEvent>> NewEvents;

        /// <summary>
        /// Occurs when a new events states has been received.
        /// </summary>
        public event EventHandler<IEnumerable<MachinesEvent>> EventsReceived;

        /// <summary>
        /// Occurs when old events has been resolved.
        /// </summary>
        public event EventHandler<IEnumerable<MachinesEvent>> EventsResolved;

        /// <summary>
        /// Occurs when the collection of current events has changed.
        /// </summary>
        public event EventHandler<IEnumerable<MachinesEvent>> EventsChanged;

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultMachineEventsStateProvider"/> class.
        /// </summary>
        public FSEMachineEventsStateProvider()
        {
            TangoIOC.Default.Inject(this);
            Events = new ReadOnlyObservableCollection<MachinesEvent>(new ObservableCollection<MachinesEvent>(new Collection<MachinesEvent>()));
        }

        /// <summary>
        /// Initializes this events state provider only if it was not initialized yet.
        /// Will retrieve all event types and perform caching and mapping between PMR and DB.
        /// </summary>
        public async void Init()
        {
            if (_initialized) return;

            _eventTypesGuids = new Dictionary<EventTypes, Tango.BL.Entities.EventType>();

            try
            {
                var eventTypes = await Services.MachineEventsService.GetAllEventTypes();

                foreach (var type in eventTypes)
                {
                    try
                    {
                        _eventTypesGuids.Add((EventTypes)type.Code, type);
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, $"Error initializing event type '{type.Name}'.");
                    }
                }

                _initialized = true;
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error initializing FSE machine events state provider.");
                NotificationProvider.PushErrorReportingSnackbar(ex, "Events Initialization", "Error initializing machine events definitions.");
            }
        }

        /// <summary>
        /// Applies the collection of events received from the machine operator.
        /// </summary>
        /// <param name="events">The events.</param>
        public void ApplyEvents(IEnumerable<Event> events)
        {
            List<MachinesEvent> receivedEvents = new List<MachinesEvent>();

            foreach (var ev in events)
            {
                MachinesEvent machineEvent = new MachinesEvent();

                machineEvent.DateTime = DateTime.UtcNow;
                machineEvent.Description = ev.Message;

                if (_eventTypesGuids.ContainsKey((EventTypes)ev.Type))
                {
                    machineEvent.EventType = _eventTypesGuids[(EventTypes)ev.Type];
                }
                else
                {
                    machineEvent.EventType = _eventTypesGuids[EventTypes.APPLICATION_INFORMATION];
                }

                receivedEvents.Add(machineEvent);
            }

            List<MachinesEvent> newEvents = receivedEvents.Where(x => !Events.ToList().Exists(y => y.Type == x.Type)).ToList();
            List<MachinesEvent> oldEvents = Events.Where(x => !receivedEvents.Exists(y => y.Type == x.Type)).ToList();

            List<MachinesEvent> activeEvents = Events.ToList();

            foreach (var oldEvent in oldEvents)
            {
                oldEvent.ResolvedDateTime = DateTime.UtcNow;
                activeEvents.Remove(oldEvent);
            }

            foreach (var newEvent in newEvents)
            {
                activeEvents.Add(newEvent);
            }

            Events = new ReadOnlyObservableCollection<MachinesEvent>(new ObservableCollection<MachinesEvent>(activeEvents));

            if (newEvents.Count > 0)
            {
                OnNewEvents(newEvents);
            }
            if (oldEvents.Count > 0)
            {
                OnEventsResolved(oldEvents);
            }

            if (newEvents.Count > 0 || oldEvents.Count > 0)
            {
                OnEventsChanged(_events);
            }

            OnEventsReceived(Events);

            RaisePropertyChanged(nameof(HasEvents));
        }

        /// <summary>
        /// Called when the new has been events
        /// </summary>
        /// <param name="events">The events.</param>
        protected virtual void OnNewEvents(IEnumerable<MachinesEvent> events)
        {
            NewEvents?.Invoke(this, events);
        }

        /// <summary>
        /// Called when the events has been received
        /// </summary>
        /// <param name="events">The events.</param>
        protected virtual void OnEventsReceived(IEnumerable<MachinesEvent> events)
        {
            EventsReceived?.Invoke(this, events);
        }

        /// <summary>
        /// Called when the events has been resolved
        /// </summary>
        /// <param name="events">The events.</param>
        protected virtual void OnEventsResolved(IEnumerable<MachinesEvent> events)
        {
            EventsResolved?.Invoke(this, events);
        }

        /// <summary>
        /// Called when the events has been changed
        /// </summary>
        /// <param name="events">The events.</param>
        protected virtual void OnEventsChanged(IEnumerable<MachinesEvent> events)
        {
            EventsChanged?.Invoke(this, events);
        }

        /// <summary>
        /// Resets the current events tracking.
        /// </summary>
        public void Reset()
        {
            Events = new ReadOnlyObservableCollection<MachinesEvent>(new ObservableCollection<MachinesEvent>(new List<MachinesEvent>()));
            RaisePropertyChanged(nameof(Events));
            OnEventsChanged(new List<MachinesEvent>());
        }
    }
}