using System.Collections;

namespace YLErp.Commons
{
    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="TKey"></typeparam>
    /// <typeparam name="TValue"></typeparam>
    public class ExpandoDictionary<TKey, TValue> : IDictionary, IDictionary<TKey, TValue>
    {
        readonly IDictionary<TKey, TValue> _dic;

        public ExpandoDictionary(IDictionary<TKey, TValue> dic)
        {
            _dic = dic ?? throw new ArgumentNullException(nameof(dic));
        }

        object IDictionary.this[object key]
        {
            get
            {
                return ((IDictionary)_dic).Contains(key) ? ((IDictionary)_dic)[(TKey)key] : default;
            }
            set => ((IDictionary)_dic)[(TKey)key] = (TValue)value;
        }

        public TValue this[TKey key]
        {
            get => _dic.TryGetValue(key, out var value) ? value : default;
            set => _dic[key] = value;
        }

        ICollection IDictionary.Keys => _dic.Keys.ToArray();

        ICollection IDictionary.Values => _dic.Values.ToArray();

        public bool IsReadOnly => _dic.IsReadOnly;

        bool IDictionary.IsFixedSize => ((IDictionary)_dic).IsFixedSize;

        public int Count => _dic.Count;

        object ICollection.SyncRoot => ((IDictionary)_dic).SyncRoot;

        bool ICollection.IsSynchronized => ((IDictionary)_dic).IsSynchronized;

        ICollection<TKey> IDictionary<TKey, TValue>.Keys => _dic.Keys;

        ICollection<TValue> IDictionary<TKey, TValue>.Values => _dic.Values;

        void IDictionary.Add(object key, object value)
        {
            ((IDictionary)_dic).Add(key, value);
        }

        public void Add(TKey key, TValue value)
        {
            _dic.Add(key, value);
        }

        public void Add(KeyValuePair<TKey, TValue> item)
        {
            _dic.Add(item);
        }

        public void Clear()
        {
            _dic.Clear();
        }

        bool IDictionary.Contains(object key)
        {
            return ((IDictionary)_dic).Contains(key);
        }

        public bool Contains(KeyValuePair<TKey, TValue> item)
        {
            return _dic.Contains(item);
        }

        public bool ContainsKey(TKey key)
        {
            return _dic.ContainsKey(key);
        }

        void ICollection.CopyTo(Array array, int index)
        {
            ((IDictionary)_dic).CopyTo(array, index);
        }

        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            _dic.CopyTo(array, arrayIndex);
        }

        IDictionaryEnumerator IDictionary.GetEnumerator()
        {
            return ((IDictionary)_dic).GetEnumerator();
        }

        void IDictionary.Remove(object key)
        {
            ((IDictionary)_dic).Remove(key);
        }

        public bool Remove(TKey key)
        {
            return _dic.Remove(key);
        }

        public bool Remove(KeyValuePair<TKey, TValue> item)
        {
            return _dic.Remove(item);
        }

        public bool TryGetValue(TKey key, out TValue value)
        {
            return _dic.TryGetValue(key, out value);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _dic.GetEnumerator();
        }

        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
        {
            return _dic.GetEnumerator();
        }

        public static implicit operator ExpandoDictionary<TKey, TValue>(Dictionary<TKey, TValue> dic)
        {
            return new ExpandoDictionary<TKey, TValue>(dic);
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public class ExpandoDictionary
    {
        public delegate string FormatPropValue(string propName, object propValue);

        public static ExpandoDictionary<string, string> ConvertObject(object obj, FormatPropValue format)
        {
            if (obj is null)
            {
                return null;
            }

            var props = TypeDescriptor.GetProperties(obj);
            var dic = new Dictionary<string, string>(props.Count);

            foreach (PropertyDescriptor p in props)
            {
                var val = p.GetValue(obj);
                dic[p.Name] = val == null ? string.Empty : format != null ? format(p.Name, val) : val.ToString();
            }

            return dic;
        }
    }
}