//******************************************************************************************************
//  ReplicationProviderBase.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:
//  ----------------------------------------------------------------------------------------------------
//  11/04/2009 - Pinal C. Patel
//       Generated original version of source code.
//  11/17/2009 - Pinal C. Patel
//       Made Initialize(), SaveSettings() and LoadSettings() overridable in a derived class.
//  03/30/2010 - Pinal C. Patel
//       Corrected the usage of Enabled in Replicate().
//  10/11/2010 - Mihir Brahmbhatt
//       Updated header and license agreement.
//  12/14/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using System;
using System.Configuration;
using System.Threading;
using System.Timers;
using GSF.Adapters;
using GSF.Configuration;
using Timer = System.Timers.Timer;

namespace GSF.Historian.Replication
{
    /// <summary>
    /// Base class for a provider of replication mechanism for the <see cref="IArchive"/>.
    /// </summary>
    public abstract class ReplicationProviderBase : Adapter, IReplicationProvider
    {
        #region [ Members ]

        // Events

        /// <summary>
        /// Occurs when the process of replicating the <see cref="IArchive"/> is started.
        /// </summary>
        public event EventHandler ReplicationStart;

        /// <summary>
        /// Occurs when the process of replicating the <see cref="IArchive"/> is complete.
        /// </summary>
        public event EventHandler ReplicationComplete;

        /// <summary>
        /// Occurs when an <see cref="Exception"/> is encountered during the replication process of <see cref="IArchive"/>.
        /// </summary>
        public event EventHandler<EventArgs<Exception>> ReplicationException;

        /// <summary>
        /// Occurs when the <see cref="IArchive"/> is being replicated.
        /// </summary>
        public event EventHandler<EventArgs<ProcessProgress<int>>> ReplicationProgress;

        // Fields
        private string m_archiveLocation;
        private string m_replicaLocation;
        private int m_replicationInterval;
        private Thread m_replicationThread;
        private Timer m_replicationTimer;
        private bool m_initialized;
        private bool m_disposed;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Initializes a new instance of the replication provider.
        /// </summary>
        protected ReplicationProviderBase()
        {
            m_replicationInterval = -1;
            PersistSettings = true;
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets or sets the primary location of the <see cref="IArchive"/>.
        /// </summary>
        public string ArchiveLocation
        {
            get
            {
                return m_archiveLocation;
            }
            set
            {
                m_archiveLocation = value;
            }
        }

        /// <summary>
        /// Gets or sets the mirrored location of the <see cref="IArchive"/>.
        /// </summary>
        public string ReplicaLocation
        {
            get
            {
                return m_replicaLocation;
            }
            set
            {
                m_replicaLocation = value;
            }
        }

        /// <summary>
        /// Gets or sets the interval in minutes at which the <see cref="IArchive"/> is to be replicated.
        /// </summary>
        public int ReplicationInterval
        {
            get
            {
                return m_replicationInterval;
            }
            set
            {
                if (value < 0)
                    m_replicationInterval = -1;
                else
                    m_replicationInterval = value;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// When overridden in a derived class, replicates the <see cref="IArchive"/>.
        /// </summary>
        protected abstract void ReplicateArchive();

        /// <summary>
        /// Initializes the replication provider.
        /// </summary>
        public override void Initialize()
        {
            base.Initialize();

            if (!m_initialized)
            {
                // Start timer for periodic replication.
                if (Enabled && m_replicationInterval > 0)
                {
                    m_replicationTimer = new Timer(m_replicationInterval * 60000);
                    m_replicationTimer.Elapsed += ReplicationTimer_Elapsed;
                    m_replicationTimer.Start();
                }

                // Initialize only once.
                m_initialized = true;
            }
        }

        /// <summary>
        /// Saves replication provider settings to the config file if the <see cref="Adapter.PersistSettings"/> property is set to true.
        /// </summary>
        /// <exception cref="ConfigurationErrorsException"><see cref="Adapter.SettingsCategory"/> has a value of null or empty string.</exception>
        public override void SaveSettings()
        {
            base.SaveSettings();

            if (PersistSettings)
            {
                // Save settings under the specified category.
                ConfigurationFile config = ConfigurationFile.Current;
                CategorizedSettingsElementCollection settings = config.Settings[SettingsCategory];
                settings["Enabled", true].Update(Enabled);
                settings["ArchiveLocation", true].Update(m_archiveLocation);
                settings["ReplicaLocation", true].Update(m_replicaLocation);
                settings["ReplicationInterval", true].Update(m_replicationInterval);
                config.Save();
            }
        }

        /// <summary>
        /// Loads saved replication provider settings from the config file if the <see cref="Adapter.PersistSettings"/> property is set to true.
        /// </summary>
        /// <exception cref="ConfigurationErrorsException"><see cref="Adapter.SettingsCategory"/> has a value of null or empty string.</exception>
        public override void LoadSettings()
        {
            base.LoadSettings();

            if (PersistSettings)
            {
                // Load settings from the specified category.
                ConfigurationFile config = ConfigurationFile.Current;
                CategorizedSettingsElementCollection settings = config.Settings[SettingsCategory];
                settings.Add("Enabled", Enabled, "True if this replication provider is enabled; otherwise False.");
                settings.Add("ArchiveLocation", m_archiveLocation, "Path to the primary location of time-series data archive.");
                settings.Add("ReplicaLocation", m_replicaLocation, "Path to the mirrored location of time-series data archive.");
                settings.Add("ReplicationInterval", m_replicationInterval, "Interval in minutes at which the time-series data archive is to be replicated.");
                Enabled = settings["Enabled"].ValueAs(Enabled);
                ArchiveLocation = settings["ArchiveLocation"].ValueAs(m_archiveLocation);
                ReplicaLocation = settings["ReplicaLocation"].ValueAs(m_replicaLocation);
                ReplicationInterval = settings["ReplicationInterval"].ValueAs(m_replicationInterval);
            }
        }

        /// <summary>
        /// Replicates the <see cref="IArchive"/>.
        /// </summary>
        /// <returns>true if the replication is successful; otherwise false.</returns>
        /// <exception cref="ArgumentNullException"><see cref="ArchiveLocation"/> or <see cref="ReplicaLocation"/> is null or empty string.</exception>
        public bool Replicate()
        {
            if (!Enabled || (m_replicationThread != null && m_replicationThread.IsAlive))
                return false;

            if (string.IsNullOrEmpty(m_archiveLocation))
                throw new ArgumentNullException("ArchiveLocation");

            if (string.IsNullOrEmpty(m_replicaLocation))
                throw new ArgumentNullException("ReplicaLocation");

            m_replicationThread = new Thread(ReplicateInternal);
            m_replicationThread.Start();
            m_replicationThread.Join();

            return true;
        }

        /// <summary>
        /// Releases the unmanaged resources used by the replication provider and optionally releases the managed resources.
        /// </summary>
        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
        protected override void Dispose(bool disposing)
        {
            if (!m_disposed)
            {
                try
                {
                    // This will be done regardless of whether the object is finalized or disposed.				
                    if (disposing)
                    {
                        if (m_replicationThread != null)
                            m_replicationThread.Abort();

                        if (m_replicationTimer != null)
                        {
                            m_replicationTimer.Elapsed -= ReplicationTimer_Elapsed;
                            m_replicationTimer.Dispose();
                        }
                    }
                }
                finally
                {
                    m_disposed = true;  // Prevent duplicate dispose.
                    base.Dispose(disposing);
                }
            }
        }

        /// <summary>
        /// Raises the <see cref="ReplicationStart"/> event.
        /// </summary>
        protected virtual void OnReplicationStart()
        {
            if (ReplicationStart != null)
                ReplicationStart(this, EventArgs.Empty);
        }

        /// <summary>
        /// Raises the <see cref="ReplicationComplete"/> event.
        /// </summary>
        protected virtual void OnReplicationComplete()
        {
            if (ReplicationComplete != null)
                ReplicationComplete(this, EventArgs.Empty);
        }

        /// <summary>
        /// Raises the <see cref="ReplicationException"/> event.
        /// </summary>
        /// <param name="ex"><see cref="Exception"/> to send to <see cref="ReplicationException"/> event.</param>
        protected virtual void OnReplicationException(Exception ex)
        {
            if (ReplicationException != null)
                ReplicationException(this, new EventArgs<Exception>(ex));
        }

        /// <summary>
        /// Raises the <see cref="ReplicationProgress"/> event.
        /// </summary>
        /// <param name="replicationProgress"><see cref="ProcessProgress{T}"/> to send to <see cref="ReplicationProgress"/> event.</param>
        protected virtual void OnReplicationProgress(ProcessProgress<int> replicationProgress)
        {
            if (ReplicationProgress != null)
                ReplicationProgress(this, new EventArgs<ProcessProgress<int>>(replicationProgress));
        }

        private void ReplicateInternal()
        {
            try
            {
                OnReplicationStart();
                ReplicateArchive();
                OnReplicationComplete();
            }
            catch (Exception ex)
            {
                OnReplicationException(ex);
            }
        }

        private void ReplicationTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            Replicate();
        }

        #endregion
    }
}