//******************************************************************************************************
//  Trackable.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 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:
//  ----------------------------------------------------------------------------------------------------
//  07/07/2016 - Stephen C. Wills
//       Generated original version of source code.
//
//******************************************************************************************************

using System.Collections.Generic;
using System.Linq;

namespace GSF
{
    /// <summary>
    /// Represents the change history for a property.
    /// </summary>
    /// <remarks>
    /// <para>
    /// This class is primarily designed to track changes to the
    /// property of an object, as in the following example.
    /// </para>
    /// 
    /// <code>
    /// public class MyClass
    /// {
    ///     private Trackable&lt;string&gt; m_trackableText = new Trackable&lt;string&gt;(nameof(Text), true);
    ///     
    ///     public string Text
    ///     {
    ///         get
    ///         {
    ///             return m_trackableText.CurrentValue;
    ///         }
    ///         set
    ///         {
    ///             m_trackableText.CurrentValue = value;
    ///         }
    ///     }
    /// }
    /// </code>
    /// </remarks>
    public class Trackable<T> : ITrackable
    {
        #region [ Members ]

        // Fields
        private string m_propertyName;
        private T m_initialValue;
        private List<T> m_changeList;
        private bool m_autoTrack;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new instance of the <see cref="Trackable{T}"/> class.
        /// </summary>
        /// <param name="propertyName">The name of the property being tracked.</param>
        /// <param name="autoTrack">Determines the behavior of the setter for the <see cref="CurrentValue"/> property. Set to false to track only the original and current values.</param>
        public Trackable(string propertyName, bool autoTrack)
            : this(propertyName, default(T), autoTrack)
        {
        }

        /// <summary>
        /// Creates a new instance of the <see cref="Trackable{T}"/> class.
        /// </summary>
        /// <param name="propertyName">The name of the property being tracked.</param>
        /// <param name="initialValue">The initial value of the property.</param>
        /// <param name="autoTrack">Determines the behavior of the setter for the <see cref="CurrentValue"/> property. Set to false to track only the original and current values.</param>
        public Trackable(string propertyName, T initialValue = default(T), bool autoTrack = false)
        {
            m_propertyName = propertyName;
            m_initialValue = initialValue;
            m_changeList = new List<T>() { initialValue };
            m_autoTrack = autoTrack;
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets the name of the property being tracked.
        /// </summary>
        public string PropertyName
        {
            get
            {
                return m_propertyName;
            }
        }

        /// <summary>
        /// Gets or sets the current value after all changes have been applied to the property.
        /// </summary>
        public T CurrentValue
        {
            get
            {
                return ChangeList.Last();
            }
            set
            {
                SetCurrentValue(value, !m_autoTrack);
            }
        }

        /// <summary>
        /// Gets the original value before the first change was made to the property.
        /// </summary>
        public T OriginalValue
        {
            get
            {
                return ChangeList.First();
            }
        }

        /// <summary>
        /// Gets a value to indicate whether the property's value has been
        /// changed since the last time the current value was committed.
        /// </summary>
        public bool IsChanged
        {
            get
            {
                return !Equals(OriginalValue, CurrentValue);
            }
        }

        /// <summary>
        /// Gets the list of changes to the property's value,
        /// starting from its original value and up to the current value.
        /// </summary>
        public List<T> ChangeList
        {
            get
            {
                if (m_changeList.Count == 0)
                    m_changeList.Add(m_initialValue);

                return m_changeList;
            }
        }

        /// <summary>
        /// Gets the original value before the first change was made to the property.
        /// </summary>
        object ITrackable.OriginalValue
        {
            get
            {
                return OriginalValue;
            }
        }

        /// <summary>
        /// Gets the current value after all changes have been applied to the property.
        /// </summary>
        object ITrackable.CurrentValue
        {
            get
            {
                return CurrentValue;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Sets the current value of the property.
        /// </summary>
        /// <param name="value">The new value of the property.</param>
        /// <param name="overwrite">True to track the change; false to overwrite the previous change. Does not overwrite the original value.</param>
        public void SetCurrentValue(T value, bool overwrite)
        {
            if (overwrite && m_changeList.Count > 1)
                m_changeList.RemoveAt(m_changeList.Count - 1);

            if (Equals(CurrentValue, value))
                return;

            m_changeList.Add(value);
        }

        /// <summary>
        /// Erases all history in the change list and commits
        /// the current value as the new original value.
        /// </summary>
        public void AcceptChanges()
        {
            T currentValue = CurrentValue;
            m_changeList.Clear();
            m_changeList.Add(currentValue);
        }

        /// <summary>
        /// Erases all history in the change list and reverts
        /// to the original value before the changes were made.
        /// </summary>
        public void Revert()
        {
            T originalValue = OriginalValue;
            m_changeList.Clear();
            m_changeList.Add(originalValue);
        }

        /// <summary>
        /// Erases all history in the change list and sets
        /// the original value back to its initial value.
        /// </summary>
        public void Reset()
        {
            m_changeList.Clear();
            m_changeList.Add(m_initialValue);
        }

        /// <summary>
        /// Returns a string that represents the current value.
        /// </summary>
        /// <returns>A string that represents the current value.</returns>
        public override string ToString()
        {
            return CurrentValue.ToString();
        }

        #endregion
    }
}