//******************************************************************************************************
//  SignalIndexCache.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 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/15/2011 - J. Ritchie Carroll
//       Generated original version of source code.
//  12/20/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using GSF.Collections;
using GSF.Parsing;

#pragma warning disable 618

namespace GSF.TimeSeries.Transport
{
    /// <summary>
    /// Represents a serializable <see cref="Guid"/> signal ID to <see cref="ushort"/> index cross reference.
    /// </summary>
    /// <remarks>
    /// This class is used to create a runtime index to be used for data exchange so that a 16-bit integer
    /// is exchanged in the data packets for signal identification instead of the 128-bit Guid signal ID
    /// to reduce bandwidth required for signal exchange. This means the total number of unique signal
    /// IDs that could be exchanged using this method in a single session is 65,535. This number seems
    /// reasonable for the currently envisioned use cases, however, multiple sessions each with their own
    /// runtime signal index cache could be established if this is a limitation for a given data set.
    /// </remarks>
    [Serializable]
    public class SignalIndexCache : ISupportBinaryImage
    {
        #region [ Members ]

        // Fields
        private Guid m_subscriberID;

        // Since measurement keys are statically cached as a global system optimization and the keys
        // can be different between two parties exchanging data, the raw measurement key elements are
        // cached and exchanged instead of actual measurement key values
        private ConcurrentDictionary<ushort, MeasurementKey> m_reference;
        private Guid[] m_unauthorizedSignalIDs;

        /// <summary>
        /// Lookups MeasurementKey.RuntimeID and returns ushort SignalIndex. -1 means it does not exist.
        /// </summary>
        [NonSerialized] // SignalID reverse lookup runtime cache (used to speed deserialization)
        private IndexedArray<int> m_signalIDCache;

        [NonSerialized]
        private Encoding m_encoding;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new <see cref="SignalIndexCache"/> instance.
        /// </summary>
        public SignalIndexCache()
        {
            m_reference = new ConcurrentDictionary<ushort, MeasurementKey>();
            m_signalIDCache = new IndexedArray<int>(-1);
        }

        /// <summary>
        /// Creates a new local system cache from one that was received remotely.
        /// </summary>
        /// <param name="dataSource"><see cref="DataSet"/> based data source used to interpret local measurement keys.</param>
        /// <param name="remoteCache">Deserialized remote signal index cache.</param>
        public SignalIndexCache(DataSet dataSource, SignalIndexCache remoteCache)
        {
            m_subscriberID = remoteCache.SubscriberID;

            // If active measurements are defined, interpret signal cache in context of current measurement key definitions
            if (dataSource != null && dataSource.Tables.Contains("ActiveMeasurements"))
            {
                DataTable activeMeasurements = dataSource.Tables["ActiveMeasurements"];
                m_reference = new ConcurrentDictionary<ushort, MeasurementKey>();

                foreach (KeyValuePair<ushort, MeasurementKey> signalIndex in remoteCache.Reference)
                {
                    Guid signalID = signalIndex.Value.SignalID;
                    DataRow[] filteredRows = activeMeasurements.Select("SignalID = '" + signalID.ToString() + "'");

                    if (filteredRows.Length > 0)
                    {
                        DataRow row = filteredRows[0];
                        MeasurementKey key = MeasurementKey.LookUpOrCreate(signalID, row["ID"].ToNonNullString(MeasurementKey.Undefined.ToString()));
                        m_reference.TryAdd(signalIndex.Key, key);
                    }
                }

                m_unauthorizedSignalIDs = remoteCache.UnauthorizedSignalIDs;
            }
            else
            {
                // Just use remote signal index cache as-is if no local configuration exists
                m_reference = remoteCache.Reference;
                m_unauthorizedSignalIDs = remoteCache.UnauthorizedSignalIDs;
            }
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets or sets the <see cref="Guid"/> based subscriber ID of this <see cref="SignalIndexCache"/>.
        /// </summary>
        public Guid SubscriberID
        {
            get
            {
                return m_subscriberID;
            }
            set
            {
                m_subscriberID = value;
            }
        }

        /// <summary>
        /// Gets or sets integer signal index cross reference dictionary.
        /// </summary>
        public ConcurrentDictionary<ushort, MeasurementKey> Reference
        {
            get
            {
                return m_reference;
            }
            set
            {
                m_reference = value;
                IndexedArray<int> signalIDCache = new IndexedArray<int>(-1);
                foreach (var pair in value)
                {
                    signalIDCache[pair.Value.RuntimeID] = pair.Key;
                }

                m_signalIDCache = signalIDCache;
            }
        }

        /// <summary>
        /// Gets reference to array of requested input measurement signal IDs that were authorized.
        /// </summary>
        public Guid[] AuthorizedSignalIDs
        {
            get
            {
                return m_reference.Select(kvp => kvp.Value.SignalID).ToArray();
            }
        }

        /// <summary>
        /// Gets or sets reference to array of requested input measurement signal IDs that were unauthorized.
        /// </summary>
        public Guid[] UnauthorizedSignalIDs
        {
            get
            {
                return m_unauthorizedSignalIDs;
            }
            set
            {
                m_unauthorizedSignalIDs = value;
            }
        }

        /// <summary>
        /// Gets the current maximum integer signal index.
        /// </summary>
        public ushort MaximumIndex
        {
            get
            {
                if (m_reference.Count == 0)
                    return 0;

                return (ushort)(m_reference.Max(kvp => kvp.Key) + 1);
            }
        }

        /// <summary>
        /// Gets or sets character encoding used to convert strings to binary.
        /// </summary>
        public Encoding Encoding
        {
            get
            {
                return m_encoding;
            }
            set
            {
                m_encoding = value;
            }
        }

        /// <summary>
        /// Gets the length of the binary image.
        /// </summary>
        public int BinaryLength
        {
            get
            {
                int binaryLength = 0;

                if ((object)m_encoding == null)
                    throw new InvalidOperationException("Attempt to get binary length of signal index cache without setting a character encoding.");

                // Byte size of cache
                binaryLength += 4;

                // Subscriber ID
                binaryLength += 16;

                // Number of references
                binaryLength += 4;

                // Each reference
                binaryLength += m_reference.Sum(kvp => 2 + 16 + 4 + m_encoding.GetByteCount(kvp.Value.Source) + 4);

                // Number of unauthorized IDs
                binaryLength += 4;

                // Each unauthorized ID
                binaryLength += 16 * (m_unauthorizedSignalIDs ?? new Guid[0]).Length;

                return binaryLength;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Gets runtime signal index for given <see cref="Guid"/> signal ID.
        /// </summary>
        /// <param name="key">The <see cref="MeasurementKey"/> used to lookup associated runtime signal index.</param>
        /// <returns>Runtime signal index for given <see cref="MeasurementKey"/> <paramref name="key"/>.</returns>
        public ushort GetSignalIndex(MeasurementKey key)
        {
            int value = m_signalIDCache[key.RuntimeID];
            if (value < 0)
                return ushort.MaxValue;

            return (ushort)value;
        }

        /// <summary>
        /// Generates binary image of the <see cref="SignalIndexCache"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes.
        /// </summary>
        /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param>
        /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param>
        /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns>
        public int GenerateBinaryImage(byte[] buffer, int startIndex)
        {
            Guid[] unauthorizedSignalIDs = m_unauthorizedSignalIDs ?? new Guid[0];

            int binaryLength = BinaryLength;
            int offset = startIndex;
            byte[] bigEndianBuffer;
            byte[] unicodeBuffer;

            if ((object)m_encoding == null)
                throw new InvalidOperationException("Attempt to generate binary image of signal index cache without setting a character encoding.");

            buffer.ValidateParameters(startIndex, binaryLength);

            // Byte size of cache
            bigEndianBuffer = BigEndian.GetBytes(binaryLength);
            Buffer.BlockCopy(bigEndianBuffer, 0, buffer, offset, bigEndianBuffer.Length);
            offset += bigEndianBuffer.Length;

            // Subscriber ID
            bigEndianBuffer = EndianOrder.BigEndian.GetBytes(m_subscriberID);
            Buffer.BlockCopy(bigEndianBuffer, 0, buffer, offset, bigEndianBuffer.Length);
            offset += bigEndianBuffer.Length;

            // Number of references
            bigEndianBuffer = BigEndian.GetBytes(m_reference.Count);
            Buffer.BlockCopy(bigEndianBuffer, 0, buffer, offset, bigEndianBuffer.Length);
            offset += bigEndianBuffer.Length;

            foreach (KeyValuePair<ushort, MeasurementKey> kvp in m_reference)
            {
                // Signal index
                bigEndianBuffer = BigEndian.GetBytes(kvp.Key);
                Buffer.BlockCopy(bigEndianBuffer, 0, buffer, offset, bigEndianBuffer.Length);
                offset += bigEndianBuffer.Length;

                // Signal ID
                bigEndianBuffer = EndianOrder.BigEndian.GetBytes(kvp.Value.SignalID);
                Buffer.BlockCopy(bigEndianBuffer, 0, buffer, offset, bigEndianBuffer.Length);
                offset += bigEndianBuffer.Length;

                // Source
                unicodeBuffer = m_encoding.GetBytes(kvp.Value.Source);
                bigEndianBuffer = BigEndian.GetBytes(unicodeBuffer.Length);
                Buffer.BlockCopy(bigEndianBuffer, 0, buffer, offset, bigEndianBuffer.Length);
                offset += bigEndianBuffer.Length;
                Buffer.BlockCopy(unicodeBuffer, 0, buffer, offset, unicodeBuffer.Length);
                offset += unicodeBuffer.Length;

                // ID
                bigEndianBuffer = BigEndian.GetBytes((uint)kvp.Value.ID);
                Buffer.BlockCopy(bigEndianBuffer, 0, buffer, offset, bigEndianBuffer.Length);
                offset += bigEndianBuffer.Length;
            }

            // Number of unauthorized IDs
            bigEndianBuffer = BigEndian.GetBytes(unauthorizedSignalIDs.Length);
            Buffer.BlockCopy(bigEndianBuffer, 0, buffer, offset, bigEndianBuffer.Length);
            offset += bigEndianBuffer.Length;

            foreach (Guid signalID in unauthorizedSignalIDs)
            {
                // Unauthorized ID
                bigEndianBuffer = EndianOrder.BigEndian.GetBytes(signalID);
                Buffer.BlockCopy(bigEndianBuffer, 0, buffer, offset, bigEndianBuffer.Length);
                offset += bigEndianBuffer.Length;
            }

            return binaryLength;
        }

        /// <summary>
        /// Initializes the <see cref="SignalIndexCache"/> by parsing the specified <paramref name="buffer"/> containing a binary image.
        /// </summary>
        /// <param name="buffer">Buffer containing binary image to parse.</param>
        /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start parsing.</param>
        /// <param name="length">Valid number of bytes within <paramref name="buffer"/> to read from <paramref name="startIndex"/>.</param>
        /// <returns>The number of bytes used for initialization in the <paramref name="buffer"/> (i.e., the number of bytes parsed).</returns>
        public int ParseBinaryImage(byte[] buffer, int startIndex, int length)
        {
            int binaryLength;
            int offset = startIndex;

            int referenceCount;
            ushort signalIndex;
            Guid signalID;
            int sourceSize;
            string source;
            uint id;

            int unauthorizedIDCount;

            if ((object)m_encoding == null)
                throw new InvalidOperationException("Attempt to parse binary image of signal index cache without setting a character encoding.");

            buffer.ValidateParameters(startIndex, length);

            if (length < 4)
                return 0;

            // Byte size of cache
            binaryLength = BigEndian.ToInt32(buffer, offset);
            offset += 4;

            if (length < binaryLength)
                return 0;

            // We know we have enough data so we can empty the reference cache
            m_reference.Clear();

            // Subscriber ID
            m_subscriberID = EndianOrder.BigEndian.ToGuid(buffer, offset);
            offset += 16;

            // Number of references
            referenceCount = BigEndian.ToInt32(buffer, offset);
            offset += 4;

            for (int i = 0; i < referenceCount; i++)
            {
                // Signal index
                signalIndex = BigEndian.ToUInt16(buffer, offset);
                offset += 2;

                // Signal ID
                signalID = EndianOrder.BigEndian.ToGuid(buffer, offset);
                offset += 16;

                // Source
                sourceSize = BigEndian.ToInt32(buffer, offset);
                offset += 4;
                source = m_encoding.GetString(buffer, offset, sourceSize);
                offset += sourceSize;

                // ID
                id = BigEndian.ToUInt32(buffer, offset);
                offset += 4;

                m_reference[signalIndex] = MeasurementKey.LookUpOrCreate(signalID, source, id);
            }

            // Number of unauthorized IDs
            unauthorizedIDCount = BigEndian.ToInt32(buffer, offset);
            m_unauthorizedSignalIDs = new Guid[unauthorizedIDCount];
            offset += 4;

            for (int i = 0; i < unauthorizedIDCount; i++)
            {
                // Unauthorized ID
                m_unauthorizedSignalIDs[i] = EndianOrder.BigEndian.ToGuid(buffer, offset);
                offset += 16;
            }

            return binaryLength;
        }

        #endregion
    }
}