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.Core;
using Tango.PMR.Diagnostics;

namespace Tango.Integration.Operation
{
    /// <summary>
    /// Represents the default machine events state provider.
    /// </summary>
    /// <seealso cref="Tango.Integration.Operation.IMachineEventsStateProvider" />
    public class DefaultMachineEventsStateProvider : ExtendedObject, IMachineEventsStateProvider
    {
        private ReadOnlyObservableCollection<MachinesEvent> _events;
        /// <summary>
        /// Gets the current machine events.
        /// </summary>
        public ReadOnlyObservableCollection<MachinesEvent> Events
        {
            get
            {
                return _events;
            }
        }

        /// <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 DefaultMachineEventsStateProvider()
        {
            _events = new ReadOnlyObservableCollection<MachinesEvent>(new ObservableCollection<MachinesEvent>());
        }

        /// <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 = events.Select(x => new MachinesEvent(x)).ToList();

            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();

            _events = new ReadOnlyObservableCollection<MachinesEvent>(new ObservableCollection<MachinesEvent>(receivedEvents));

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

            if (newEvents.Count > 0 || oldEvents.Count > 0)
            {
                RaisePropertyChanged(nameof(Events));
                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>());
        }
    }
}