using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;

namespace AttributedSettings
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("SettingsType1");
            Console.WriteLine("-------------");
            var x = new SettingsType1();
            foreach (var prop in x.GetType().GetProperties())
                foreach (var param in x.GetPropertyParameters(prop.Name))
                    Console.WriteLine("{0}.{1} = {2}", prop.Name, param, x.GetPropertyParameterValue(prop.Name, param));

            Console.WriteLine();
            Console.WriteLine("SettingsType2");
            Console.WriteLine("-------------");
            var y = new SettingsType2();
            foreach (var prop in y.GetType().GetProperties())
                foreach (var param in y.GetPropertyParameters(prop.Name))
                    Console.WriteLine("{0}.{1} = {2}", prop.Name, param, y.GetPropertyParameterValue(prop.Name, param));

            Console.ReadLine();
        }
    }
    
    public class SettingsType1 : SettingsBase
    {
        [Parameter("Name", "Test int property")]
        [Parameter("Description", "Some test property of type <int>")]
        [Parameter("DefaultValue", 100)]
        [Parameter("MinValue", 0)]
        [Parameter("MaxValue", 1000)]
        public int IntProperty { get; set; }

        [Parameter("Name", "Test string property")]
        [Parameter("DefaultValue", "Test")]
        public string StringProperty { get; set; }

        public SettingsType1()
        {
            IntProperty = 100;
            StringProperty = "Test";
        }
    }

    public class SettingsType2 : SettingsBase
    {
        [Parameter("Name", "Unique identifier")]
        [Parameter("DefaultValue", "63EFF92C-62B0-4B34-9EB7-F8303AA9B31F")]
        public Guid UID { get; set; }

        public SettingsType2()
        {
            UID = Guid.Parse("63EFF92C-62B0-4B34-9EB7-F8303AA9B31F");
        }
    }

    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
    public class ParameterAttribute : Attribute
    {
        public string Name { get; set; }
        public object Value { get; set; }

        public ParameterAttribute(string name, object value)
        {
            Name = name;
            Value = value;
        }
    }

    public class SettingsBase
    {
        static SettingsBase()
        {
            _parameters = new Dictionary<Type, Dictionary<string, Dictionary<string, object>>>();
        }

        private static Dictionary<Type, Dictionary<string, Dictionary<string, object>>> _parameters;
        private Dictionary<Type, Dictionary<string, Dictionary<string, object>>> PropertiesParameters
        {
            get
            {
                if (!_parameters.ContainsKey(GetType()))
                {

                    var typePropertiesParameters = new Dictionary<string, Dictionary<string, object>>();

                    foreach (var property in GetType().GetProperties())
                    {
                        var attributes = property.GetCustomAttributes(typeof(ParameterAttribute), true);
                        if(attributes.Any())
                        {
                            var propertyParams = attributes.Cast<ParameterAttribute>().ToDictionary(attribute => attribute.Name, attribute => attribute.Value);
                            typePropertiesParameters.Add(property.Name, propertyParams);
                        }
                    }

                    _parameters.Add(GetType(), typePropertiesParameters);
                }

                return _parameters;
            }
        }

        public ReadOnlyCollection<string> GetPropertyParameters(string property)
        {
            if (!PropertiesParameters.ContainsKey(GetType()))
                throw new InvalidOperationException();

            if (!PropertiesParameters[GetType()].ContainsKey(property))
                throw new ArgumentException("property");

            return PropertiesParameters[GetType()][property].Keys.ToList().AsReadOnly();
        }

        public object GetPropertyParameterValue(string property, string name)
        {
            if (!PropertiesParameters.ContainsKey(GetType()))
                throw new InvalidOperationException();

            if (!PropertiesParameters[GetType()].ContainsKey(property))
                throw new ArgumentException("property");

            var propertyParams = PropertiesParameters[GetType()][property];

            if(!propertyParams.ContainsKey(name))
                throw new ArgumentException(null, "name");

            return propertyParams[name];
        }
    }
}