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.Logging;
using Tango.MachineStudio.Common.Authentication;
using Tango.MachineStudio.Common.Diagnostics;
using Tango.MachineStudio.Common.StudioApplication;
using Tango.PMR.Diagnostics;
using Tango.Integration.Operation;
using Tango.Core.ExtensionMethods;
using Tango.Transport;

namespace Tango.MachineStudio.Common.EventLogging
{
    /// <summary>
    /// Represents the default database events logger.
    /// </summary>
    /// <seealso cref="IEventLogger" />
    public class DefaultEventLogger : ExtendedObject, IEventLogger
    {
        private ObservablesContext _db;
        private static object _lockInit = new object();
        private Thread _logThread;
        private ConcurrentQueue<MachinesEvent> _events;
        private IStudioApplicationManager _application;
        private IAuthenticationProvider _authentication;
        private Dictionary<EventTypes, BL.Entities.EventType> _eventTypesGuids;
        private String _hostName;
        private bool _isInitialized;
        private List<MachinesEvent> _pendingEvents;

        #region Events

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

        #endregion

        #region Properties

        /// <summary>
        /// Gets or sets a value indicating whether to save the incoming events to database.
        /// </summary>
        public bool SaveToDB { get; set; }

        #endregion

        #region Constructors

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

            SaveToDB = true;

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

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

            _application = applicationManager;
            _authentication = authenticationProvider;
            _logThread = new Thread(LogThreadMethod);
            _logThread.IsBackground = true;
            _logThread.Start();

            _application.ConnectedMachineChanged += _application_ConnectedMachineChanged;
        }

        #endregion

        #region Private Methods

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

                        _db.EventTypes.ToList();

                        foreach (var type in _db.EventTypes)
                        {
                            _eventTypesGuids.Add((EventTypes)type.Code, type);
                        }

                        _isInitialized = true;
                    }
                    catch
                    {
                        _isInitialized = false;
                    }
                }
            }
        }

        #endregion

        #region Event Handlers

        /// <summary>
        /// Handle the application manager connected machine changed event.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="machine">The machine.</param>
        private void _application_ConnectedMachineChanged(object sender, IExternalBridgeClient machine)
        {
            if (machine != null)
            {
                if (machine.MachineEventsStateProvider != null)
                {
                    machine.MachineEventsStateProvider.NewEvents -= MachineEventsStateProvider_NewEvents;
                    machine.MachineEventsStateProvider.NewEvents += MachineEventsStateProvider_NewEvents;
                    machine.MachineEventsStateProvider.EventsResolved -= MachineEventsStateProvider_EventsResolved;
                    machine.MachineEventsStateProvider.EventsResolved += MachineEventsStateProvider_EventsResolved;
                }

                machine.RequestSent -= Machine_RequestSent;
                machine.RequestFailed -= Machine_RequestFailed;
                machine.ResponseReceived -= Machine_ResponseReceived;

                machine.RequestSent += Machine_RequestSent;
                machine.RequestFailed += Machine_RequestFailed;
                machine.ResponseReceived += Machine_ResponseReceived;

                SaveToDB = !(machine is IExternalBridgeSecureClient);
            }
        }

        /// <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));
            //}
        }

        #endregion

        #region Logging

        /// <summary>
        /// Logs the specified machine event.
        /// </summary>
        /// <param name="machineEvent">The machine event.</param>
        public void Log(MachinesEvent machineEvent)
        {
            Init();

            machineEvent.HostName = _hostName;
            machineEvent.EventType = _eventTypesGuids[machineEvent.Type];

            if (_application.ConnectedMachine == null || _authentication.CurrentUser == null)
            {
                _pendingEvents.Add(machineEvent);
            }
            else
            {
                lock (_pendingEvents)
                {
                    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 = _application.Machine.Guid;
                machineEvent.UserGuid = _authentication.CurrentUser.Guid;
                machineEvent.User = _authentication.CurrentUser;
                _events.Enqueue(machineEvent);
                NewLog?.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, bool write_to_db = true)
        {
            Init();

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

            if (write_to_db && SaveToDB)
            {
                Log(machineEvent);
            }
            else
            {
                NewLog?.Invoke(this, 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.ToString());
        }

        /// <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.ToString());
        }

        /// <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()
        {
            if (!SaveToDB)
            {
                return;
            }

            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
    }
}