using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Text;
using DTS.Storage;
// ReSharper disable RedundantEmptyDefaultSwitchBranch

// ReSharper disable once CheckNamespace
namespace DTS.Slice.Users.UserSettings
{
    /// <summary>
    /// user specific properties, stored in db
    /// 
    /// these are all the user specific settings we are storing in the db currently as generic settings
    /// we have a few user specific settings like last used hardware that are stored in other places, that maybe
    /// should be stored here as well
    /// 
    /// it's possible to retrieve all the settings at once (more efficient, only one db query), or retrieve settings individually
    /// one by one using the static accessors
    /// each setting has a default specified both in code and in the db.
    /// when retrieving a setting we fall back to the default if a user specific value is not found
    /// if the default setting in the db is not found, we can further fall back to the default specified in code
    /// 
    /// in the db we have a table that lists all the settings with their fall back default value
    /// we have a separate table that stores the user specific values for any of those settings, which may or may not match the fall
    /// back default value
    /// 
    /// the data should always be stored in invariant form in the db
    /// DisplayName, Description attributes translate so the properties can be displayed in a property grid
    /// </summary>
    public class UserSettings
    {

        #region properties
        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultUploadEnabled)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultUploadEnabled)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultUploadEnabled)]
        [DefaultValue(false)]
        public bool UploadDefault { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultTestSampleRate)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultTestSampleRate)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultTestSampleRate)]
        [DefaultValue(10000D)]
        public double DefaultSampleRate { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultPostTriggerSeconds)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultPostTriggerSeconds)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultPostTriggerSeconds)]
        [DefaultValue(1D)]
        public double DefaultPostTriggerSeconds { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultPreTriggerSeconds)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultPreTriggerSeconds)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultPreTriggerSeconds)]
        [DefaultValue(1D)]
        public double DefaultPreTriggerSeconds { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultTriggerCheckStep)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultTriggerCheckStep)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultTriggerCheckStep)]
        [DefaultValue(true)]
        public bool DefaultTriggerCheckStep { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultRealtimeGraphCount)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultRealtimeGraphCount)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultRealtimeGraphCount)]
        [DefaultValue(6)]
        public int DefaultRealtimeGraphCount { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultROIStart)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultROIStart)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultROIStart)]
        [DefaultValue(-1D)]
        public double DefaultROIStart { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultROIEnd)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultROIEnd)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultROIEnd)]
        [DefaultValue(1D)]
        public double DefaultROIEnd { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultDownloadROI)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultDownloadROI)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultDownloadROI)]
        [DefaultValue(true)]
        public bool DefaultDownloadROI { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultViewROI)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultViewROI)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultViewROI)]
        [DefaultValue(true)]
        public bool DefaultViewROI { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultDownloadAll)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultDownloadAll)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultDownloadAll)]
        [DefaultValue(true)]
        public bool DefaultDownloadAll { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultViewAll)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultViewAll)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultViewAll)]
        [DefaultValue(false)]
        public bool DefaultViewAll { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultRequireAllUnitsPassDiagnostics)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultRequireAllUnitsPassDiagnostics)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultRequireAllUnitsPassDiagnostics)]
        [DefaultValue(true)]
        public bool DefaultRequireAllUnitsPassDiagnostics { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultRequireUserConfirmationOnErrors)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultRequireUserConfirmationOnErrors)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultRequireUserConfirmationOnErrors)]
        [DefaultValue(true)]
        public bool DefaultRequireUserConfirmationOnErrors { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultAllowMissingSensors)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultAllowMissingSensors)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultAllowMissingSensors)]
        [DefaultValue(false)]
        public bool DefaultAllowMissingSensors { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultRunPostTestDiagnostics)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultRunPostTestDiagnostics)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultRunPostTestDiagnostics)]
        [DefaultValue(false)]
        public bool DefaultRunPostTestDiagnostics { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultArmCheckListStep)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultArmCheckListStep)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultArmCheckListStep)]
        [DefaultValue(false)]
        public bool DefaultArmCheckListStep { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultCheckListInputVoltageCheck)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListInputVoltageCheck)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListInputVoltageCheck)]
        [DefaultValue(true)]
        public bool DefaultCheckListInputVoltageCheck { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultCheckListBatteryVoltageCheck)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListBatteryVoltageCheck)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListBatteryVoltageCheck)]
        [DefaultValue(true)]
        public bool DefaultCheckListBatteryVoltageCheck { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultCheckListSquibResistanceCheck)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListSquibResistanceCheck)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListSquibResistanceCheck)]
        [DefaultValue(true)]
        public bool DefaultCheckListSquibResistanceCheck { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultCheckListSensorIdCheck)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListSensorIdCheck)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListSensorIdCheck)]
        [DefaultValue(true)]
        public bool DefaultCheckListSensorIdCheck { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultCheckListTriggerStartCheck)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListTriggerStartCheck)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListTriggerStartCheck)]
        [DefaultValue(true)]
        public bool DefaultCheckListTriggerStartCheck { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultCheckListTiltSensorCheck)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListTiltSensorCheck)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListTiltSensorCheck)]
        [DefaultValue(true)]
        public bool DefaultCheckListTiltSensorCheck { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultAllowSensorIdToBlankChannel)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultAllowSensorIdToBlankChannel)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultAllowSensorIdToBlankChannel)]
        [DefaultValue(true)]
        public bool DefaultAllowSensorIdToBlankChannel { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultCheckListMustPass)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListMustPass)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultCheckListMustPass)]
        [DefaultValue(false)]
        public bool DefaultChecklistMustPass { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultViewRealtime)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultViewRealtime)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultViewRealtime)]
        [DefaultValue(true)]
        public bool DefaultViewRealtime { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultExport)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultExport)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultExport)]
        [DefaultValue(false)]
        public bool DefaultExport { get; set; }

        [DefaultValue(0)]
        [CategoryAttributeEx(PropertyEnums.PropertyCategories.DefaultTestSettings)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultExportFormat)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultExportFormat)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultExportFormat)]
        public int DefaultExportFormat { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.RealtimeSettings)]
        [PropertyId(PropertyEnums.PropertyIds.RealtimeChartWidthInSeconds)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.RealtimeChartWidthInSeconds)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.RealtimeChartWidthInSeconds)]
        [DefaultValue(2)]
        public double RealtimeChartWidthInSeconds { get; set; }

        [DefaultValue(true)]
        [CategoryAttributeEx(PropertyEnums.PropertyCategories.TestOptions)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultTreeModeDiagnostics)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultTreeModeDiagnostics)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultTreeModeDiagnostics)]
        public bool DefaultTreeModeDiagnostics { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.TestOptions)]
        [PropertyId(PropertyEnums.PropertyIds.ArmChecklistRequiredIfTOM)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.ArmChecklistRequiredIfTOM)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.ArmChecklistRequiredIfTOM)]
        [DefaultValue(true)]
        public bool ArmChecklistRequiredIfTOM { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.TestOptions)]
        [PropertyId(PropertyEnums.PropertyIds.DefaultSuppressMissingSensorsWarning)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.DefaultSuppressMissingSensorsWarning)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.DefaultSuppressMissingSensorsWarning)]
        [DefaultValue(true)]
        public bool DefaultSuppressMissingSensorsWarning { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.TestOptions)]
        [PropertyId(PropertyEnums.PropertyIds.ArmTriggerDiagnosticsRunOnNextStep)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.ArmTriggerDiagnosticsRunOnNextStep)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.ArmTriggerDiagnosticsRunOnNextStep)]
        [DefaultValue(false)]
        public bool ArmTriggerDiagnosticsRunOnNextStep { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.UserHistory)]
        [PropertyId(PropertyEnums.PropertyIds.UsersCurrentTestSetup)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.UsersCurrentTestSetup)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.UsersCurrentTestSetup)]
        [DefaultValue("")]
        [ReadOnly(true)]
        public string UsersCurrentTestSetup { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.UserHistory)]
        [PropertyId(PropertyEnums.PropertyIds.LastRunTestSetup)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.LastRunTestSetup)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.LastRunTestSetup)]
        [DefaultValue("")]
        [ReadOnly(true)]
        public string LastRunTestSetup { get; set; }

        [CategoryAttributeEx(PropertyEnums.PropertyCategories.UserHistory)]
        [PropertyId(PropertyEnums.PropertyIds.LastUsedSampleRate)]
        [DescriptionAttributeEx(PropertyEnums.PropertyIds.LastUsedSampleRate)]
        [DisplayAttributeEx(PropertyEnums.PropertyIds.LastUsedSampleRate)]
        [DefaultValue(20000D)]
        [ReadOnly(true)]
        public double LastUsedSampleRate { get; set; }
        
        /*
         * Subcategory example
         */

        //[Category("Category1")]
        //public SubCategory1 Subcategory1 { get; set; }

        //[Category("Category1")]
        //public SubCategory2 Subcategory2 { get; set; }

        #endregion properties

        #region Static Methods
        /// <summary>
        /// this function is designed to create any missing property settings if needed
        /// this might happen if the database table was just created for instance
        /// it will create defaults for all the settings in the db, and also settings for all users
        /// currently it's used by DataPRO.App
        /// </summary>
        public static void CreateAnyMissingUserSettingPropertyDefaults()
        {
            //get a list of all known properties
            var userSetting = new UserSettings();
            var properties = userSetting.GetType().GetProperties();
            var needToBeAdded = new Dictionary<int, PropertyInfo>();

            foreach (var property in properties)
            {
                var id = PropertyIdAttribute.GetPropertyId(property);
                needToBeAdded[id] = property;
            }
            //find if the property already exists in the db, if so, no need to add...
            using (var sql = DbOperations.GetCommand())
            {
                sql.CommandText = "SELECT [PropertyId] from [DefaultProperties]";
                using (var ds = DbOperations.Connection.QueryDataSet(sql))
                {
                    foreach (DataRow row in ds.Tables[0].Rows)
                    {
                        var id = Convert.ToInt32(row["PropertyId"]);
                        if (needToBeAdded.ContainsKey(id))
                        {
                            needToBeAdded.Remove(id);
                        }
                    }
                }
            }
            //if we have nothing to add, we are all done
            if (needToBeAdded.Values.Count <= 0) return;

            //otherwise add the defaults
            using (var sql = DbOperations.GetCommand())
            {
                var sb = new StringBuilder();
                sb.Append(DbOperations.BEGIN_STATEMENT);

                var needToBeAddedEnumerator = needToBeAdded.GetEnumerator();
                int iIndex = 0;
                while (needToBeAddedEnumerator.MoveNext())
                {
                    var currentProperty = needToBeAddedEnumerator.Current.Value;
                    sb.AppendFormat("INSERT INTO [DefaultProperties] ([PropertyId],[PropertyName],[DefaultValue]) VALUES (@1_{0}, @2_{0}, @3_{0});", iIndex);
                    DbOperations.CreateParam(sql, string.Format("@1_{0}", iIndex), SqlDbType.Int, PropertyIdAttribute.GetPropertyId(currentProperty));
                    DbOperations.CreateParam(sql, string.Format("@2_{0}", iIndex), SqlDbType.NVarChar, PropertyIdAttribute.GetPropertyIdEnum(currentProperty).ToString());
                    DbOperations.CreateParam(sql, string.Format("@3_{0}", iIndex), SqlDbType.NVarChar, GetDefaultValueAsString(currentProperty));
                    iIndex++;
                }

                sb.Append(DbOperations.COMMIT_STATEMENT);
                sql.CommandText = sb.ToString();
                DbOperations.Connection.ExecuteCommand(sql);
            }
            //finally add settings for any users we have currently
            CreateMissingUserSettingProperties(needToBeAdded.Values.ToArray());
        }
        /// <summary>
        /// creates missing user settings (for all users)
        /// </summary>
        /// <param name="needToBeAdded"></param>
        private static void CreateMissingUserSettingProperties(PropertyInfo[] needToBeAdded)
        {
            var userIds = new List<int>();
            using (var sql = DbOperations.GetCommand())
            {
                sql.CommandText = "SELECT ID FROM [DataPROUsers]";
                using (var ds = DbOperations.Connection.QueryDataSet(sql))
                {
                    foreach (DataRow row in ds.Tables[0].Rows)
                    {
                        var id = Convert.ToInt32(row["ID"]);
                        if (!userIds.Contains(id))
                        {
                            userIds.Add(id);
                        }
                    }
                }
            }
            foreach (var id in userIds)
            {
                CreateMissingUserSettingProperties(id, needToBeAdded);
            }
        }

        /// <summary>
        /// this funtion creates a list of settings for a specific user
        /// this may happen with a new database, it's called by the
        /// CreateAnyMissingUserSettingPropertyDefaults function above
        /// </summary>
        /// <param name="id"></param>
        /// <param name="needToBeAdded"></param>
        internal static void CreateMissingUserSettingProperties(int id, PropertyInfo[] needToBeAdded)
        {
            using (var sql = DbOperations.GetCommand())
            {
                var index = 0;
                var sb = new StringBuilder();
                sb.Append(DbOperations.BEGIN_STATEMENT);

                foreach (var property in needToBeAdded)
                {
                    sb.AppendFormat(
                        "INSERT INTO [UserProperties] ([UserId],[PropertyId], [PropertyValue]) VALUES (@1_{0},@2_{0},@3_{0});",
                        index);

                    DbOperations.CreateParam(sql, string.Format("@1_{0}", index), SqlDbType.Int, id);
                    DbOperations.CreateParam(sql, string.Format("@2_{0}", index), SqlDbType.Int,
                        PropertyIdAttribute.GetPropertyId(property));
                    DbOperations.CreateParam(sql, string.Format("@3_{0}", index), SqlDbType.NVarChar,
                        GetDefaultValueAsString(property));

                    index++;
                }

                sb.Append(DbOperations.COMMIT_STATEMENT);

                sql.CommandText = sb.ToString();
                DbOperations.Connection.ExecuteCommand(sql);
            }
        }

        /// <summary>
        /// get an invariant version of the value for db storage
        /// this is used when we create or insert a new default into the db
        /// </summary>
        /// <param name="property"></param>
        /// <returns></returns>
        private static string GetDefaultValueAsString(PropertyInfo property)
        {
            if (property == null) return "";
            var attr = (DefaultValueAttribute)property.GetCustomAttribute(typeof(DefaultValueAttribute));
        
            if (attr.Value is double)
            {
                return ((double) attr.Value).ToString(CultureInfo.InvariantCulture);
            }
            if (attr.Value is float)
            {
                return ((float) attr.Value).ToString(CultureInfo.InvariantCulture);
            }
            return attr.Value.ToString();
        }
        /// <summary>
        /// gets a collection of all settings for a given user
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public static UserSettings GetUserSettings(int userId)
        {
            var settings = new UserSettings();

            var properties = settings.GetType().GetProperties();
            //first get all properties as filled out by code
            foreach (var property in properties)
            {
                var d = property.GetCustomAttribute<DefaultValueAttribute>();
                if (d != null)
                {
                    property.SetValue(settings, d.Value);
                }
            }

            //next make sure we get all the defaults from the db
            using (var sql = DbOperations.GetCommand())
            {
                sql.CommandText = "SELECT [PropertyId], [DefaultValue] from [DefaultProperties]";

                using (var ds = DbOperations.Connection.QueryDataSet(sql))
                {
                    foreach (DataRow row in ds.Tables[0].Rows)
                    {
                        var id = Convert.ToInt32(row["PropertyId"]);
                        var dv = Convert.ToString(row["DefaultValue"]);
                        settings.SetValue(id, dv);
                    }
                }
            }

            //finally get the user specific values
            using (var sql = DbOperations.GetCommand())
            {
                sql.CommandText = "SELECT [PropertyId], [PropertyValue] FROM [UserProperties] WHERE [UserId]=@1";
                DbOperations.CreateParam(sql, "@1", SqlDbType.Int, userId);
                using (var ds = DbOperations.Connection.QueryDataSet(sql))
                {
                    foreach (DataRow row in ds.Tables[0].Rows)
                    {
                        var id = Convert.ToInt32(row["PropertyId"]);
                        var value = Convert.ToString(row["PropertyValue"]);
                        settings.SetValue(id, value);
                    }
                }
            }
            return settings;
        }
        /// <summary>
        /// sets a specific user setting in the db
        /// function should handle the invariant nature of values
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public static void SetUserSetting(int userId, PropertyEnums.PropertyIds id, object value)
        {
            var sValue = value.ToString();
            if (value is double)
            {
                sValue = ((double)value).ToString(CultureInfo.InvariantCulture);
            }
            else if (value is float)
            {
                sValue = ((float)value).ToString(CultureInfo.InvariantCulture);
            }
            using (var sql = DbOperations.GetCommand())
            {
                sql.CommandText = "UPDATE [UserProperties] SET [PropertyValue]=@1 WHERE [UserId]=@2 AND [PropertyId]=@3";
                DbOperations.CreateParam(sql, "@1", SqlDbType.NVarChar, sValue);
                DbOperations.CreateParam(sql, "@2", SqlDbType.Int, userId);
                DbOperations.CreateParam(sql, "@3", SqlDbType.Int, (int)id);
                DbOperations.Connection.ExecuteCommand(sql);
            }
        }
        /// <summary>
        /// gets a specific user setting as a bool
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="property"></param>
        /// <returns></returns>
        public static bool GetUserSettingValueBool(int userId, PropertyEnums.PropertyIds property)
        {
            return Convert.ToBoolean(GetUserSettingValue(userId, property));
        }
        /// <summary>
        /// gets a specific user setting as a double
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="property"></param>
        /// <returns></returns>
        public static double GetUserSettingValueDouble(int userId, PropertyEnums.PropertyIds property)
        {
            return Convert.ToDouble(GetUserSettingValue(userId, property), CultureInfo.InvariantCulture);
        }
        /// <summary>
        /// gets a specific user setting as an integer
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="property"></param>
        /// <returns></returns>
        public static int GetUserSettingValueInt(int userId, PropertyEnums.PropertyIds property)
        {
            return Convert.ToInt32(GetUserSettingValue(userId, property), CultureInfo.InvariantCulture);
        }
        /// <summary>
        /// Gets a specific user setting as a string
        /// </summary>
        /// <param name="userid"></param>
        /// <param name="property"></param>
        /// <returns></returns>
        public static string GetUserSettingValueString(int userid, PropertyEnums.PropertyIds property)
        {
            return GetUserSettingValue(userid, property);
        }
        /// <summary>
        /// gets a user setting out of the db, this is an internal function used by all the public
        /// single setting accessors.
        /// setting is determined by user settings table, default values table
        /// </summary>
        /// <param name="userid"></param>
        /// <param name="property"></param>
        /// <returns></returns>
        private static string GetUserSettingValue(int userid, PropertyEnums.PropertyIds property)
        {
            //if the user has a specific value set for this property, just return it directly
            using (var sql = DbOperations.GetCommand())
            {
                sql.CommandText = "SELECT [PropertyValue] FROM [UserProperties] WHERE [UserId]=@1 AND [PropertyId]=@2";
                DbOperations.CreateParam(sql, "@1", SqlDbType.Int, userid);
                DbOperations.CreateParam(sql, "@2", SqlDbType.Int, (int)property);
                using (var ds = DbOperations.Connection.QueryDataSet(sql))
                {
                    if (ds.Tables[0].Rows.Count > 0)
                    {
                        return Convert.ToString(ds.Tables[0].Rows[0]["PropertyValue"]);
                    }
                }
            }
            //if there exists a specific default value set for this property, return that
            using (var sql = DbOperations.GetCommand())
            {
                sql.CommandText = "SELECT [DefaultValue] FROM [DefaultProperties] WHERE [PropertyId] =@1";
                DbOperations.CreateParam(sql, "@1", SqlDbType.Int, (int)property);
                using (var ds = DbOperations.Connection.QueryDataSet(sql))
                {
                    if (ds.Tables[0].Rows.Count > 0)
                    {
                        return Convert.ToString(ds.Tables[0].Rows[0]["DefaultValue"]);
                    }
                }
            }
            //we could return the default value in code here, but we don't expect to get here, so 
            //we can treat this as an exception for now
            throw new NullReferenceException(property.ToString());
        }
        #endregion 

        #region methods
        /// <summary>
        /// sets a specific value given a property id
        /// this is used when deserializing values out of the db
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="dv"></param>
        protected void SetValue(int id, string dv)
        {
            var property = (PropertyEnums.PropertyIds)id;

            switch (property)
            {
                case PropertyEnums.PropertyIds.ArmChecklistRequiredIfTOM: ArmChecklistRequiredIfTOM = Convert.ToBoolean(dv); break;
                case PropertyEnums.PropertyIds.ArmTriggerDiagnosticsRunOnNextStep: ArmTriggerDiagnosticsRunOnNextStep = Convert.ToBoolean(dv); break;
                case PropertyEnums.PropertyIds.DefaultAllowMissingSensors: DefaultAllowMissingSensors = Convert.ToBoolean(dv); break;
                case PropertyEnums.PropertyIds.DefaultAllowSensorIdToBlankChannel: DefaultAllowSensorIdToBlankChannel = Convert.ToBoolean(dv); break;
                case PropertyEnums.PropertyIds.DefaultArmCheckListStep: DefaultArmCheckListStep = Convert.ToBoolean(dv); break;
                case PropertyEnums.PropertyIds.DefaultCheckListBatteryVoltageCheck: DefaultCheckListBatteryVoltageCheck = Convert.ToBoolean(dv); break;
                case PropertyEnums.PropertyIds.DefaultUploadEnabled: UploadDefault = Convert.ToBoolean(dv); break;
                case PropertyEnums.PropertyIds.DefaultTestSampleRate: DefaultSampleRate = Convert.ToDouble(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultPostTriggerSeconds: DefaultPostTriggerSeconds = Convert.ToDouble(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultPreTriggerSeconds: DefaultPreTriggerSeconds = Convert.ToDouble(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultTriggerCheckStep: DefaultTriggerCheckStep = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultRealtimeGraphCount: DefaultRealtimeGraphCount = Convert.ToInt32(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultROIStart: DefaultROIStart = Convert.ToDouble(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultROIEnd: DefaultROIEnd = Convert.ToDouble(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultDownloadROI: DefaultDownloadROI = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultViewROI: DefaultViewROI = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultDownloadAll: DefaultDownloadAll = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultViewAll: DefaultViewAll = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultRequireAllUnitsPassDiagnostics: DefaultRequireAllUnitsPassDiagnostics = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultRequireUserConfirmationOnErrors: DefaultRequireUserConfirmationOnErrors = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultRunPostTestDiagnostics: DefaultRunPostTestDiagnostics = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultCheckListInputVoltageCheck: DefaultCheckListInputVoltageCheck = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultCheckListSquibResistanceCheck: DefaultCheckListSquibResistanceCheck = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultCheckListSensorIdCheck: DefaultCheckListSensorIdCheck = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultCheckListTriggerStartCheck: DefaultCheckListTriggerStartCheck = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultCheckListTiltSensorCheck: DefaultCheckListTiltSensorCheck = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultCheckListMustPass: DefaultChecklistMustPass = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultViewRealtime: DefaultViewRealtime = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultExport: DefaultExport = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultExportFormat: DefaultExportFormat = Convert.ToInt32(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.RealtimeChartWidthInSeconds: RealtimeChartWidthInSeconds = Convert.ToDouble(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultTreeModeDiagnostics: DefaultTreeModeDiagnostics = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.DefaultSuppressMissingSensorsWarning: DefaultSuppressMissingSensorsWarning = Convert.ToBoolean(dv, CultureInfo.InvariantCulture); break;
                case PropertyEnums.PropertyIds.UsersCurrentTestSetup: UsersCurrentTestSetup = dv; break;
                case PropertyEnums.PropertyIds.LastRunTestSetup: LastRunTestSetup = dv; break;
                case PropertyEnums.PropertyIds.LastUsedSampleRate: LastUsedSampleRate = Convert.ToDouble(dv, CultureInfo.InvariantCulture); break;                
                default:
                    break;//ignore unknown property, just just ignore it
            }
        }
        /// <summary>
        /// resets all the settings for a user in the db, using the default settings in the db
        /// </summary>
        /// <param name="userId"></param>
        public void ResetUserSettings(int userId)
        {
            //you can do this with one command with SQL, ie like
            //http://stackoverflow.com/questions/224732/sql-update-from-one-table-to-another-based-on-a-id-match
            //but since we haven't ditched SQlite yet, lets include support for both by separating it into two statements
            var properties = new List<Tuple<int, string>>();

            using (var sql = DbOperations.GetCommand())
            {
                sql.CommandText = "SELECT [PropertyId],[DefaultValue] from [DefaultProperties]";
                using (var ds = DbOperations.Connection.QueryDataSet(sql))
                {
                    properties.AddRange(from DataRow row in ds.Tables[0].Rows let id = Convert.ToInt32(row["PropertyId"]) let value = Convert.ToString(row["DefaultValue"]) select new Tuple<int, string>(id, value));
                }
            }

            using (var sql = DbOperations.GetCommand())
            {                
                var sb = new StringBuilder();
                sb.Append(DbOperations.BEGIN_STATEMENT);

                for (var i = 0; i < properties.Count; i ++)
                {
                    sb.AppendFormat("UPDATE [UserProperties] SET [PropertyValue]=@1_{0} WHERE [PropertyId]=@2_{0} AND [UserId]=@3_{0};",i);

                    DbOperations.CreateParam(sql, string.Format("@1_{0}", i), SqlDbType.NVarChar, properties[i].Item2);
                    DbOperations.CreateParam(sql, string.Format("@2_{0}", i), SqlDbType.Int, properties[i].Item1);
                    DbOperations.CreateParam(sql, string.Format("@3_{0}",i), SqlDbType.Int, userId);
                }

                sb.Append(DbOperations.COMMIT_STATEMENT);
                sql.CommandText = sb.ToString();
                DbOperations.Connection.ExecuteCommand(sql);
            }
        }
        #endregion
    }

    /// <summary>
    /// Subcategory example
    /// http://stackoverflow.com/questions/9379353/category-hierarchy-in-winforms-propertygrid
    /// </summary>
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class SubCategory1
    {
        public String Property1 { get; set; }

        public String Property2 { get; set; }

        public override string ToString()
        {
            return String.Empty;
        }
    }

    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class SubCategory2
    {
        public String Property3 { get; set; }

        public override string ToString()
        {
            return String.Empty;
        }
    }
}