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

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading;
using GSF.Data;
using GSF.Diagnostics;
using ConnectionStringParser = GSF.Configuration.ConnectionStringParser<GSF.TimeSeries.Adapters.ConnectionStringParameterAttribute>;

namespace GSF.TimeSeries.Adapters
{
    // Common implementation extension handlers for independent adapter collection managers.
    internal static class IndependentAdapterManagerHandlers
    {
        /// <summary>
        /// Handles construction steps for a new <see cref="IIndependentAdapterManager"/> instance.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        public static void HandleConstruct(this IIndependentAdapterManager instance)
        {
            bool needsRouting = true;

            instance.OriginalDataMember = instance.DataMember;
            instance.DataMember = "[internal]";
            instance.Name = $"{instance.GetType().Name} Collection";

            // ReSharper disable SuspiciousTypeConversion.Global
            switch (instance)
            {
                case ActionAdapterCollection actionAdapterCollection:
                    instance.RoutingTables = new RoutingTables { ActionAdapters = actionAdapterCollection };
                    break;
                case OutputAdapterCollection outputAdapterCollection:
                    instance.RoutingTables = new RoutingTables { OutputAdapters = outputAdapterCollection };
                    break;
                case InputAdapterCollection _:
                    needsRouting = false;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(instance));
            }
            // ReSharper restore SuspiciousTypeConversion.Global

            if (needsRouting)
            {
                instance.RoutingTables.StatusMessage += RoutingTables_StatusMessage;
                instance.RoutingTables.ProcessException += RoutingTables_ProcessException;

                // Make sure routes are recalculated any time measurements are updated
                instance.InputMeasurementKeysUpdated += Instance_InputMeasurementKeysUpdated;
            }

            instance.ConfigurationReloadedWaitHandle = new ManualResetEventSlim();
        }

        /// <summary>
        /// Disposes resources used by the <see cref="IIndependentAdapterManager"/> instance.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        public static void HandleDispose(this IIndependentAdapterManager instance)
        {
            if (instance.RoutingTables != null)
            {
                instance.InputMeasurementKeysUpdated -= Instance_InputMeasurementKeysUpdated;

                instance.RoutingTables.StatusMessage -= RoutingTables_StatusMessage;
                instance.RoutingTables.ProcessException -= RoutingTables_ProcessException;
                instance.RoutingTables.Dispose();
            }

            if (instance.ConfigurationReloadedWaitHandle != null)
            {
                instance.ConfigurationReloadedWaitHandle.Set();
                instance.ConfigurationReloadedWaitHandle.Dispose();
            }
        }

        /// <summary>
        /// Initializes the <see cref="IndependentAdapterManagerExtensions" />.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        public static void HandleInitialize(this IIndependentAdapterManager instance)
        {
            // We don't call base class initialize since it tries to auto-load adapters from the defined
            // data member - instead, the multi-adapter class implementation manages its own adapters
            instance.Initialized = false;

            instance.ParseConnectionString();

            if (instance.ConfigurationReloadWaitTimeout < 0)
                instance.ConfigurationReloadWaitTimeout = 0;

            if (instance.InputMeasurementIndexUsedForName < 0 || instance.InputMeasurementIndexUsedForName > instance.PerAdapterInputCount - 1)
                instance.InputMeasurementIndexUsedForName = 0;

            if (instance.SignalTypes != null && instance.SignalTypes.Length < instance.PerAdapterOutputNames.Count)
            {
                instance.OnProcessException(MessageLevel.Warning, new InvalidOperationException($"Defined {nameof(IIndependentAdapterManager.SignalTypes)} array length for adapter \"{instance.Name}\" does not match {nameof(IIndependentAdapterManager.PerAdapterOutputNames)} array length."));
                return;
            }

            instance.Initialized = true;
        }

        /// <summary>
        /// Sets <see cref="DataSet"/> based data source used to load each <see cref="IAdapter"/>. Updates to this
        /// property will cascade to all adapters in this <see cref="IndependentAdapterManagerExtensions"/> instance.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        public static void HandleUpdateDataSource(this IIndependentAdapterManager instance)
        {
            // Notify any waiting threads that configuration has been reloaded
            instance.ConfigurationReloadedWaitHandle.Set();

            // Update routes for configuration reload
            instance.RoutingTables?.CalculateRoutingTables(null);

            if (instance.AutoReparseConnectionString)
            {
                // Lookup adapter configuration record
                DataRow[] records = instance.DataSource.Tables[instance.OriginalDataMember].Select($"AdapterName = '{instance.Name}'");

                if (records.Length > 0)
                {
                    // Parsing connection string after any updates will parse input measurement keys causing
                    // a request to update measurements routed to adapter. Derived implementations can then
                    // use DataSourceChanged notification to add or remove child adapters as needed.
                    instance.ConnectionString = records[0]["ConnectionString"].ToNonNullString();
                    instance.ParseConnectionString();
                }
                else
                {
                    instance.OnStatusMessage(MessageLevel.Warning, $"Failed to find adapter \"{instance.Name}\" in \"{instance.OriginalDataMember}\" configuration table. Cannot reload connection string parameters.");
                }
            }

            instance.ConfigurationReloaded();
        }

        /// <summary>
        /// Returns the detailed status for the <see cref="IIndependentAdapterManager"/> instance.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        public static string HandleStatus(this IIndependentAdapterManager instance)
        {
            const int MaxMeasurementsToShow = 10;

            StringBuilder status = new StringBuilder();

            status.AppendLine($"        Point Tag Template: {instance.PointTagTemplate}");
            status.AppendLine($"    Alternate Tag Template: {instance.AlternateTagTemplate}");
            status.AppendLine($" Signal Reference Template: {instance.SignalReferenceTemplate}");
            status.AppendLine($"      Description Template: {instance.DescriptionTemplate}");
            status.AppendLine($"   Device Acronym Template: {instance.ParentDeviceAcronymTemplate}");
            status.AppendLine($"        Output Signal Type: {instance.SignalType}");
            status.AppendLine($"  Target Historian Acronym: {instance.TargetHistorianAcronym}");
            status.AppendLine($"  Source Measurement Table: {instance.SourceMeasurementTable}");
            status.AppendLine($"        Inputs per Adapter: {instance.PerAdapterInputCount:N0}");
            status.AppendLine($" Input Index Used for Name: {instance.InputMeasurementIndexUsedForName:N0}");
            status.AppendLine($"  Output Names per Adapter: {instance.PerAdapterOutputNames.Count:N0}");

            foreach (string outputName in instance.PerAdapterOutputNames)
                status.AppendLine($"                  \"{outputName.TruncateRight(40)}\"");

            status.AppendLine($"Re-parse Connection String: {instance.AutoReparseConnectionString}");
            status.AppendLine($"      Original Data Member: {instance.OriginalDataMember}");
            status.AppendLine($"     Config Reload Timeout: {instance.ConfigurationReloadWaitTimeout:N0} ms");
            status.AppendLine($"    Config Reload Attempts: {instance.ConfigurationReloadWaitAttempts:N0}");
            status.AppendLine($"Database Connection String: {(string.IsNullOrWhiteSpace(instance.DatabaseConnectionString) ? "Using <systemSettings>" : instance.DatabaseConnectionString.TruncateRight(40))}");
            
            if (!string.IsNullOrWhiteSpace(instance.DatabaseConnectionString))
                status.AppendLine($"  Custom Database Provider: {instance.DatabaseProviderString ?? ""}");

            if (instance.OutputMeasurements != null && instance.OutputMeasurements.Length > instance.OutputMeasurements.Count(m => m.Key == MeasurementKey.Undefined))
            {
                status.AppendLine($"       Output measurements: {instance.OutputMeasurements.Length:N0} defined measurements");
                status.AppendLine();

                for (int i = 0; i < Math.Min(instance.OutputMeasurements.Length, MaxMeasurementsToShow); i++)
                {
                    status.Append(instance.OutputMeasurements[i].ToString().TruncateRight(40).PadLeft(40));
                    status.Append(" ");
                    status.AppendLine(instance.OutputMeasurements[i].ID.ToString());
                }

                if (instance.OutputMeasurements.Length > MaxMeasurementsToShow)
                    status.AppendLine("...".PadLeft(26));

                status.AppendLine();
            }

            if (instance.InputMeasurementKeys != null && instance.InputMeasurementKeys.Length > instance.InputMeasurementKeys.Count(k => k == MeasurementKey.Undefined))
            {
                status.AppendLine($"        Input measurements: {instance.InputMeasurementKeys.Length:N0} defined measurements");
                status.AppendLine();

                for (int i = 0; i < Math.Min(instance.InputMeasurementKeys.Length, MaxMeasurementsToShow); i++)
                    status.AppendLine(instance.InputMeasurementKeys[i].ToString().TruncateRight(25).CenterText(50));

                if (instance.InputMeasurementKeys.Length > MaxMeasurementsToShow)
                    status.AppendLine("...".CenterText(50));

                status.AppendLine();
            }

            return status.ToString();
        }

        /// <summary>
        /// Parses connection string. Derived classes should override for custom connection string parsing.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        public static void HandleParseConnectionString(this IIndependentAdapterManager instance)
        {
            // Parse all properties marked with ConnectionStringParameterAttribute from provided ConnectionString value
            ConnectionStringParser parser = new ConnectionStringParser();
            parser.ParseConnectionString(instance.ConnectionString, instance);

            // Parse input measurement keys like class was a typical adapter
            if (instance.Settings.TryGetValue(nameof(instance.InputMeasurementKeys), out string setting))
                instance.InputMeasurementKeys = AdapterBase.ParseInputMeasurementKeys(instance.DataSource, true, setting, instance.SourceMeasurementTable);

            // Parse output measurement keys like class was a typical adapter
            if (instance.Settings.TryGetValue(nameof(instance.OutputMeasurements), out setting))
                instance.OutputMeasurements = AdapterBase.ParseOutputMeasurements(instance.DataSource, true, setting, instance.SourceMeasurementTable);
        }
        
        /// <summary>
        /// Validates that an even number of inputs are provided for specified <see cref="IIndependentAdapterManager.PerAdapterInputCount"/>.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        public static void HandleValidateEvenInputCount(this IIndependentAdapterManager instance)
        {
            int remainder = instance.InputMeasurementKeys.Length % instance.PerAdapterInputCount;

            if (remainder == 0)
                return;

            int adjustedCount = instance.InputMeasurementKeys.Length - remainder;
            instance.OnStatusMessage(MessageLevel.Warning, $"Uneven number of inputs provided, adjusting total number of inputs to {adjustedCount:N0}. Expected {instance.PerAdapterInputCount:N0} per adapter, received {instance.InputMeasurementKeys.Length:N0} total measurements, leaving {instance.PerAdapterInputCount - remainder:N0} needed.");
            instance.InputMeasurementKeys = instance.InputMeasurementKeys.Take(adjustedCount).ToArray();
        }

        /// <summary>
        /// Recalculates routing tables.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        public static void HandleRecalculateRoutingTables(this IIndependentAdapterManager instance) => instance.OnInputMeasurementKeysUpdated(); // Requests route recalculation by IonSession

        /// <summary>
        /// Queues a collection of measurements for processing to each <see cref="IAdapter"/> connected to this <see cref="IndependentAdapterManagerExtensions"/>.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        /// <param name="measurements">Measurements to queue for processing.</param>
        public static void HandleQueueMeasurementsForProcessing(this IIndependentAdapterManager instance, IEnumerable<IMeasurement> measurements)
        {
            if (instance.RoutingTables == null)
                return;

            // Pass measurements coming into parent collection adapter to routing tables for individual child adapter distribution
            IList<IMeasurement> measurementList = measurements as IList<IMeasurement> ?? measurements.ToList();
            instance.RoutingTables.InjectMeasurements(instance, new EventArgs<ICollection<IMeasurement>>(measurementList));
        }

        /// <summary>
        /// Gets a short one-line status of this <see cref="IndependentAdapterManagerExtensions"/>.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        /// <param name="maxLength">Maximum number of available characters for display.</param>
        /// <returns>A short one-line summary of the current status of the <see cref="IndependentAdapterManagerExtensions"/>.</returns>
        public static string HandleGetShortStatus(this IIndependentAdapterManager instance, int maxLength)
        {
            if (instance.Enabled)
                return $"Processing enabled for {instance.Count:N0} adapters.".CenterText(maxLength);

            return "Processing not enabled".CenterText(maxLength);
        }

        /// <summary>
        /// Enumerates child adapters.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        public static void HandleEnumerateAdapters(this IIndependentAdapterManager instance)
        {
            StringBuilder enumeratedAdapters = new StringBuilder();
            IAdapter[] adapters = instance.ToArray();

            enumeratedAdapters.AppendLine($"{instance.Name} Indexed Adapter Enumeration - {adapters.Length:N0} Total:\r\n");

            for (int i = 0; i < adapters.Length; i++)
                enumeratedAdapters.AppendLine($"{i.ToString("N0").PadLeft(5)}: {adapters[i].Name}".TrimWithEllipsisMiddle(79));

            instance.OnStatusMessage(MessageLevel.Info, enumeratedAdapters.ToString());
        }

        /// <summary>
        /// Gets subscriber information for specified client connection.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        /// <param name="adapterIndex">Enumerated index for child adapter.</param>
        public static string HandleGetAdapterStatus(this IIndependentAdapterManager instance, int adapterIndex) => instance[adapterIndex].Status;

        /// <summary>
        /// Gets configured database connection.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        /// <returns>New ADO data connection based on configured settings.</returns>
        public static AdoDataConnection HandleGetConfiguredConnection(this IIndependentAdapterManager instance) => string.IsNullOrWhiteSpace(instance.DatabaseConnectionString) ?
            new AdoDataConnection("systemSettings") :
            new AdoDataConnection(instance.DatabaseConnectionString, instance.DatabaseProviderString);

        /// <summary>
        /// Determines whether the data in the data source has actually changed when receiving a new data source.
        /// </summary>
        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>
        /// <param name="newDataSource">New data source to check.</param>
        /// <returns><c>true</c> if data source has changed; otherwise, <c>false</c>.</returns>
        public static bool DataSourceChanged(this IIndependentAdapterManager instance, DataSet newDataSource)
        {
            try
            {
                return !DataSetEqualityComparer.Default.Equals(instance.DataSource, newDataSource);
            }
            catch
            {
                // Function is for optimization, reason for failure is irrelevant
                return true;
            }
        }

        // Make sure routes are recalculated any time measurements are updated
        private static void Instance_InputMeasurementKeysUpdated(object sender, EventArgs e)
        {
            if (sender is IIndependentAdapterManager instance)
                instance.RoutingTables?.CalculateRoutingTables(null);
        }

        // Make sure to expose any routing table messages
        private static void RoutingTables_StatusMessage(object sender, EventArgs<string> e)
        {
            if (sender is RoutingTables routingTables)
            {
                IIndependentAdapterManager instance =
                    routingTables.ActionAdapters as IIndependentAdapterManager ??
                    routingTables.OutputAdapters as IIndependentAdapterManager;

                instance?.OnStatusMessage(MessageLevel.Info, e.Argument);
            }
        }

        // Make sure to expose any routing table exceptions
        private static void RoutingTables_ProcessException(object sender, EventArgs<Exception> e)
        {
            if (sender is RoutingTables routingTables)
            {
                IIndependentAdapterManager instance =
                    routingTables.ActionAdapters as IIndependentAdapterManager ??
                    routingTables.OutputAdapters as IIndependentAdapterManager;

                instance?.OnProcessException(MessageLevel.Warning, e.Argument);
            }
        }
    }
}