using System;
using System.Collections.Generic;
// ReSharper disable ConditionalTernaryEqualBranch
// ReSharper disable RedundantAssignment

// ReSharper disable once CheckNamespace
namespace DTS.Common.Settings
{
    /// <summary>
    /// handles storing/retrieving settings from a db
    /// assumes DB connection is already established or connection information has already been set for db
    /// </summary>
    public class SettingsDB
    {
        private static SettingsDB _instance;
        private static readonly object LOCK_OBJECT = new object();

        private const string CSV_IMPORT_CREATE_DYNAMIC_GROUPS = "CSVImportCreateDynamicGroups";
        private const string IMPORT_CREATE_DYNAMIC_GROUPS = "ImportCreateDynamicGroups";

        private static SettingsDB Instance
        {
            get
            {
                lock (LOCK_OBJECT)
                {
                    return _instance ?? (_instance = new SettingsDB());
                }
            }
        }

        private readonly Dictionary<string, Setting> _settingsLookup = new Dictionary<string, Setting>();

        private SettingsDB()
        {
        }

        public static void RefreshSettings()
        {
            lock (LOCK_OBJECT)
            {
                Instance._settingsLookup.Clear();
            }
        }
        /// <summary>
        /// retrieve property value given user
        /// creates with default value if doesn't exist
        /// </summary>
        /// <param name="id"></param>
        /// <param name="defaultValue"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public static string GetUserValue(string id, string defaultValue, string user)
        {
            var key = $"{id}_{user}";
            lock (LOCK_OBJECT)
            {
                if (!Instance._settingsLookup.ContainsKey(key))
                {
                    Instance._settingsLookup[key] = new UserSetting(id, defaultValue, user);
                }
                return Instance._settingsLookup[key].PropertyValue;
            }
        }
        /// <summary>
        /// retrieves a global value, creates using default value if property doesn't exist yet
        /// </summary>
        /// <param name="id"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static string GetGlobalValue(string id, string defaultValue, bool useCache = true)
        {
            lock (LOCK_OBJECT)
            {
                if (!Instance._settingsLookup.ContainsKey(id) || !useCache)
                {
                    //If a setting is being added to the db, and is replacing an old
                    //setting, use the value of the old setting
                    if ((id == IMPORT_CREATE_DYNAMIC_GROUPS) && Instance._settingsLookup.ContainsKey(CSV_IMPORT_CREATE_DYNAMIC_GROUPS))
                    {
                        defaultValue = Instance._settingsLookup[CSV_IMPORT_CREATE_DYNAMIC_GROUPS].PropertyValue;
                    }
                    Instance._settingsLookup[id] = new GlobalSetting(id, defaultValue);
                }
                return Instance._settingsLookup[id].PropertyValue;
            }
        }
        public static void GetAllGlobalValues()
        {
            var settings = GlobalSetting.GetAllGlobalSettings();
            lock (LOCK_OBJECT)
            {
                foreach (var setting in settings)
                {
                    Instance._settingsLookup[setting.PropertyId] = setting;
                }
            }
        }
        /// <summary>
        /// returns the global value for given property, or the default value if no value currently exists
        /// </summary>
        /// <param name="id"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static double GetGlobalValueDouble(string id, double defaultValue)
        {
            var sValue = GetGlobalValue(id, defaultValue.ToString(System.Globalization.CultureInfo.InvariantCulture));
            var d = defaultValue;
            return !double.TryParse(sValue, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d) ? defaultValue : d;
        }
        public static int GetGlobalValueInt(string id, int defaultValue)
        {
            var sValue = GetGlobalValue(id, defaultValue.ToString(System.Globalization.CultureInfo.InvariantCulture));
            var d = defaultValue;
            return !int.TryParse(sValue, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d) ? defaultValue : d;
        }
        /// <summary>
        /// returns the global value for given property, or the default value if no value currently exists
        /// </summary>
        /// <param name="id"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static bool GetGlobalValueBool(string id, bool defaultValue, bool useCache = true)
        {
            var sValue = GetGlobalValue(id, defaultValue.ToString(System.Globalization.CultureInfo.InvariantCulture), useCache);
            var b = defaultValue;
            return !bool.TryParse(sValue, out b) ? b : b;
        }

        public static double[] GetGlobalValueDoubleArray(string id, double[] defaultValues)
        {
            var key = $"{id}_x_Count";
            var count = GetGlobalValueInt(key, defaultValues.Length);

            var values = new List<double>();

            for (var i = 0; i < count; i++)
            {
                var thiskey = $"{id}_x_{i}";
                values.Add(i >= defaultValues.Length
                    ? GetGlobalValueDouble(thiskey, 0D)
                    : GetGlobalValueDouble(thiskey, defaultValues[i]));
            }
            return values.ToArray();
        }

        public static void SetGlobalValueDoubleArray(string id, double[] values)
        {
            var key = $"{id}_x_Count";
            SetGlobalValueInt(key, values.Length);

            for (var i = 0; i < values.Length; i++)
            {
                var thiskey = $"{id}_x_{i}";
                SetGlobalValueDouble(thiskey, values[i]);
            }
        }

        public static int[] GetGlobalValueIntArray(string id, int[] defaultValues)
        {
            var key = $"{id}_x_Count";
            var count = GetGlobalValueInt(key, defaultValues.Length);

            var values = new List<int>();

            for (var i = 0; i < count; i++)
            {
                try
                {
                    var thiskey = $"{id}_x_{i}";
                    values.Add(i >= defaultValues.Length
                        ? GetGlobalValueInt(thiskey, 0)
                        : GetGlobalValueInt(thiskey, defaultValues[i]));
                }
                catch (Exception) { /* catch (Exception ex) { APILogger.Log(ex); } */ }
            }
            return values.ToArray();
        }

        public static void SetGlobalValueIntArray(string id, int[] values)
        {
            var key = $"{id}_x_Count";
            SetGlobalValueInt(key, values.Length);

            for (var i = 0; i < values.Length; i++)
            {
                var thiskey = $"{id}_x_{i}";
                SetGlobalValueInt(thiskey, values[i]);
            }
        }

        /// <summary>
        /// sets user specific property in database
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        /// <param name="user"></param>
        public static void SetUserValue(string id, string value, string user)
        {
            var key = $"{id}_{user}";
            lock (LOCK_OBJECT)
            {
                if (!Instance._settingsLookup.ContainsKey(key))
                {
                    Instance._settingsLookup[key] = new UserSetting(id, value, user);
                }
                Instance._settingsLookup[key].SetValue(value);
            }
        }
        /// <summary>
        /// stores an application global property in the database
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public static void SetGlobalValue(string id, string value)
        {
            lock (LOCK_OBJECT)
            {
                if (!Instance._settingsLookup.ContainsKey(id))
                {
                    Instance._settingsLookup[id] = new GlobalSetting(id, value);
                }
                Instance._settingsLookup[id].SetValue(value);
            }
        }
        /// <summary>
        /// stores an application global property value in the database
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public static void SetGlobalValueDouble(string id, double value)
        {
            lock (LOCK_OBJECT)
            {
                if (!Instance._settingsLookup.ContainsKey(id))
                {
                    Instance._settingsLookup[id] = new GlobalSetting(id, value.ToString(System.Globalization.CultureInfo.InvariantCulture));
                }
                Instance._settingsLookup[id].SetValue(value.ToString(System.Globalization.CultureInfo.InvariantCulture));
            }
        }

        public static void SetGlobalValueInt(string id, int value)
        {
            lock (LOCK_OBJECT)
            {
                if (!Instance._settingsLookup.ContainsKey(id))
                {
                    Instance._settingsLookup[id] = new GlobalSetting(id, value.ToString(System.Globalization.CultureInfo.InvariantCulture));
                }
                Instance._settingsLookup[id].SetValue(value.ToString(System.Globalization.CultureInfo.InvariantCulture));
            }
        }
        /// <summary>
        /// stores an application global property value in the database
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public static void SetGlobalValueBoolean(string id, bool value)
        {
            lock (LOCK_OBJECT)
            {
                if (!Instance._settingsLookup.ContainsKey(id))
                {
                    Instance._settingsLookup[id] = new GlobalSetting(id, value.ToString(System.Globalization.CultureInfo.InvariantCulture));
                }

                if (id == IMPORT_CREATE_DYNAMIC_GROUPS)
                {
                    // 36831 The ImportCreateDynamicGroups setting has replaced the CSVImportCreateDynamicGroups setting, but
                    // the old setting needs to still be used by pre-Version 93 clients, so set it whenever the new one is set.
                    // When a pre-Version 93 client sets the old setting, the stored procedure will also set the new one.
                    if (!Instance._settingsLookup.ContainsKey(CSV_IMPORT_CREATE_DYNAMIC_GROUPS))
                    {
                        Instance._settingsLookup[CSV_IMPORT_CREATE_DYNAMIC_GROUPS] = new GlobalSetting(CSV_IMPORT_CREATE_DYNAMIC_GROUPS, "True");
                    }

                    //This SetValue call will set both the ImportCreateDynamicGroups (new) and CSVImportCreateDynamicGroups (old) settings.
                    Instance._settingsLookup[CSV_IMPORT_CREATE_DYNAMIC_GROUPS].SetValue(value.ToString(System.Globalization.CultureInfo.InvariantCulture));
                }
                Instance._settingsLookup[id].SetValue(value.ToString(System.Globalization.CultureInfo.InvariantCulture));
            }
        }
    }
}