// Source https://github.com/azixMcAze/Unity-SerializableDictionary
// Licensed under MIT License: https://github.com/azixMcAze/Unity-SerializableDictionary/blob/master/LICENSE

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
using UnityEngine;

namespace WalletConnectUnity.Core.Utils
{
    public abstract class SerializableDictionaryBase
    {
        public abstract class Storage
        {
        }

        protected class Dictionary<TKey, TValue> : System.Collections.Generic.Dictionary<TKey, TValue>
        {
            public Dictionary()
            {
            }

            public Dictionary(IDictionary<TKey, TValue> dict) : base(dict)
            {
            }

            public Dictionary(SerializationInfo info, StreamingContext context) : base(info, context)
            {
            }
        }
    }

    [Serializable]
    public abstract class SerializableDictionaryBase<TKey, TValue, TValueStorage> : SerializableDictionaryBase,
        IDictionary<TKey, TValue>, IDictionary, ISerializationCallbackReceiver, IDeserializationCallback, ISerializable
    {
        Dictionary<TKey, TValue> m_dict;
        [SerializeField] TKey[] m_keys;
        [SerializeField] TValueStorage[] m_values;

        public SerializableDictionaryBase()
        {
            m_dict = new Dictionary<TKey, TValue>();
        }

        public SerializableDictionaryBase(IDictionary<TKey, TValue> dict)
        {
            m_dict = new Dictionary<TKey, TValue>(dict);
        }

        protected abstract void SetValue(TValueStorage[] storage, int i, TValue value);
        protected abstract TValue GetValue(TValueStorage[] storage, int i);

        public void CopyFrom(IDictionary<TKey, TValue> dict)
        {
            m_dict.Clear();
            foreach (var kvp in dict)
            {
                m_dict[kvp.Key] = kvp.Value;
            }
        }

        public void OnAfterDeserialize()
        {
            if (m_keys != null && m_values != null && m_keys.Length == m_values.Length)
            {
                m_dict.Clear();
                int n = m_keys.Length;
                for (int i = 0; i < n; ++i)
                {
                    m_dict[m_keys[i]] = GetValue(m_values, i);
                }

                m_keys = null;
                m_values = null;
            }
        }

        public void OnBeforeSerialize()
        {
            int n = m_dict.Count;
            m_keys = new TKey[n];
            m_values = new TValueStorage[n];

            int i = 0;
            foreach (var kvp in m_dict)
            {
                m_keys[i] = kvp.Key;
                SetValue(m_values, i, kvp.Value);
                ++i;
            }
        }

        #region IDictionary<TKey, TValue>

        public ICollection<TKey> Keys
        {
            get { return ((IDictionary<TKey, TValue>)m_dict).Keys; }
        }

        public ICollection<TValue> Values
        {
            get { return ((IDictionary<TKey, TValue>)m_dict).Values; }
        }

        public int Count
        {
            get { return ((IDictionary<TKey, TValue>)m_dict).Count; }
        }

        public bool IsReadOnly
        {
            get { return ((IDictionary<TKey, TValue>)m_dict).IsReadOnly; }
        }

        public TValue this[TKey key]
        {
            get { return ((IDictionary<TKey, TValue>)m_dict)[key]; }
            set { ((IDictionary<TKey, TValue>)m_dict)[key] = value; }
        }

        public void Add(TKey key, TValue value)
        {
            ((IDictionary<TKey, TValue>)m_dict).Add(key, value);
        }

        public bool ContainsKey(TKey key)
        {
            return ((IDictionary<TKey, TValue>)m_dict).ContainsKey(key);
        }

        public bool Remove(TKey key)
        {
            return ((IDictionary<TKey, TValue>)m_dict).Remove(key);
        }

        public bool TryGetValue(TKey key, out TValue value)
        {
            return ((IDictionary<TKey, TValue>)m_dict).TryGetValue(key, out value);
        }

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

        public void Clear()
        {
            ((IDictionary<TKey, TValue>)m_dict).Clear();
        }

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

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

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

        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            return ((IDictionary<TKey, TValue>)m_dict).GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IDictionary<TKey, TValue>)m_dict).GetEnumerator();
        }

        #endregion

        #region IDictionary

        public bool IsFixedSize
        {
            get { return ((IDictionary)m_dict).IsFixedSize; }
        }

        ICollection IDictionary.Keys
        {
            get { return ((IDictionary)m_dict).Keys; }
        }

        ICollection IDictionary.Values
        {
            get { return ((IDictionary)m_dict).Values; }
        }

        public bool IsSynchronized
        {
            get { return ((IDictionary)m_dict).IsSynchronized; }
        }

        public object SyncRoot
        {
            get { return ((IDictionary)m_dict).SyncRoot; }
        }

        public object this[object key]
        {
            get { return ((IDictionary)m_dict)[key]; }
            set { ((IDictionary)m_dict)[key] = value; }
        }

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

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

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

        public void Remove(object key)
        {
            ((IDictionary)m_dict).Remove(key);
        }

        public void CopyTo(Array array, int index)
        {
            ((IDictionary)m_dict).CopyTo(array, index);
        }

        #endregion

        #region IDeserializationCallback

        public void OnDeserialization(object sender)
        {
            ((IDeserializationCallback)m_dict).OnDeserialization(sender);
        }

        #endregion

        #region ISerializable

        protected SerializableDictionaryBase(SerializationInfo info, StreamingContext context)
        {
            m_dict = new Dictionary<TKey, TValue>(info, context);
        }

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            ((ISerializable)m_dict).GetObjectData(info, context);
        }

        #endregion
    }

    public static class SerializableDictionary
    {
        public class Storage<T> : SerializableDictionaryBase.Storage
        {
            public T data;
        }
    }

    [Serializable]
    public class SerializableDictionary<TKey, TValue> : SerializableDictionaryBase<TKey, TValue, TValue>
    {
        public SerializableDictionary()
        {
        }

        public SerializableDictionary(IDictionary<TKey, TValue> dict) : base(dict)
        {
        }

        protected SerializableDictionary(SerializationInfo info, StreamingContext context) : base(info, context)
        {
        }

        protected override TValue GetValue(TValue[] storage, int i)
        {
            return storage[i];
        }

        protected override void SetValue(TValue[] storage, int i, TValue value)
        {
            storage[i] = value;
        }
    }

    [Serializable]
    public class
        SerializableDictionary<TKey, TValue, TValueStorage> : SerializableDictionaryBase<TKey, TValue, TValueStorage>
        where TValueStorage : SerializableDictionary.Storage<TValue>, new()
    {
        public SerializableDictionary()
        {
        }

        public SerializableDictionary(IDictionary<TKey, TValue> dict) : base(dict)
        {
        }

        protected SerializableDictionary(SerializationInfo info, StreamingContext context) : base(info, context)
        {
        }

        protected override TValue GetValue(TValueStorage[] storage, int i)
        {
            return storage[i].data;
        }

        protected override void SetValue(TValueStorage[] storage, int i, TValue value)
        {
            storage[i] = new TValueStorage();
            storage[i].data = value;
        }
    }
}