//******************************************************************************************************
//  TimestampTest.cs - Gbtc
//
//  Copyright © 2012, 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 Eclipse Public License -v 1.0 (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/eclipse-1.0.php
//
//  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:
//  ----------------------------------------------------------------------------------------------------
//  12/18/2009 - Stephen C. Wills
//       Generated original version of source code.
//  12/13/2012 - Starlynn Danyelle Gilliam
//       Modifed Header.
//
//******************************************************************************************************

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Timers;
using DataQualityMonitoring.Services;
using GSF;
using GSF.TimeSeries;
using GSF.TimeSeries.Adapters;

namespace DataQualityMonitoring
{
    /// <summary>
    /// Tests measurements to determine whether their timestamps are good or bad.
    /// </summary>
    [Description("Timestamp Test: notifies when the timestamps of incoming measurements are bad")]
    public class TimestampTest : FacileActionAdapterBase
    {
        #region [ Members ]

        // Fields
        private readonly Dictionary<Ticks, LinkedList<IMeasurement>> m_badTimestampMeasurements;
        private IActionAdapter m_discardingAdapter;
        private int m_totalBadTimestampMeasurements;
        private Ticks m_timeToPurge;
        private Ticks m_warnInterval;
        private Timer m_purgeTimer;
        private Timer m_warningTimer;
        private TimestampService m_timestampService;
        private bool m_disposed;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Initializes a new instance of the <see cref="TimestampTest"/> class.
        /// </summary>
        public TimestampTest()
        {
            m_badTimestampMeasurements = new Dictionary<Ticks, LinkedList<IMeasurement>>();
            m_timeToPurge = Ticks.FromSeconds(1.0);
            m_warnInterval = Ticks.FromSeconds(4.0);
            m_purgeTimer = new Timer();
            m_warningTimer = new Timer();
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets or sets the age, in seconds, at which measurements with bad timestamps are purged from the adapter.
        /// </summary>
        [ConnectionStringParameter,
        Description("Define the age, in seconds, at which measurements with bad timestamps are purged from the adapter."),
        DefaultValue(1.0)]
        public double TimeToPurge
        {
            get
            {
                return m_timeToPurge.ToSeconds();
            }
            set
            {
                m_timeToPurge = Ticks.FromSeconds(value);
            }
        }

        /// <summary>
        /// Gets or sets the amount of time, in seconds, between console updates.
        /// </summary>
        [ConnectionStringParameter,
        Description("Define the amount of time, in seconds, between console updates."),
        DefaultValue(4.0)]
        public double WarnInterval
        {
            get
            {
                return m_warnInterval.ToSeconds();
            }
            set
            {
                m_warnInterval = Ticks.FromSeconds(value);
            }
        }

        /// <summary>
        /// Gets or sets the name of the concentrator whose measurements will be checked for bad timestamps.
        /// Modifying this property will cause this adapter to search for an action adapter with the name
        /// that was supplied to the property. If one is found, it will detach from the current adapter and
        /// attach to the other. If one is not found, nothing will happen.
        /// </summary>
        [ConnectionStringParameter,
        Description("Define the name of the concentrator whose measurements will be checked for bad timestamps.")]
        public string ConcentratorName
        {
            get
            {
                return m_discardingAdapter.Name;
            }
            set
            {
                // Detach to the current adapter's discarding measurements and disposed events.
                m_discardingAdapter.DiscardingMeasurements -= m_discardingAdapter_DiscardingMeasurements;
                m_discardingAdapter.Disposed -= m_discardingAdapter_Disposed;

                // Find the adapter whose name matches the specified concentratorName
                foreach (IAdapter adapter in Parent)
                {
                    IActionAdapter concentrator = adapter as IActionAdapter;

                    if (concentrator != null && string.Compare(adapter.Name, value, true) == 0)
                    {
                        m_discardingAdapter = concentrator;
                        break;
                    }
                }

                // Attach to adapter's discarding measurements and disposed events
                m_discardingAdapter.DiscardingMeasurements += m_discardingAdapter_DiscardingMeasurements;
                m_discardingAdapter.Disposed += m_discardingAdapter_Disposed;
            }
        }

        /// <summary>
        /// Gets the flag indicating if this adapter supports temporal processing.
        /// </summary>
        public override bool SupportsTemporalProcessing
        {
            get
            {
                return false;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Returns a short, one-line status message about the adapter.
        /// </summary>
        /// <param name="maxLength">The maximum length of the message to be returned.</param>
        /// <returns>A short, one-line status message.</returns>
        public override string GetShortStatus(int maxLength)
        {
            return string.Format("Detected {0} measurements with bad timestamps", m_totalBadTimestampMeasurements).CenterText(maxLength);
        }

        /// <summary>
        /// Initializes <see cref="TimestampTest"/>.
        /// </summary>
        public override void Initialize()
        {
            base.Initialize();

            string errorMessage = "{0} is missing from Settings - Example: concentratorName=TESTSTREAM";
            Dictionary<string, string> settings = Settings;
            string setting;

            // Load optional parameters
            if (settings.TryGetValue("timeToPurge", out setting))
                m_timeToPurge = Ticks.FromSeconds(double.Parse(setting));

            if (settings.TryGetValue("warnInterval", out setting))
                m_warnInterval = Ticks.FromSeconds(double.Parse(setting));

            // Load required parameters
            string concentratorName;

            if (!settings.TryGetValue("concentratorName", out concentratorName))
                throw new ArgumentException(string.Format(errorMessage, "concentratorName"));

            m_discardingAdapter = null;

            // Find the adapter whose name matches the specified concentratorName
            foreach (IAdapter adapter in Parent)
            {
                IActionAdapter concentrator = adapter as IActionAdapter;

                if (concentrator != null && string.Compare(adapter.Name, concentratorName, true) == 0)
                {
                    m_discardingAdapter = concentrator;
                    break;
                }
            }

            if (m_discardingAdapter == null)
                throw new ArgumentException(string.Format("Concentrator {0} not found.", concentratorName));

            // Wait for associated adapter to initialize
            int timeout = m_discardingAdapter.InitializationTimeout;
            m_discardingAdapter.WaitForInitialize(timeout);

            if (!m_discardingAdapter.Initialized)
                throw new TimeoutException(string.Format("Timeout waiting for concentrator {0} to initialize.", concentratorName));

            // Attach to adapter's discarding measurements and disposed events
            m_discardingAdapter.DiscardingMeasurements += m_discardingAdapter_DiscardingMeasurements;
            m_discardingAdapter.Disposed += m_discardingAdapter_Disposed;

            m_purgeTimer.Interval = m_timeToPurge.ToMilliseconds();
            m_purgeTimer.Elapsed += m_purgeTimer_Elapsed;

            m_warningTimer.Interval = m_warnInterval.ToMilliseconds();
            m_warningTimer.Elapsed += m_warningTimer_Elapsed;

            m_timestampService = new TimestampService(this);
            m_timestampService.ServiceProcessException += m_timestampService_ServiceProcessException;
            m_timestampService.SettingsCategory = base.Name + m_timestampService.SettingsCategory;
            m_timestampService.Initialize();
        }

        /// <summary>
        /// Starts this <see cref="TimestampTest"/>.
        /// </summary>
        public override void Start()
        {
            base.Start();
            m_purgeTimer.Start();
            m_warningTimer.Start();
        }

        /// <summary>
        /// Stops this <see cref="TimestampTest"/>.
        /// </summary>
        public override void Stop()
        {
            base.Stop();
            m_purgeTimer.Stop();
            m_warningTimer.Stop();
        }

        /// <summary>
        /// Queues a collection of measurements for processing.
        /// </summary>
        /// <param name="measurements">Collection of measurements to queue for processing.</param>
        /// <remarks>
        /// The <see cref="TimestampTest"/> adapter doesn't process any measurements.
        /// </remarks>
        public override void QueueMeasurementsForProcessing(IEnumerable<IMeasurement> measurements)
        {
            // The timestamp test doesn't have a need to process any measurements
        }

        /// <summary>
        /// Releases the unmanaged resources used by the <see cref="TimestampTest"/> 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 override void Dispose(bool disposing)
        {
            if (!m_disposed)
            {
                try
                {
                    if (disposing)
                    {
                        // Dispose timestamp service.
                        if (m_timestampService != null)
                        {
                            m_timestampService.ServiceProcessException -= m_timestampService_ServiceProcessException;
                            m_timestampService.Dispose();
                        }
                        m_timestampService = null;

                        // Dispose purge timer.
                        if (m_purgeTimer != null)
                        {
                            m_purgeTimer.Elapsed -= m_purgeTimer_Elapsed;
                            m_purgeTimer.Dispose();
                        }
                        m_purgeTimer = null;

                        // Dispose warning timer.
                        if (m_warningTimer != null)
                        {
                            m_warningTimer.Elapsed -= m_warningTimer_Elapsed;
                            m_warningTimer.Dispose();
                        }
                        m_warningTimer = null;

                        // Dispose discarding adapter.
                        if (m_discardingAdapter != null)
                        {
                            m_discardingAdapter.DiscardingMeasurements -= m_discardingAdapter_DiscardingMeasurements;
                            m_discardingAdapter.Disposed -= m_discardingAdapter_Disposed;
                        }
                        m_discardingAdapter = null; 
                    }
                }
                finally
                {
                    m_disposed = true;          // Prevent duplicate dispose.
                    base.Dispose(disposing);    // Call base class Dispose().
                }
            }
        }

        /// <summary>
        /// Gets all the measurements with bad timestamps.
        /// </summary>
        /// <returns>A dictionary where the keys are arrival times and the values are <see cref="LinkedList{IMeasurement}"/>s of measurements that arrived at the corresponding time.</returns>
        public Dictionary<Ticks, LinkedList<IMeasurement>> GetMeasurementsWithBadTimestamps()
        {
            lock (m_badTimestampMeasurements)
            {
                PurgeOldMeasurements();
                return new Dictionary<Ticks, LinkedList<IMeasurement>>(m_badTimestampMeasurements);
            }
        }

        /// <summary>
        /// Gets the number of measurements with bad timestamps received by this <see cref="TimestampTest"/>.
        /// </summary>
        /// <returns>The number of measurements with bad timestamps.</returns>
        public int GetBadTimestampMeasurementCount()
        {
            Dictionary<Ticks, LinkedList<IMeasurement>> badTimestampMeasurements = GetMeasurementsWithBadTimestamps();
            int count = 0;

            foreach (LinkedList<IMeasurement> measurementList in badTimestampMeasurements.Values)
            {
                count += measurementList.Count;
            }

            return count;
        }

        private void m_discardingAdapter_DiscardingMeasurements(object sender, EventArgs<IEnumerable<IMeasurement>> e)
        {
            if (Enabled)
            {
                Ticks currentTime = DateTime.UtcNow.Ticks;

                lock (m_badTimestampMeasurements)
                {
                    foreach (IMeasurement measurement in e.Argument)
                    {
                        Ticks distance = currentTime - measurement.Timestamp;
                        AddMeasurementWithBadTimestamp(currentTime, measurement);
                    }
                }
            }
        }

        private void AddMeasurementWithBadTimestamp(Ticks timeArrived, IMeasurement measurement)
        {
            lock (m_badTimestampMeasurements)
            {
                LinkedList<IMeasurement> measurementList;

                if (!m_badTimestampMeasurements.TryGetValue(timeArrived, out measurementList))
                {
                    measurementList = new LinkedList<IMeasurement>();
                    m_badTimestampMeasurements.Add(timeArrived, measurementList);
                }

                measurementList.AddLast(measurement);
                m_totalBadTimestampMeasurements++;
            }
        }

        private void PurgeOldMeasurements()
        {
            Ticks currentTime = DateTime.UtcNow.Ticks;

            lock (m_badTimestampMeasurements)
            {
                List<Ticks> arrivalTimes = new List<Ticks>(m_badTimestampMeasurements.Keys);

                foreach (Ticks timeArrived in arrivalTimes)
                {
                    Ticks distance = currentTime - timeArrived;

                    if (distance > m_timeToPurge)
                        m_badTimestampMeasurements.Remove(timeArrived);
                }
            }
        }

        // Periodically purge measurements to speed up retrieval of data.
        private void m_purgeTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            PurgeOldMeasurements();
        }

        // Periodically send updates to the console about any measurements with bad timestamps.
        private void m_warningTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            int count = GetBadTimestampMeasurementCount();

            if (count > 0)
                OnStatusMessage("Received {0} measurements with bad timestamps within the last {1} seconds.", count, (int)m_timeToPurge.ToSeconds());
        }

        private void m_discardingAdapter_Disposed(object sender, EventArgs e)
        {
            m_discardingAdapter.DiscardingMeasurements -= m_discardingAdapter_DiscardingMeasurements;
            m_discardingAdapter.Disposed -= m_discardingAdapter_Disposed;
            m_discardingAdapter = null;
        }

        private void m_timestampService_ServiceProcessException(object sender, EventArgs<Exception> e)
        {
            OnProcessException(e.Argument);
        }

        #endregion
    }
}