//******************************************************************************************************
//  AlarmStatusQuery.cs - Gbtc
//
//  Copyright © 2013, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  05/16/2013 - J. Ritchie Carroll
//       Generated original version of source code.
//
//******************************************************************************************************

using System;
using System.Collections.Generic;
using System.Threading;
using GSF.Communication;
using GSF.Console;
using GSF.ServiceProcess;
using GSF.Threading;

namespace GSF.TimeSeries.UI
{
    /// <summary>
    /// Represents as object that will query current alarm state.
    /// </summary>
    public class AlarmStatusQuery : IDisposable
    {
        #region [ Members ]

        // Constants

        /// <summary>
        /// Default value for <see cref="ResponseTimeout"/>.
        /// </summary>
        public const int DefaultResponseTimeout = 20000; // Default to waiting twenty seconds, could be lots of alarms

        // Events

        /// <summary>
        /// Provides collection containing raised alarms with the highest severity for each signal in the system.
        /// </summary>
        /// <remarks>
        /// <see cref="EventArgs{T}.Argument"/> is a collection of the current high-severity <see cref="Alarm"/> states.
        /// </remarks>
        public event EventHandler<EventArgs<ICollection<Alarm>>> RaisedAlarmStates;

        /// <summary>
        /// Event is raised when there is an exception encountered while processing.
        /// </summary>
        /// <remarks>
        /// <see cref="EventArgs{T}.Argument"/> is the exception that was thrown.
        /// </remarks>
        public event EventHandler<EventArgs<Exception>> ProcessException;

        // Fields
        private WindowsServiceClient m_serviceClient;
        private ICollection<Alarm> m_raisedAlarms;
        private readonly LongSynchronizedOperation m_alarmStateQueryOperation;
        private AutoResetEvent m_responseComplete;
        private int m_responseTimeout;
        private bool m_connectedToService;
        private bool m_disposed;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new <see cref="AlarmStatusQuery"/>.
        /// </summary>
        public AlarmStatusQuery()
        {
            // Attach to service connected events
            CommonFunctions.ServiceConnectionRefreshed += CommonFunctions_ServiceConnectionRefreshed;

            // Determine initial state of connectivity
            UpdateServiceConnectivity();

            m_alarmStateQueryOperation = new LongSynchronizedOperation(ExecuteAlarmStateQuery)
            {
                IsBackground = true
            };
            m_responseComplete = new AutoResetEvent(false);
            m_responseTimeout = DefaultResponseTimeout;
        }

        /// <summary>
        /// Releases the unmanaged resources before the <see cref="AlarmStatusQuery"/> object is reclaimed by <see cref="GC"/>.
        /// </summary>
        ~AlarmStatusQuery()
        {
            Dispose(false);
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets or sets allowed timeout, in milliseconds, for a command request response.
        /// </summary>
        public int ResponseTimeout
        {
            get
            {
                return m_responseTimeout;
            }
            set
            {
                m_responseTimeout = value;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Releases all the resources used by the <see cref="AlarmStatusQuery"/> object.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Releases the unmanaged resources used by the <see cref="AlarmStatusQuery"/> object and optionally releases the managed resources.
        /// </summary>
        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (!m_disposed)
            {
                try
                {
                    if (disposing)
                    {
                        if ((object)m_serviceClient != null && (object)m_serviceClient.Helper != null)
                            m_serviceClient.Helper.ReceivedServiceResponse -= Helper_ReceivedServiceResponse;

                        m_serviceClient = null;

                        if ((object)m_responseComplete != null)
                        {
                            // Release any waiting threads before disposing wait handle
                            m_responseComplete.Set();
                            m_responseComplete.Dispose();
                        }

                        m_responseComplete = null;

                        // Detach from service connected events
                        CommonFunctions.ServiceConnectionRefreshed -= CommonFunctions_ServiceConnectionRefreshed;
                    }
                }
                finally
                {
                    m_disposed = true;  // Prevent duplicate dispose.
                }
            }
        }

        private void UpdateServiceConnectivity(bool refreshRaisedAlarms = false)
        {
            // Detach from original service response if refreshing service connection
            if ((object)m_serviceClient != null && (object)m_serviceClient.Helper != null)
                m_serviceClient.Helper.ReceivedServiceResponse -= Helper_ReceivedServiceResponse;

            // Get new service client
            m_serviceClient = CommonFunctions.GetWindowsServiceClient();
            ClientHelper clientHelper = ((object)m_serviceClient != null) ? m_serviceClient.Helper : null;
            IClient remotingClient = ((object)clientHelper != null) ? clientHelper.RemotingClient : null;

            if ((object)clientHelper != null)
                clientHelper.ReceivedServiceResponse += Helper_ReceivedServiceResponse;

            if ((object)remotingClient == null || remotingClient.CurrentState != ClientState.Connected)
            {
                // Remoting client is not connected to service
                m_connectedToService = false;

                // Release any waiting threads if service has been disconnected
                if ((object)m_responseComplete != null)
                    m_responseComplete.Set();
            }
            else
            {
                // If remoting client is connected, refresh raised alarms if requested and attach to connection terminated event
                m_connectedToService = true;

                if (refreshRaisedAlarms)
                    RequestRaisedAlarmStates();

                remotingClient.ConnectionTerminated += RemotingClient_ConnectionTerminated;
            }
        }

        private void CommonFunctions_ServiceConnectionRefreshed(object sender, EventArgs eventArgs)
        {
            // Determine new state of connectivity - since we are reconnecting and this could be to a
            // new node an/or a restarted system, re-request raised alarm states
            UpdateServiceConnectivity(true);
        }

        private void RemotingClient_ConnectionTerminated(object sender, EventArgs eventArgs)
        {
            IClient remotingClient = sender as IClient;

            // Attempt to detach from the event that just occurred
            if ((object)remotingClient != null)
                remotingClient.ConnectionTerminated -= RemotingClient_ConnectionTerminated;

            // Determine new state of connectivity
            UpdateServiceConnectivity();
        }

        /// <summary>
        /// Requests the current state of highest severity alarms.
        /// </summary>
        public void RequestRaisedAlarmStates()
        {
            // Create single item operation queue so that
            // multiple requests will be handled one at a time
            m_alarmStateQueryOperation.RunOnceAsync();
        }

        // Execute alarm state query
        private void ExecuteAlarmStateQuery()
        {
            // Nothing to do if not connected to service
            if (!m_connectedToService)
                return;

            try
            {
                // Clear any existing raised alarms
                m_raisedAlarms = null;

                // Reset state of response complete event (in case a prior event set never completed)
                if ((object)m_responseComplete != null)
                    m_responseComplete.Reset();

                // Send command to alarm services to get highest severity alarms
                CommonFunctions.SendCommandToService("INVOKE ALARM!SERVICES GetRaisedAlarms");

                // Wait for command response allowing for processing time
                if ((object)m_responseComplete != null)
                {
                    if (!m_responseComplete.WaitOne(m_responseTimeout))
                        OnProcessException(new TimeoutException(string.Format("Timed-out after {0} seconds waiting for service response{1}.", (m_responseTimeout / 1000.0D).ToString("0.00"), m_connectedToService ? "" : " - service is disconnected")));
                }

                // If alarms were returned, expose them to consumer
                if ((object)m_raisedAlarms != null)
                    OnRaisedAlarmStates(m_raisedAlarms);
            }
            catch (Exception ex)
            {
                OnProcessException(new InvalidOperationException("Alarm state query error: " + ex.Message, ex));
            }
        }

        /// <summary>
        /// Raises <see cref="RaisedAlarmStates"/> event.
        /// </summary>
        /// <param name="raisedAlarms">Alarm states.</param>
        protected virtual void OnRaisedAlarmStates(ICollection<Alarm> raisedAlarms)
        {
            if ((object)RaisedAlarmStates != null)
                RaisedAlarmStates(this, new EventArgs<ICollection<Alarm>>(raisedAlarms));
        }

        /// <summary>
        /// Raises <see cref="ProcessException"/> event.
        /// </summary>
        /// <param name="ex">Processing <see cref="Exception"/>.</param>
        protected virtual void OnProcessException(Exception ex)
        {
            if ((object)ProcessException != null)
                ProcessException(this, new EventArgs<Exception>(ex));
        }

        /// <summary>
        /// Handles ReceivedServiceResponse event.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void Helper_ReceivedServiceResponse(object sender, EventArgs<ServiceResponse> e)
        {
            if ((object)e != null)
            {
                ServiceResponse response = e.Argument;

                if ((object)response != null)
                {
                    string sourceCommand;
                    bool responseSuccess;

                    if (ClientHelper.TryParseActionableResponse(response, out sourceCommand, out responseSuccess) && responseSuccess)
                    {
                        if (!string.IsNullOrWhiteSpace(sourceCommand) && string.Compare(sourceCommand.Trim(), "INVOKE", true) == 0)
                        {
                            List<object> attachments = response.Attachments;

                            // A GetHighestSeverityAlarms INVOKE will have two attachments: an alarm array, item 0, and the original command arguments, item 1
                            if ((object)attachments != null && attachments.Count > 1)
                            {
                                Arguments arguments = attachments[1] as Arguments;

                                // Check the method that was invoked - the second argument after the adapter ID
                                if ((object)arguments != null && string.Compare(arguments["OrderedArg2"], "GetRaisedAlarms", true) == 0)
                                {
                                    m_raisedAlarms = attachments[0] as ICollection<Alarm>;

                                    // Release waiting thread once desired response has been received
                                    if ((object)m_responseComplete != null)
                                        m_responseComplete.Set();
                                }
                            }
                        }
                    }
                }
            }
        }

        #endregion
    }
}