//******************************************************************************************************
//  ConfigurationFrame.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/05/2009 - J. Ritchie Carroll
//       Generated original version of source code.
//  09/15/2009 - Stephen C. Wills
//       Added new header and license agreement.
//  12/20/2011 - J. Ritchie Carroll
//       Updated configuration caching algorithm to create multiple backup configurations.
//  12/17/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using System;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization.Formatters.Soap;
using GSF.Collections;
using GSF.Configuration;
using GSF.IO;
using GSF.IO.Checksums;
using GSF.Threading;

namespace GSF.PhasorProtocols.Anonymous
{
    /// <summary>
    /// Represents a protocol independent implementation of a <see cref="IConfigurationFrame"/> that can be sent or received.
    /// </summary>
    [Serializable]
    public class ConfigurationFrame : ConfigurationFrameBase
    {
        #region [ Constructors ]

        /// <summary>
        /// Creates a new <see cref="ConfigurationFrame"/> from specified parameters.
        /// </summary>
        /// <param name="idCode">The ID code of this <see cref="ConfigurationFrame"/>.</param>
        /// <param name="timestamp">The exact timestamp, in <see cref="Ticks"/>, of the data represented by this <see cref="ConfigurationFrame"/>.</param>
        /// <param name="frameRate">The defined frame rate of this <see cref="ConfigurationFrame"/>.</param>
        public ConfigurationFrame(ushort idCode, Ticks timestamp, ushort frameRate)
            : base(idCode, new ConfigurationCellCollection(), timestamp, frameRate)
        {
        }

        /// <summary>
        /// Creates a new <see cref="ConfigurationFrame"/> from serialization parameters.
        /// </summary>
        /// <param name="info">The <see cref="SerializationInfo"/> with populated with data.</param>
        /// <param name="context">The source <see cref="StreamingContext"/> for this deserialization.</param>
        protected ConfigurationFrame(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets reference to the <see cref="ConfigurationCellCollection"/> for this <see cref="ConfigurationFrame"/>.
        /// </summary>
        public new ConfigurationCellCollection Cells => base.Cells as ConfigurationCellCollection;

        /// <summary>
        /// Gets or sets name of this configuration frame as assigned or useful in an end-use context.
        /// </summary>
        public virtual string Name { get; set; }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Calculates checksum of given <paramref name="buffer"/>.
        /// </summary>
        /// <param name="buffer">Buffer image over which to calculate checksum.</param>
        /// <param name="offset">Start index into <paramref name="buffer"/> to calculate checksum.</param>
        /// <param name="length">Length of data within <paramref name="buffer"/> to calculate checksum.</param>
        /// <returns>Checksum over specified portion of <paramref name="buffer"/>.</returns>
        protected override ushort CalculateChecksum(byte[] buffer, int offset, int length)
        {
            // Just returning calculated CRC-CCITT over given buffer as a default CRC
            return buffer.CrcCCITTChecksum(offset, length);
        }

        #endregion

        #region [ Static ]

        // Static Fields
        private static readonly ProcessQueue<Tuple<IConfigurationFrame, Action<Exception>, string>> s_configurationCacheQueue;
        private static string s_configurationCachePath;
        private static int s_configurationBackups;

        // Static Constructor
        static ConfigurationFrame()
        {
            s_configurationBackups = -1;
            s_configurationCacheQueue = ProcessQueue<Tuple<IConfigurationFrame, Action<Exception>, string>>.CreateRealTimeQueue(CacheConfigurationFile);
            s_configurationCacheQueue.SynchronizedOperationType = SynchronizedOperationType.LongBackground;
            s_configurationCacheQueue.Start();
        }

        // Static Properties

        /// <summary>
        /// Gets the path for storing serialized phasor protocol configurations.
        /// </summary>
        public static string ConfigurationCachePath
        {
            get
            {
                // This property will not change during system life-cycle so we cache if for future use
                if (string.IsNullOrEmpty(s_configurationCachePath))
                {
                    // Define default configuration cache directory relative to path of host application
                    s_configurationCachePath = string.Format("{0}{1}ConfigurationCache{1}", FilePath.GetAbsolutePath(""), Path.DirectorySeparatorChar);

                    // Make sure configuration cache path setting exists within system settings section of config file
                    ConfigurationFile configFile = ConfigurationFile.Current;
                    CategorizedSettingsElementCollection systemSettings = configFile.Settings["systemSettings"];
                    systemSettings.Add("ConfigurationCachePath", s_configurationCachePath, "Defines the path used to cache serialized phasor protocol configurations");

                    // Retrieve configuration cache directory as defined in the config file
                    s_configurationCachePath = FilePath.AddPathSuffix(systemSettings["ConfigurationCachePath"].Value);

                    // Make sure configuration cache directory exists
                    if (!Directory.Exists(s_configurationCachePath))
                        Directory.CreateDirectory(s_configurationCachePath);
                }

                return s_configurationCachePath;
            }
        }

        /// <summary>
        /// Gets total number of configuration backups to keep when storing serialized phasor protocol configurations.
        /// </summary>
        public static int ConfigurationBackups
        {
            get
            {
                if (s_configurationBackups == -1)
                {
                    const int DefaultConfigurationBackups = 5;

                    // Make sure configuration backups setting exists within system settings section of config file
                    ConfigurationFile configFile = ConfigurationFile.Current;
                    CategorizedSettingsElementCollection systemSettings = configFile.Settings["systemSettings"];
                    systemSettings.Add("ConfigurationBackups", DefaultConfigurationBackups, "Defines the total number of older backup configurations to maintain.");

                    // Retrieve configuration backups value as defined in the config file
                    s_configurationBackups = systemSettings["ConfigurationBackups"].ValueAs(DefaultConfigurationBackups);
                }

                return s_configurationBackups;
            }
        }

        // Static Methods

        /// <summary>
        /// Serializes configuration frame to cache folder on an independent thread for later use (if needed).
        /// </summary>
        /// <param name="configurationFrame">Reference to <see cref="IConfigurationFrame"/>.</param>
        /// <param name="exceptionHandler"><see cref="Action{T}"/> delegate to handle process exceptions.</param>
        /// <param name="configurationName"><see cref="string"/> representing the configuration name.</param>
        public static void Cache(IConfigurationFrame configurationFrame, Action<Exception> exceptionHandler, string configurationName)
        {
            Tuple<IConfigurationFrame, Action<Exception>, string> cacheState = new(configurationFrame, exceptionHandler, configurationName);
            s_configurationCacheQueue.Add(cacheState);
        }

        // Cache configuration file
        private static void CacheConfigurationFile(Tuple<IConfigurationFrame, Action<Exception>, string> args)
        {
            if (args is null)
                return;

            FileStream configFile = null;
            IConfigurationFrame configurationFrame = args.Item1;
            Action<Exception> exceptionHandler = args.Item2;
            string configurationName = args.Item3;
            string configurationCacheFileName = GetConfigurationCacheFileName(configurationName);

            try
            {
                // Create multiple backup configurations, if requested
                for (int i = ConfigurationBackups; i > 0; i--)
                {
                    string origConfigFile = $"{configurationCacheFileName}.backup{(i == 1 ? "" : (i - 1).ToString())}";

                    if (File.Exists(origConfigFile))
                    {
                        string nextConfigFile = $"{configurationCacheFileName}.backup{i}";

                        if (File.Exists(nextConfigFile))
                            File.Delete(nextConfigFile);

                        File.Move(origConfigFile, nextConfigFile);
                    }
                }
            }
            catch (Exception ex)
            {
                exceptionHandler(new InvalidOperationException($"Failed to create extra backup serialized configuration frames due to exception: {ex.Message}"));
            }

            try
            {
                if (ConfigurationBackups > 0)
                {
                    // Back up current configuration file, if any
                    if (File.Exists(configurationCacheFileName))
                    {
                        string backupConfigFile = $"{configurationCacheFileName}.backup";

                        if (File.Exists(backupConfigFile))
                            File.Delete(backupConfigFile);

                        File.Move(configurationCacheFileName, backupConfigFile);
                    }
                }
            }
            catch (Exception ex)
            {
                exceptionHandler(new InvalidOperationException($"Failed to backup last serialized configuration frame due to exception: {ex.Message}"));
            }

            try
            {
                // Serialize configuration frame to a file
                SoapFormatter xmlSerializer = new()
                {
                    AssemblyFormat = FormatterAssemblyStyle.Simple,
                    TypeFormat = FormatterTypeStyle.TypesWhenNeeded
                };

                configFile = File.Create(configurationCacheFileName);
                xmlSerializer.Serialize(configFile, configurationFrame);
            }
            catch (Exception ex)
            {
                exceptionHandler(new InvalidOperationException($"Failed to serialize configuration frame: {ex.Message}", ex));
            }
            finally
            {
                configFile?.Close();
            }
        }

        /// <summary>
        /// Gets the file name with path of the specified <paramref name="configurationName"/>.
        /// </summary>
        /// <param name="configurationName">Name of the configuration to get file name for.</param>
        /// <returns>File name with path of the specified <paramref name="configurationName"/>.</returns>
        public static string GetConfigurationCacheFileName(string configurationName)
        {
            return $"{ConfigurationCachePath}{configurationName.ReplaceCharacters('_', c => Path.GetInvalidFileNameChars().Contains(c))}.configuration.xml";
        }

        /// <summary>
        /// Deletes the cached configuration, if defined.
        /// </summary>
        /// <param name="configurationName">Name of the configuration to delete.</param>
        public static void DeleteCachedConfiguration(string configurationName)
        {
            string configFileName = GetConfigurationCacheFileName(configurationName);

            if (File.Exists(configFileName))
                File.Delete(configFileName);
        }

        /// <summary>
        /// Deserializes cached configuration, if available.
        /// </summary>
        /// <param name="configurationName">Name of the configuration to get file name for.</param>
        /// <param name="fromCache">Set to True retrieve from cache, False to retrieve from specified file name in <paramref name="configurationName"/></param>
        /// <returns>Cached configuration frame, or null if not available.</returns>
        public static IConfigurationFrame GetCachedConfiguration(string configurationName, bool fromCache)
        {
            IConfigurationFrame configFrame = null;
            string configFileName = fromCache ? GetConfigurationCacheFileName(configurationName) : configurationName;

            if (File.Exists(configFileName))
                configFrame = Common.DeserializeConfigurationFrame(configFileName);

            return configFrame;
        }

        #endregion
    }
}