using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using Swan.Formatters;
using Swan.Reflection;

namespace Swan.Configuration
{
    /// <summary>
    /// Represents a provider to save and load settings using a plain JSON file.
    /// </summary>
    /// <example>
    /// The following example shows how to save and load settings.
    /// <code>
    /// using Swan.Configuration;
    /// 
    /// public class Example
    /// { 
    ///     public static void Main()
    ///     {
    ///         // get user from settings
    ///         var user = SettingsProvider&lt;Settings&gt;.Instance.Global.User;
    ///             
    ///         // modify the port
    ///         SettingsProvider&lt;Settings&gt;.Instance.Global.Port = 20;
    ///             
    ///         // if we want these settings to persist
    ///         SettingsProvider&lt;Settings&gt;.Instance.PersistGlobalSettings();
    ///     }
    ///         
    ///     public class Settings
    ///     {
    ///         public int Port { get; set; } = 9696;
    ///         
    ///         public string User { get; set; } = "User";
    ///     }
    /// }
    /// </code>
    /// </example>
    /// <typeparam name="T">The type of settings model.</typeparam>
    public sealed class SettingsProvider<T>    : SingletonBase<SettingsProvider<T>>
    {
        private readonly Object _syncRoot = new Object();

        private T _global;

        /// <summary>
        /// Gets or sets the configuration file path. By default the entry assembly directory is used
        /// and the filename is 'appsettings.json'.
        /// </summary>
        /// <value>
        /// The configuration file path.
        /// </value>
        public String ConfigurationFilePath { get; set; } =            Path.Combine(SwanRuntime.EntryAssemblyDirectory, "appsettings.json");

        /// <summary>
        /// Gets the global settings object.
        /// </summary>
        /// <value>
        /// The global settings object.
        /// </value>
        public T Global
        {
            get
            {
                lock (this._syncRoot)
                {
                    if (Equals(this._global, default(T)!)) {
            this.ReloadGlobalSettings();
          }

          return this._global;
                }
            }
        }

        /// <summary>
        /// Reloads the global settings.
        /// </summary>
        public void ReloadGlobalSettings()
        {
            if (File.Exists(this.ConfigurationFilePath) == false || File.ReadAllText(this.ConfigurationFilePath).Length == 0)
            {
        this.ResetGlobalSettings();
                return;
            }

            lock (this._syncRoot) {
        this._global = Json.Deserialize<T>(File.ReadAllText(this.ConfigurationFilePath));
      }
    }

        /// <summary>
        /// Persists the global settings.
        /// </summary>
        public void PersistGlobalSettings() => File.WriteAllText(this.ConfigurationFilePath, Json.Serialize(this.Global, true));

        /// <summary>
        /// Updates settings from list.
        /// </summary>
        /// <param name="propertyList">The list.</param>
        /// <returns>
        /// A list of settings of type ref="ExtendedPropertyInfo".
        /// </returns>
        /// <exception cref="ArgumentNullException">propertyList.</exception>
        public List<String> RefreshFromList(List<ExtendedPropertyInfo<T>> propertyList)
        {
            if (propertyList == null) {
        throw new ArgumentNullException(nameof(propertyList));
      }

      List<String> changedSettings = new List<global::System.String>();
      IEnumerable<PropertyInfo> globalProps = PropertyTypeCache.DefaultCache.Value.RetrieveAllProperties<T>();

            foreach (ExtendedPropertyInfo<T> property in propertyList)
            {
        PropertyInfo propertyInfo = globalProps.FirstOrDefault(x => x.Name == property.Property);

                if (propertyInfo == null) {
          continue;
        }

        Object originalValue = propertyInfo.GetValue(this.Global);
        Boolean isChanged = propertyInfo.PropertyType.IsArray
                    ? property.Value is IEnumerable enumerable && propertyInfo.TrySetArray(enumerable.Cast<Object>(), this.Global)
                    : this.SetValue(property.Value, originalValue, propertyInfo);

                if (!isChanged) {
          continue;
        }

        changedSettings.Add(property.Property);
        this.PersistGlobalSettings();
            }

            return changedSettings;
        }

        /// <summary>
        /// Gets the list.
        /// </summary>
        /// <returns>A List of ExtendedPropertyInfo of the type T.</returns>
        public List<ExtendedPropertyInfo<T>> GetList()
        {
      Dictionary<String, Object> jsonData = Json.Deserialize(Json.Serialize(this.Global)) as Dictionary<global::System.String, global::System.Object>;

            return jsonData?.Keys
                .Select(p => new ExtendedPropertyInfo<T>(p) { Value = jsonData[p] })
                .ToList();
        }

        /// <summary>
        /// Resets the global settings.
        /// </summary>
        public void ResetGlobalSettings()
        {
            lock (this._syncRoot) {
        this._global = Activator.CreateInstance<T>();
      }

      this.PersistGlobalSettings();
        }

        private Boolean SetValue(Object property, Object originalValue, PropertyInfo propertyInfo)
        {
            switch (property)
            {
                case null when originalValue == null:
                    break;
                case null:
                    propertyInfo.SetValue(this.Global, null);
                    return true;
                default:
                    if (propertyInfo.PropertyType.TryParseBasicType(property, out Object propertyValue) &&
                        !propertyValue.Equals(originalValue))
                    {
                        propertyInfo.SetValue(this.Global, propertyValue);
                        return true;
                    }

                    break;
            }

            return false;
        }
    }
}