//******************************************************************************************************
//  IIndependentAdapterManager.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.ObjectModel;
using System.Threading;
using GSF.Data;
using GSF.Diagnostics;
using GSF.Units.EE;

namespace GSF.TimeSeries.Adapters
{
    /// <summary>
    /// Represents the interface for implementations of independent adapter collection managers.
    /// </summary>
    public interface IIndependentAdapterManager : IAdapterCollection
    {
        /// <summary>
        /// Gets or sets the wait timeout, in milliseconds, that system wait for system configuration reload to complete.
        /// </summary>
        int ConfigurationReloadWaitTimeout { get; set; }

        /// <summary>
        /// Gets or sets the total number of attempts to wait for system configuration reloads when waiting for configuration updates to be available.
        /// </summary>
        int ConfigurationReloadWaitAttempts { get; set; }

        /// <summary>
        /// Gets or sets the connection string used for database operations. Leave blank to use local configuration database defined in "systemSettings".
        /// </summary>
        string DatabaseConnectionString { get; set; }

        /// <summary>
        /// Gets or sets the provider string used for database operations. Defaults to a SQL Server provider string.
        /// </summary>
        string DatabaseProviderString { get; set; }

        /// <summary>
        /// Gets or sets template for output measurement point tag names.
        /// </summary>
        string PointTagTemplate { get; set; }

        /// <summary>
        /// Gets or sets template for output measurement alternate tag names.
        /// </summary>
        string AlternateTagTemplate { get; set; }

        /// <summary>
        /// Gets or sets template for output measurement signal reference names.
        /// </summary>
        string SignalReferenceTemplate { get; set; }

        /// <summary>
        /// Gets or sets template for output measurement descriptions.
        /// </summary>
        string DescriptionTemplate { get; set; }

        /// <summary>
        /// Gets or sets template for the parent device acronym used to group associated output measurements.
        /// </summary>
        string ParentDeviceAcronymTemplate { get; set; }

        /// <summary>
        /// Gets or sets default signal type to use for all output measurements when <see cref="SignalTypes"/> array is not defined.
        /// </summary>
        SignalType SignalType { get; set; }

        /// <summary>
        /// Gets per adapter signal type for output measurements, used when each output needs to be a different type.
        /// </summary>
        SignalType[] SignalTypes { get; }

        /// <summary>
        /// Gets any custom adapter settings to be added to each adapter connection string. Can be used to add
        /// settings that are custom per adapter.
        /// </summary>
        string CustomAdapterSettings { get; }

        /// <summary>
        /// Gets or sets the target historian acronym for output measurements.
        /// </summary>
        string TargetHistorianAcronym { get; set; }

        /// <summary>
        /// Gets or sets the source measurement table to use for configuration.
        /// </summary>
        string SourceMeasurementTable { get; set; }

        /// <summary>
        /// Gets routing tables used by<see cref="IIndependentAdapterManager"/> instance.
        /// </summary>
        RoutingTables RoutingTables { get; set; }

        /// <summary>
        /// Gets original data member setting for <see cref="IIndependentAdapterManager"/> instance.
        /// </summary>
        string OriginalDataMember { get; set; }

        /// <summary>
        /// Gets or sets flag that determines if the <see cref="IndependentActionAdapterManagerBase{TAdapter}"/> instance
        /// <see cref="AdapterCollectionBase{T}.ConnectionString"/> should be automatically parsed every time the
        /// <see cref="AdapterCollectionBase{T}.DataSource"/> is updated without requiring adapter to be reinitialized.
        /// </summary>
        bool AutoReparseConnectionString { get; set; }

        /// <summary>
        /// Gets input measurement <see cref="SignalType"/>'s for each of the <see cref="AdapterBase.InputMeasurementKeys"/>, if any.
        /// </summary>
        SignalType[] InputMeasurementKeyTypes { get; }
        
        /// <summary>
        /// Gets output measurement <see cref="SignalType"/>'s for each of the <see cref="AdapterBase.OutputMeasurements"/>, if any.
        /// </summary>
        SignalType[] OutputMeasurementTypes { get; }

        /// <summary>
        /// Gets or sets wait handle used by <see cref="IndependentActionAdapterManagerBase{TAdapter}"/> instance to
        /// manage waiting for changes to be loaded in system configuration.
        /// </summary>
        ManualResetEventSlim ConfigurationReloadedWaitHandle { get; set; }

        /// <summary>
        /// Gets number of input measurement required by each adapter.
        /// </summary>
        int PerAdapterInputCount { get; }

        /// <summary>
        /// Gets or sets the index into the per adapter input measurements to use for target adapter name.
        /// </summary>
        int InputMeasurementIndexUsedForName { get; set; }

        /// <summary>
        /// Gets output measurement names to use for each adapter.
        /// </summary>
        ReadOnlyCollection<string> PerAdapterOutputNames { get; }

        /// <summary>
        /// Gets or sets current adapter ID counter.
        /// </summary>
        uint AdapterIDCounter { get; set; }

        /// <summary>
        /// Gets adapter index currently being processed.
        /// </summary>
        int CurrentAdapterIndex { get; }

        /// <summary>
        /// Gets adapter output index currently being processed.
        /// </summary>
        int CurrentOutputIndex { get; }

        /// <summary>
        /// Gets associated device ID for <see cref="CurrentAdapterIndex"/>, if any, for measurement generation.
        /// </summary>
        int CurrentDeviceID { get; }

        /// <summary>
        /// Parses connection string. Derived classes should override for custom connection string parsing.
        /// </summary>
        void ParseConnectionString();
        
        /// <summary>
        /// Notifies derived classes that configuration has been reloaded.
        /// </summary>
        void ConfigurationReloaded();

        /// <summary>
        /// Recalculates routing tables.
        /// </summary>
        void RecalculateRoutingTables();

        /// <summary>
        /// Gets configured database connection.
        /// </summary>
        /// <returns>New ADO data connection based on configured settings.</returns>
        AdoDataConnection GetConfiguredConnection();

        /// <summary>
        /// Enumerates child adapters
        /// </summary>
        void EnumerateAdapters();

        /// <summary>
        /// Gets subscriber information for specified client connection.
        /// </summary>
        /// <param name="adapterIndex">Enumerated index for child adapter.</param>
        /// <returns>Status for adapter with specified <paramref name="adapterIndex"/>.</returns>
        string GetAdapterStatus(int adapterIndex);

        /// <summary>
        /// Raises <see cref="AdapterCollectionBase{T}.ConfigurationChanged"/> event.
        /// </summary>
        void OnConfigurationChanged();

        /// <summary>
        /// Raises <see cref="AdapterCollectionBase{T}.InputMeasurementKeysUpdated"/> event.
        /// </summary>
        void OnInputMeasurementKeysUpdated();

        /// <summary>
        /// Raises the <see cref="AdapterCollectionBase{T}.StatusMessage"/> event and sends this data to the <see cref="Logger"/>.
        /// </summary>
        /// <param name="level">The <see cref="MessageLevel"/> to assign to this message</param>
        /// <param name="status">New status message.</param>
        /// <param name="eventName">A fixed string to classify this event; defaults to <c>null</c>.</param>
        /// <param name="flags"><see cref="MessageFlags"/> to use, if any; defaults to <see cref="MessageFlags.None"/>.</param>
        /// <remarks>
        /// <see pref="eventName"/> should be a constant string value associated with what type of message is being
        /// generated. In general, there should only be a few dozen distinct event names per class. Exceeding this
        /// threshold will cause the EventName to be replaced with a general warning that a usage issue has occurred.
        /// </remarks>
        void OnStatusMessage(MessageLevel level, string status, string eventName = null, MessageFlags flags = MessageFlags.None);

        /// <summary>
        /// Raises the <see cref="AdapterCollectionBase{T}.ProcessException"/> event.
        /// </summary>
        /// <param name="level">The <see cref="MessageLevel"/> to assign to this message</param>
        /// <param name="exception">Processing <see cref="Exception"/>.</param>
        /// <param name="eventName">A fixed string to classify this event; defaults to <c>null</c>.</param>
        /// <param name="flags"><see cref="MessageFlags"/> to use, if any; defaults to <see cref="MessageFlags.None"/>.</param>
        /// <remarks>
        /// <see pref="eventName"/> should be a constant string value associated with what type of message is being
        /// generated. In general, there should only be a few dozen distinct event names per class. Exceeding this
        /// threshold will cause the EventName to be replaced with a general warning that a usage issue has occurred.
        /// </remarks>
        void OnProcessException(MessageLevel level, Exception exception, string eventName = null, MessageFlags flags = MessageFlags.None);
    }
}