//******************************************************************************************************
//  TrackingFrame.cs - Gbtc
//
//  Copyright © 2010, 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:
//  ----------------------------------------------------------------------------------------------------
//  09/02/2010 - J. Ritchie Carroll
//       Generated original version of source code.
//
//******************************************************************************************************

using GSF.Threading;
using System.Collections.Concurrent;
using System.Collections.Generic;

namespace GSF.TimeSeries
{
    /// <summary>
    /// <see cref="IFrame"/> container used to track <see cref="IMeasurement"/> values for downsampling.
    /// </summary>
    internal class TrackingFrame
    {
        #region [ Members ]

        // Fields
        private IFrame m_sourceFrame;
        private long m_timestamp;
        private DownsamplingMethod m_downsamplingMethod;
        private ConcurrentDictionary<MeasurementKey, List<IMeasurement>> m_measurements;
        private ReaderWriterSpinLock m_frameLock;
        private long m_derivedMeasurements;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Constructs a new <see cref="TrackingFrame"/> given the specified parameters.
        /// </summary>
        /// <param name="sourceFrame">Source <see cref="IFrame"/> to track.</param>
        /// <param name="downsamplingMethod"><see cref="DownsamplingMethod"/> to apply.</param>
        public TrackingFrame(IFrame sourceFrame, DownsamplingMethod downsamplingMethod)
        {
            m_sourceFrame = sourceFrame;
            m_timestamp = sourceFrame.Timestamp;
            m_downsamplingMethod = downsamplingMethod;
            m_frameLock = new ReaderWriterSpinLock();

            if (downsamplingMethod != DownsamplingMethod.LastReceived)
                m_measurements = new ConcurrentDictionary<MeasurementKey, List<IMeasurement>>();
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets instance of <see cref="IFrame"/> being tracked.
        /// </summary>
        public IFrame SourceFrame
        {
            get
            {
                return m_sourceFrame;
            }
        }

        /// <summary>
        /// Gets timestamp of <see cref="IFrame"/> being tracked.
        /// </summary>
        public long Timestamp
        {
            get
            {
                return m_timestamp;
            }
        }

        /// <summary>
        /// Total number of measurements downsampled by <see cref="TrackingFrame"/>.
        /// </summary>
        public long DownsampledMeasurements
        {
            get
            {
                // Only measurements that came in after initial sorts were downsampled...
                return m_derivedMeasurements - m_sourceFrame.SortedMeasurements;
            }
        }

        /// <summary>
        /// Gets the <see cref="TrackingFrame"/> locking primitive.
        /// </summary>
        public ReaderWriterSpinLock Lock
        {
            get
            {
                return m_frameLock;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Derives measurement value, downsampling if needed.
        /// </summary>
        /// <param name="measurement">New <see cref="IMeasurement"/> value.</param>
        /// <returns>New derived <see cref="IMeasurement"/> value, or null if value should not be assigned to <see cref="IFrame"/>.</returns>
        public IMeasurement DeriveMeasurementValue(IMeasurement measurement)
        {
            IMeasurement derivedMeasurement;
            List<IMeasurement> values;

            switch (m_downsamplingMethod)
            {
                case DownsamplingMethod.LastReceived:
                    // Keep track of total number of derived measurements
                    m_derivedMeasurements++;

                    // This is the simplest case, just apply latest value
                    return measurement;
                case DownsamplingMethod.Closest:
                    // Get tracked measurement values
                    if (m_measurements.TryGetValue(measurement.Key, out values))
                    {
                        if ((object)values != null && values.Count > 0)
                        {
                            // Get first tracked value (should only be one for "Closest")
                            derivedMeasurement = values[0];

                            if ((object)derivedMeasurement != null)
                            {
                                // Determine if new measurement's timestamp is closer to frame
                                if (measurement.Timestamp < derivedMeasurement.Timestamp && measurement.Timestamp >= m_timestamp)
                                {
                                    // This measurement came in out-of-order and is closer to frame timestamp, so 
                                    // we sort this measurement instead of the original
                                    values[0] = measurement;

                                    // Keep track of total number of derived measurements
                                    m_derivedMeasurements++;

                                    return measurement;
                                }

                                // Prior measurement is closer to frame than new one
                                return null;
                            }
                        }
                    }

                    // No prior measurement exists, track this initial one
                    values = new List<IMeasurement> { measurement };
                    m_measurements[measurement.Key] = values;

                    // Keep track of total number of derived measurements
                    m_derivedMeasurements++;

                    return measurement;
                case DownsamplingMethod.Filtered:
                    // Get tracked measurement values
                    if (m_measurements.TryGetValue(measurement.Key, out values))
                    {
                        if ((object)values != null && values.Count > 0)
                        {
                            // Get first tracked value - we clone the measurement since we are updating its value
                            derivedMeasurement = Measurement.Clone(values[0]);

                            if ((object)derivedMeasurement != null)
                            {
                                // Get function defined for measurement value filtering
                                MeasurementValueFilterFunction measurementValueFilter = derivedMeasurement.MeasurementValueFilter;

                                // Default to average value filter if none is specified
                                if (measurementValueFilter == null)
                                    measurementValueFilter = Measurement.AverageValueFilter;

                                // Add new measurement to tracking collection
                                if ((object)measurement != null)
                                    values.Add(measurement);

                                // Perform filter calculation as specified by device measurement
                                if (values.Count > 1)
                                {
                                    derivedMeasurement.Value = measurementValueFilter(values);

                                    // Keep track of total number of derived measurements
                                    m_derivedMeasurements++;

                                    return derivedMeasurement;
                                }

                                // No change from existing measurement
                                return null;
                            }
                        }
                    }

                    // No prior measurement exists, track this initial one
                    values = new List<IMeasurement> { measurement };
                    m_measurements[measurement.Key] = values;

                    // Keep track of total number of derived measurements
                    m_derivedMeasurements++;

                    return measurement;
                case DownsamplingMethod.BestQuality:
                    // Get tracked measurement values
                    if (m_measurements.TryGetValue(measurement.Key, out values))
                    {
                        if ((object)values != null && values.Count > 0)
                        {
                            // Get first tracked value (should only be one for "BestQuality")
                            derivedMeasurement = values[0];

                            if ((object)derivedMeasurement != null)
                            {
                                // Determine if new measurement's quality is better than existing one or if new measurement's timestamp is closer to frame
                                if
                                (
                                    (
                                        (!derivedMeasurement.ValueQualityIsGood() || !derivedMeasurement.TimestampQualityIsGood())
                                            &&
                                        (measurement.ValueQualityIsGood() || measurement.TimestampQualityIsGood())
                                    )
                                        ||
                                    (
                                        measurement.Timestamp < derivedMeasurement.Timestamp && measurement.Timestamp >= m_timestamp
                                    )
                                )
                                {
                                    // This measurement has a better quality or came in out-of-order and is closer to frame timestamp, so 
                                    // we sort this measurement instead of the original
                                    values[0] = measurement;

                                    // Keep track of total number of derived measurements
                                    m_derivedMeasurements++;

                                    return measurement;
                                }

                                // Prior measurement is closer to frame than new one
                                return null;
                            }
                        }
                    }

                    // No prior measurement exists, track this initial one
                    values = new List<IMeasurement> { measurement };
                    m_measurements[measurement.Key] = values;

                    // Keep track of total number of derived measurements
                    m_derivedMeasurements++;

                    return measurement;
            }

            return null;
        }

        #endregion
    }
}