using System;
using System.Collections.Generic;

namespace Game
{
    /// <summary>
    /// 数据绑定，改变数据时回调，只支持基本数据类型、list
    /// </summary>
    public interface IMetaData
    {
        void AddEvent(Delegate callback);
        void RemoveEvent(Delegate callback);
    }

    public delegate void EventMetaData<ValueType>(ValueType valuePre, ValueType valueNow);

    public class MetaBase<T> : IMetaData
    {
        protected T ValueReal;

        public T Value
        {
            get => ValueReal;
            set
            {
                if (ValueReal != null && ValueReal.Equals(value)) return;
                OnValueChange(ValueReal, value);
                ValueReal = value;
            }
        }

        private Delegate _handler;

        public void AddEvent(Delegate callback)
        {
            if (_handler == null)
            {
                _handler = callback;
            }
            else
            {
                _handler = (EventMetaData<T>)_handler + (EventMetaData<T>)callback;
            }

            //绑定的时候执行一次
            ((EventMetaData<T>)callback)(ValueReal, ValueReal);
        }

        public void RemoveEvent(Delegate callback)
        {
            _handler = (EventMetaData<T>)_handler - (EventMetaData<T>)callback;
        }

        private void OnValueChange(T valuePre, T valueNow)
        {
            if (_handler == null)
            {
                return;
            }

            foreach (var callback in _handler.GetInvocationList())
            {
                ((EventMetaData<T>)callback)(valuePre, valueNow);
            }
        }

        protected void OnValueChange()
        {
            OnValueChange(ValueReal, ValueReal);
        }
    }

    public class MetaData<T> : MetaBase<T>
    {
    }

    public class MetaList<T> : MetaBase<List<T>>
    {
        public T this[int key]
        {
            set => Value[key] = value;
            get => Value[key];
        }

        public void Add(T data)
        {
            ValueReal.Add(data);
            OnValueChange();
        }

        public void AddRange(IEnumerable<T> collection)
        {
            ValueReal.AddRange(collection);
            OnValueChange();
        }

        public void Clear()
        {
            ValueReal.Clear();
            OnValueChange();
        }

        public void Remove(T data)
        {
            ValueReal.Remove(data);
            OnValueChange();
        }
    }

    public class MetaDictionary<TKey, TValue> : MetaBase<Dictionary<TKey, TValue>>
    {
        public MetaDictionary()
        {
            ValueReal = new Dictionary<TKey, TValue>();
        }

        public TValue this[TKey key]
        {
            set
            {
                var isChange = !ValueReal.ContainsKey(key);
                ValueReal[key] = value;
                if (isChange)
                {
                    OnValueChange();
                }
            }
            get => ValueReal[key];
        }

        public int Count => ValueReal.Count;

        public void Clear()
        {
            ValueReal.Clear();
            OnValueChange();
        }

        public void Remove(TKey data)
        {
            ValueReal.Remove(data);
            OnValueChange();
        }

        public bool ContainsKey(TKey data)
        {
            return ValueReal.ContainsKey(data);
        }

        public Dictionary<TKey, TValue>.Enumerator GetEnumerator()
        {
            return ValueReal.GetEnumerator();
        }
    }
}