using Google.Protobuf;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core;
using Tango.Integration.ExternalBridge;
using Tango.PMR.Diagnostics;
using Tango.Integration.Operation;
using Tango.PPC.Common.Application;
using Tango.PPC.Common.Authentication;
using Tango.PPC.Common.Connection;
using Tango.Transport;
using Tango.PPC.Common.ExternalBridge;
using Tango.PPC.Shared.Events;
using Tango.Core.DI;

namespace Tango.PPC.Common.EventLogging
{
    /// <summary>
    /// Represents the default database events logger.
    /// </summary>
    /// <seealso cref="IEventLogger" />
    public class DefaultEventLogger : ExtendedObject, IEventLogger
    {
        private ObservablesContext _db;
        private Thread _logThread;
        private ConcurrentQueue<MachinesEvent> _events;
        private IMachineProvider _machineProvider;
        private IAuthenticationProvider _authentication;
        private Dictionary<EventTypes, BL.Entities.EventType> _eventTypesGuids;
        private String _hostName;
        private bool _isInitialized;
        private List<MachinesEvent> _pendingEvents;
        private List<MachinesEvent> _currentEvents;
        private Machine _machine;

        #region Events

        /// <summary>
        /// Occurs when a new machine event has been received.
        /// </summary>
        public event EventHandler<MachinesEvent> EventReceived;

        /// <summary>
        /// Occurs when a machine event has been resolved.
        /// </summary>
        public event EventHandler<MachinesEvent> EventResolved;

        #endregion

        private IPPCExternalBridgeService _externalBridge;
        [TangoInject(Mode = TangoInjectMode.WhenAvailable)]
        public IPPCExternalBridgeService ExternalBridgeService
        {
            get { return _externalBridge; }
            set
            {
                if (_externalBridge != value)
                {
                    _externalBridge = value;
                    _externalBridge.RegisterRequestHandler(this);
                }
            }
        }

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultEventLogger"/> class.
        /// </summary>
        /// <param name="machineProvider">The application manager.</param>
        /// <param name="authenticationProvider">The authentication provider.</param>
        public DefaultEventLogger(IMachineProvider machineProvider, IAuthenticationProvider authenticationProvider)
        {
            _hostName = Environment.MachineName;

            _events = new ConcurrentQueue<MachinesEvent>();
            _pendingEvents = new List<MachinesEvent>();
            _currentEvents = new List<MachinesEvent>();

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

            _machineProvider = machineProvider;
            _authentication = authenticationProvider;
            _logThread = new Thread(LogThreadMethod);
            _logThread.IsBackground = true;
            _logThread.Start();

            _machineProvider.MachineOperator.MachineEventsStateProvider.NewEvents += MachineEventsStateProvider_NewEvents;
            _machineProvider.MachineOperator.MachineEventsStateProvider.EventsResolved += MachineEventsStateProvider_EventsResolved;

            _machineProvider.MachineOperator.RequestSent += Machine_RequestSent;
            _machineProvider.MachineOperator.RequestFailed += Machine_RequestFailed;
            _machineProvider.MachineOperator.ResponseReceived += Machine_ResponseReceived;
            _machineProvider.MachineOperator.StateChanged += MachineOperator_StateChanged;
            _machineProvider.MachineOperator.PrintingStarted += MachineOperator_PrintingStarted;
            _machineProvider.MachineOperator.PrintingAborted += MachineOperator_PrintingAborted;
            _machineProvider.MachineOperator.PrintingCompleted += MachineOperator_PrintingCompleted;
            _machineProvider.MachineOperator.PrintingFailed += MachineOperator_PrintingFailed;
        }

        #endregion

        #region Private Methods

        private void Init()
        {
            if (!_isInitialized)
            {
                try
                {
                    _db = ObservablesContext.CreateDefault();

                    _machine = _db.Machines.FirstOrDefault();

                    _db.EventTypes.ToList();

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

                    _isInitialized = true;
                }
                catch (Exception ex)
                {
                    _isInitialized = false;
                    LogManager.Log(ex, "Error initializing event types.");
                }
            }
        }

        #endregion

        #region Event Handlers

        /// <summary>
        /// Handles the PrintingFailed event of the MachineOperator.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="PrintingFailedEventArgs"/> instance containing the event data.</param>
        private void MachineOperator_PrintingFailed(object sender, PrintingFailedEventArgs e)
        {
            EventTypes? relatedEventType = null;

            if (e.Exception is Transport.ResponseErrorException responseError)
            {
                if (responseError.Container.EventCode > 0)
                {
                    relatedEventType = (EventTypes)responseError.Container.EventCode;
                }
            }

            Log(EventTypes.JOB_FAILED, e.Exception.Message, relatedEventType);
        }

        /// <summary>
        /// Handles the PrintingCompleted event of the MachineOperator.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="PrintingEventArgs"/> instance containing the event data.</param>
        private void MachineOperator_PrintingCompleted(object sender, PrintingEventArgs e)
        {
            Log(EventTypes.JOB_COMPLETED, $"Job '{e.Job.Name}' completed successfully.");
        }

        /// <summary>
        /// Handles the PrintingAborted event of the MachineOperator.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="PrintingEventArgs"/> instance containing the event data.</param>
        private void MachineOperator_PrintingAborted(object sender, PrintingEventArgs e)
        {
            Log(EventTypes.JOB_ABORTED, $"Job '{e.Job.Name}' has been aborted.");
        }

        /// <summary>
        /// Handles the PrintingStarted event of the MachineOperator.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="PrintingEventArgs"/> instance containing the event data.</param>
        private void MachineOperator_PrintingStarted(object sender, PrintingEventArgs e)
        {
            Log(EventTypes.JOB_STARTED, $"Job '{e.Job.Name}' started.");
        }

        /// <summary>
        /// Handles the machine operator state changed event.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The e.</param>
        private void MachineOperator_StateChanged(object sender, Transport.TransportComponentState e)
        {
            if (e == Transport.TransportComponentState.Connected)
            {
                _events = new ConcurrentQueue<MachinesEvent>();
                _currentEvents.Clear();
            }
        }

        /// <summary>
        /// Handles the RequestSent event of the connected machine.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="message">The message.</param>
        private void Machine_RequestSent(object sender, IMessage message)
        {
            //Log(EventTypes.REQUEST_SENT, String.Format("Sending request '{0}'...{1}{2}", message.GetType().Name, Environment.NewLine, message.ToJsonString()));
        }

        /// <summary>
        /// Handles the RequestFailed event of the connected machine.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RequestFailedEventArgs"/> instance containing the event data.</param>
        private void Machine_RequestFailed(object sender, RequestFailedEventArgs e)
        {
            //Log(EventTypes.REQUEST_FAILED, String.Format("Request failed '{0}'...{1}{2}{1}{3}", e.Message.GetType().Name, Environment.NewLine, e.Message.ToJsonString(), e.Exception.ToString()));
        }

        /// <summary>
        /// Handles the ResponseReceived event of the connected machine.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="message">The message.</param>
        private void Machine_ResponseReceived(object sender, IMessage message)
        {
            //Log(EventTypes.RESPONSE_RECEIVED, String.Format("Response received '{0}'...{1}{2}", message.GetType().Name, Environment.NewLine, message.ToJsonString()));
        }

        /// <summary>
        /// Handles the connected machine events state provider NewEvents event.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="events">The events.</param>
        private void MachineEventsStateProvider_NewEvents(object sender, IEnumerable<MachinesEvent> events)
        {
            foreach (var ev in events)
            {
                Log(ev);
            }
        }

        /// <summary>
        /// Handles the connected machine events state provider EventsResolved event.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="events">The events.</param>
        private void MachineEventsStateProvider_EventsResolved(object sender, IEnumerable<MachinesEvent> events)
        {
            foreach (var ev in events)
            {
                //Log(String.Format("Event '{0}' resolved.", ev.EventType.Name));

                var existing = _currentEvents.SingleOrDefault(x => x.Type == ev.Type);

                if (existing != null)
                {
                    _currentEvents.Remove(existing);
                    EventResolved?.Invoke(this, existing);
                }
            }
        }

        #endregion

        #region Logging

        /// <summary>
        /// Logs the specified machine event.
        /// </summary>
        /// <param name="machineEvent">The machine event.</param>
        public void Log(MachinesEvent machineEvent)
        {
            machineEvent.HostName = _hostName;
            machineEvent.EventType = _eventTypesGuids[machineEvent.Type];

            if (_machine == null)
            {
                _pendingEvents.Add(machineEvent);
            }
            else
            {
                if (_pendingEvents.Count > 0)
                {
                    var pending = _pendingEvents.ToList();
                    _pendingEvents.Clear();

                    foreach (var ev in pending)
                    {
                        Log(ev);
                    }
                }

                LogManager.Log("Logging event " + machineEvent.EventType.Name);
                machineEvent.MachineGuid = _machine.Guid;
                machineEvent.UserGuid = null;
                machineEvent.User = null;
                _events.Enqueue(machineEvent);

                if (!_currentEvents.Exists(x => x.Type == machineEvent.Type))
                {
                    if (machineEvent.Group != EventTypeGroups.Application && machineEvent.Group != EventTypeGroups.Transport && machineEvent.Group != EventTypeGroups.Jobs)
                    {
                        _currentEvents.Add(machineEvent);
                    }
                }

                EventReceived?.Invoke(this, machineEvent);
            }
        }

        /// <summary>
        /// Logs the specified event type.
        /// </summary>
        /// <param name="eventType">Type of the event.</param>
        /// <param name="message">The message.</param>
        public void Log(EventTypes eventType, string message, EventTypes? relatedEventType = null)
        {
            Init();

            MachinesEvent machineEvent = new MachinesEvent();
            machineEvent.DateTime = DateTime.UtcNow;
            machineEvent.Description = message;
            machineEvent.EventType = _eventTypesGuids[eventType];
            machineEvent.EventTypeGuid = machineEvent.EventType.Guid;

            if (relatedEventType != null)
            {
                machineEvent.RelatedEventType = _eventTypesGuids[relatedEventType.Value];
            }

            Log(machineEvent);
        }

        /// <summary>
        /// Logs the specified hardware event.
        /// </summary>
        /// <param name="hardwareEvent">The hardware event.</param>
        public void Log(Event hardwareEvent)
        {
            Log((EventTypes)hardwareEvent.Type, hardwareEvent.Message);
        }

        /// <summary>
        /// Logs the specified exception using the <see cref="EventTypes.ApplicationException"/>.
        /// </summary>
        /// <param name="exception">The exception.</param>
        public void Log(Exception exception)
        {
            Log(EventTypes.APPLICATION_EXCEPTION, exception.FlattenMessage());
        }

        /// <summary>
        /// Logs the specified exception using the <see cref="EventTypes.ApplicationException" />.
        /// </summary>
        /// <param name="exception">The exception.</param>
        /// <param name="description"></param>
        public void Log(Exception exception, string description)
        {
            Log(EventTypes.APPLICATION_EXCEPTION, description + Environment.NewLine + exception.FlattenMessage());
        }

        /// <summary>
        /// Logs the specified message using the <see cref="EventTypes.ApplicationInformation"/>.
        /// </summary>
        /// <param name="message">The message.</param>
        public void Log(String message)
        {
            Log(EventTypes.APPLICATION_INFORMATION, message);
        }

        /// <summary>
        /// Logging thread loop.
        /// </summary>
        private void LogThreadMethod()
        {
            while (true)
            {
                FlushAll();
                Thread.Sleep(5000);
            }
        }

        /// <summary>
        /// Immediately saves all pending events to database.
        /// </summary>
        public void FlushAll()
        {
            bool _saveChanges = false;

            while (_events.Count > 0)
            {
                MachinesEvent ev = null;

                if (_events.TryDequeue(out ev))
                {
                    ev.User = null;
                    _db.MachinesEvents.Add(ev);
                    _saveChanges = true;
                }
            }

            if (_saveChanges)
            {
                try
                {
                    _db.SaveChanges();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error saving machine event to database.");
                }
            }
        }

        #endregion

        #region External Bridge Handler

        [ExternalBridgeRequestHandlerMethod(typeof(PushEmulatedEventRequest), RequestHandlerLoggingMode.LogRequestNameAndContent)]
        public async Task OnStartPerformanceUpdatesRequest(PushEmulatedEventRequest request, String token, ExternalBridgeReceiver receiver)
        {
            _machineProvider.MachineOperator.PushEmulatedEvent(request.Event, request.Timeout);
            await receiver.SendGenericResponse(new PushEmulatedEventResponse(), token);
        }

        public void OnReceiverDisconnected(ExternalBridgeReceiver receiver)
        {

        }

        #endregion
    }
}