//******************************************************************************************************
//  LogStackMessages.cs - Gbtc
//
//  Copyright © 2016, 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:
//  ----------------------------------------------------------------------------------------------------
//  10/24/2016 - Steven E. Chisholm
//       Generated original version of source code. 
//
//******************************************************************************************************

using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Text;
using GSF.IO;

namespace GSF.Diagnostics
{
    /// <summary>
    /// Represents an immutable list of stack messages.
    /// </summary>
    public class LogStackMessages : IEquatable<LogStackMessages>
    {
        #region [ Members ]

        // Fields
        //Since stack messages won't be too large, SortedList consumes less memory and can be faster.
        private readonly SortedList<string, string> m_messages;
        private readonly long m_hashCode;

        #endregion

        #region [ Constructors ]

        private LogStackMessages()
        {
            m_messages = new SortedList<string, string>();
            m_hashCode = ComputeHashCode();
        }

        /// <summary>
        /// Creates a new stack message from the provided list of key/value pairs.
        /// </summary>
        /// <param name="keyValuePairs">Key/value pairs, e.g., key1, value1, key2, value2, ..., key(n), value(n).</param>
        public LogStackMessages(params string[] keyValuePairs)
        {
            if (keyValuePairs.Length == 0)
                throw new ArgumentOutOfRangeException(nameof(keyValuePairs));

            if (keyValuePairs.Length % 2 != 0)
                throw new ArgumentOutOfRangeException(nameof(keyValuePairs), "Key/value pair mismatch");


            m_messages = new SortedList<string, string>();

            for (int i = 0; i < keyValuePairs.Length; i += 2)
            {
                string key = keyValuePairs[i];
                string value = keyValuePairs[i + 1];

                if (string.IsNullOrWhiteSpace(key))
                    throw new ArgumentNullException(nameof(key), "Specified key was null or empty.");

                if (string.IsNullOrWhiteSpace(value))
                    throw new ArgumentNullException(nameof(value), "Specified value was null or empty.");

                m_messages[key] = value;
            }

            m_hashCode = ComputeHashCode();
        }

        /// <summary>
        /// Creates a new stack message from the provided <paramref name="key"/> and <paramref name="value"/>.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="value">The value.</param>
        /// <exception cref="ArgumentNullException">if key or value are null or whitespace.</exception>
        public LogStackMessages(string key, string value)
        {
            if (string.IsNullOrWhiteSpace(key))
                throw new ArgumentNullException(nameof(key), "Specified key was null or empty.");

            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentNullException(nameof(value), "Specified value was null or empty.");

            m_messages = new SortedList<string, string>();
            m_messages[key] = value;
            m_hashCode = ComputeHashCode();
        }

        /// <summary>
        /// Appends stack messages together.
        /// </summary>
        /// <param name="messages">the messages</param>
        public LogStackMessages(List<KeyValuePair<string, string>> messages)
        {
            m_messages = new SortedList<string, string>();

            for (int x = 0; x < messages.Count; x++)
            {
                KeyValuePair<string, string> pair = messages[x];

                if (string.IsNullOrWhiteSpace(pair.Key))
                    throw new ArgumentNullException(nameof(messages), "A key is null or whitespace");

                if (string.IsNullOrWhiteSpace(pair.Value))
                    throw new ArgumentNullException(nameof(messages), "A value is null or whitespace");

                m_messages[pair.Key] = pair.Value;
            }

            m_hashCode = ComputeHashCode();
        }

        /// <summary>
        /// Appends stack messages together.
        /// </summary>
        /// <param name="messages">the messages</param>
        public LogStackMessages(List<LogStackMessages> messages)
        {
            m_messages = new SortedList<string, string>();

            for (int x = 0; x < messages.Count; x++)
            {
                LogStackMessages item = messages[x];
                foreach (var kvp in item.m_messages)
                {
                    m_messages[kvp.Key] = kvp.Value;
                }
            }

            m_hashCode = ComputeHashCode();
        }

        /// <summary>
        /// Appends stack messages together.
        /// </summary>
        private LogStackMessages(LogStackMessages a, LogStackMessages b)
        {
            m_messages = new SortedList<string, string>();

            foreach (var kvp in a.m_messages)
            {
                m_messages[kvp.Key] = kvp.Value;
            }

            foreach (var kvp in b.m_messages)
            {
                m_messages[kvp.Key] = kvp.Value;
            }

            m_hashCode = ComputeHashCode();
        }

        /// <summary>
        /// Loads stack messages from the stream.
        /// </summary>
        /// <param name="stream">the stream to load from</param>
        /// <exception cref="VersionNotFoundException">if the version is not recognized.</exception>
        public LogStackMessages(Stream stream)
        {
            int version = stream.ReadNextByte();
            m_messages = new SortedList<string, string>();

            if (version == 0)
            {
                int count = stream.ReadInt32();
                for (int x = 0; x < count; x++)
                {
                    string key = stream.ReadString();
                    string value = stream.ReadString();
                    m_messages[key] = value;
                }
            }
            else
            {
                throw new VersionNotFoundException();
            }

            m_hashCode = ComputeHashCode();
        }

        private LogStackMessages(LogStackMessages oldMessage, string key, string value)
        {
            m_messages = new SortedList<string, string>();

            foreach (var kvp in oldMessage.m_messages)
            {
                m_messages[kvp.Key] = kvp.Value;
            }
            m_messages[key] = value;
            m_hashCode = ComputeHashCode();

        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets the number of Key/Value pairs.
        /// </summary>
        public int Count => m_messages.Count;

        /// <summary>
        /// Gets the KeyValue for the provided index.
        /// </summary>
        /// <param name="index">The Index</param>
        public KeyValuePair<string, string> this[int index] => new KeyValuePair<string, string>(m_messages.Keys[index], m_messages.Values[index]);

        /// <summary>
        /// Gets the first match of the provided <see pref="key"/> in this dictionary. Returns
        /// null if none can be found.
        /// </summary>
        /// <param name="key">The Index</param>
        public string this[string key]
        {
            get
            {
                string value;
                m_messages.TryGetValue(key, out value);
                return value;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// returns the union of this instance and the specified key/value. 
        /// If the key already exists. The new one replaces the existing one.
        /// </summary>
        /// <param name="key">a key</param>
        /// <param name="value">a value</param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException">if Key or Value are null or whitespace.</exception>
        public LogStackMessages Union(string key, string value)
        {
            if (string.IsNullOrWhiteSpace(key))
                throw new ArgumentNullException(nameof(key));

            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentNullException(nameof(value));

            string currentValue = this[key];
            if (currentValue != null && currentValue == value)
                return this;

            return new LogStackMessages(this, key, value);
        }

        /// <summary>
        /// returns the union of this instance and the specified list of key/value pairs. 
        /// If the keys already exists. The new one replaces the existing one.
        /// </summary>
        /// <param name="keyValuePairs">Key/value pairs, e.g., key1, value1, key2, value2, ..., key(n), value(n).</param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException">if Key or Value are null or whitespace.</exception>
        public LogStackMessages Union(params string[] keyValuePairs)
        {
            return Union(new LogStackMessages(keyValuePairs));
        }

        /// <summary>
        /// returns the union of this instance and the specified <see pref="stackMessage"/>
        /// New messages replace existing messages.
        /// </summary>
        /// <returns></returns>
        public LogStackMessages Union(LogStackMessages stackMessage)
        {
            if ((object)stackMessage == null)
                return this;

            if (ReferenceEquals(stackMessage, Empty))
                return this;

            if (ReferenceEquals(this, Empty))
                return stackMessage;

            if (Equals(stackMessage))
                return this;

            return new LogStackMessages(this, stackMessage);
        }

        /// <summary>
        /// Saves this instance to the provided stream
        /// </summary>
        /// <param name="stream">the stream to save.</param>
        public void Save(Stream stream)
        {
            stream.WriteByte(0);
            stream.Write(m_messages.Count);

            foreach (var kvp in m_messages)
            {
                stream.Write(kvp.Key);
                stream.Write(kvp.Value);
            }
        }

        /// <summary>
        /// Serves as a hash function for a particular type. 
        /// </summary>
        /// <returns>
        /// A hash code for the current <see cref="T:System.Object"/>.
        /// </returns>
        /// <filterpriority>2</filterpriority>
        public override int GetHashCode() => (int)m_hashCode;

        /// <summary>
        /// Determines whether the specified <see cref="T:System.Object"/> is equal to the current <see cref="T:System.Object"/>.
        /// </summary>
        /// <returns>
        /// true if the specified object  is equal to the current object; otherwise, false.
        /// </returns>
        /// <param name="obj">The object to compare with the current object. </param><filterpriority>2</filterpriority>
        public override bool Equals(object obj) => Equals(obj as LogStackMessages);

        /// <summary>
        /// Indicates whether the current object is equal to another object of the same type.
        /// </summary>
        /// <returns>
        /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
        /// </returns>
        /// <param name="other">An object to compare with this object.</param>
        public bool Equals(LogStackMessages other)
        {
            if (ReferenceEquals(this, other))
                return true;

            if ((object)other == null
                || m_hashCode != other.m_hashCode
                || m_messages.Count != other.m_messages.Count)
                return false;

            for (int x = 0; x < m_messages.Count; x++)
            {
                if (m_messages.Keys[x] != other.m_messages.Keys[x])
                    return false;

                if (m_messages.Values[x] != other.m_messages.Values[x])
                    return false;
            }

            return true;
        }

        /// <summary>Returns a string that represents the current object.</summary>
        /// <returns>A string that represents the current object.</returns>
        /// <filterpriority>2</filterpriority>
        public override string ToString()
        {
            if (m_messages.Count == 0)
                return string.Empty;

            StringBuilder image = new StringBuilder();

            foreach (var kvp in m_messages)
            {
                image.Append(kvp.Key);
                image.Append('=');
                image.Append(kvp.Value);
                image.AppendLine();
            }

            return image.ToString();
        }

        private int ComputeHashCode()
        {
            int hashSum = m_messages.Count;

            foreach (var kvp in m_messages)
            {
                hashSum ^= kvp.Key.GetHashCode();
                hashSum ^= kvp.Value.GetHashCode();
            }

            return hashSum;
        }

        #endregion

        #region [ Static ]

        // Static Fields

        /// <summary>
        /// An empty stack message.
        /// </summary>
        [SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
        public static readonly LogStackMessages Empty;

        // Static Constructor
        static LogStackMessages()
        {
            Empty = new LogStackMessages();
        }

        // Static Methods

        internal static void Initialize()
        {
        }

        #endregion
    }
}