using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace VketCloudGUITools.Runtime
{
    [System.Serializable]
    public class SerializableDictionary<TKey, TValue, TKeyValuePair> : IDictionary<TKey, TValue>, ISerializationCallbackReceiver
        where TKeyValuePair : SerializableKeyValuePair<TKey, TValue>, new()
    {
        Dictionary<TKey, TValue> _innerDictionary = new Dictionary<TKey, TValue>();

        [SerializeField] List<TKeyValuePair> _keyValuePairs = new List<TKeyValuePair>();

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

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

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

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

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

        public ICollection<TKey> Keys => ((IDictionary<TKey, TValue>)_innerDictionary).Keys;

        public ICollection<TValue> Values => ((IDictionary<TKey, TValue>)_innerDictionary).Values;

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

        public void Clear()
        {
            ((ICollection<KeyValuePair<TKey, TValue>>)_innerDictionary).Clear();
        }

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

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

        public bool Remove(KeyValuePair<TKey, TValue> item)
        {
            var retval = ((ICollection<KeyValuePair<TKey, TValue>>)_innerDictionary).Remove(item);
            return retval;
        }

        public int Count => ((ICollection<KeyValuePair<TKey, TValue>>)_innerDictionary).Count;

        public bool IsReadOnly => ((ICollection<KeyValuePair<TKey, TValue>>)_innerDictionary).IsReadOnly;

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

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

        public void OnBeforeSerialize()
        {
            DictionaryToList();
        }

        public void OnAfterDeserialize()
        {
            ListToDictionary();
        }

        private void DictionaryToList()
        {
            _keyValuePairs.Clear();

            foreach (var kv in _innerDictionary)
            {
                var skv = new TKeyValuePair() { Key = kv.Key, Value = kv.Value };
                _keyValuePairs.Add(skv);
            }
        }

        private void ListToDictionary()
        {
            int count = _keyValuePairs.Count;

            for (int i = 0; i < _keyValuePairs.Count; ++i)
            {
                _innerDictionary.Add(_keyValuePairs[i].Key, _keyValuePairs[i].Value);
            }
        }
    }

    [System.Serializable]
    public class SerializableKeyValuePair<TKey, TValue>
    {
        public TKey Key;
        public TValue Value;

        public SerializableKeyValuePair()
        {
        }

        public SerializableKeyValuePair(TKey _key, TValue _value)
        {
            Key = _key;
            Value = _value;
        }

        public SerializableKeyValuePair(KeyValuePair<TKey, TValue> pair)
        {
            Key = pair.Key;
            Value = pair.Value;
        }
    }

    [System.Serializable]
    public class SerializableDictionaryStringBool : SerializableDictionary<string, bool, SerializableKeyValuePairStringBool>
    {
    }

    [System.Serializable]
    public class SerializableKeyValuePairStringBool : SerializableKeyValuePair<string, bool>
    {
    }

    [System.Serializable]
    public class SerializableDictionaryStringInt : SerializableDictionary<string, int, SerializableKeyValuePairStringInt>
    {
    }

    [System.Serializable]
    public class SerializableKeyValuePairStringInt : SerializableKeyValuePair<string, int>
    {
    }

    [System.Serializable]
    public class SerializableDictionaryStringFloat : SerializableDictionary<string, float, SerializableKeyValuePairStringFloat>
    {
    }

    [System.Serializable]
    public class SerializableKeyValuePairStringFloat : SerializableKeyValuePair<string, float>
    {
    }

    [System.Serializable]
    public class SerializableDictionaryStringString : SerializableDictionary<string, string, SerializableKeyValuePairStringString>
    {
    }

    [System.Serializable]
    public class SerializableKeyValuePairStringString : SerializableKeyValuePair<string, string>
    {
    }

    [System.Serializable]
    public class SerializableDictionaryStringIntArray : SerializableDictionary<string, int[], SerializableKeyValuePairStringIntArray>
    {
    }

    [System.Serializable]
    public class SerializableKeyValuePairStringIntArray : SerializableKeyValuePair<string, int[]>
    {
    }

    [System.Serializable]
    public class SerializableDictionaryStringObject : IDictionary<string, System.Object>, ISerializationCallbackReceiver
    {
        Dictionary<string, System.Object> _innerDictionary = new Dictionary<string, System.Object>();

        [SerializeField] SerializableDictionaryStringBool _boolDictionary = new SerializableDictionaryStringBool();
        [SerializeField] SerializableDictionaryStringInt _intDictionary = new SerializableDictionaryStringInt();
        [SerializeField] SerializableDictionaryStringFloat _floatDictionary = new SerializableDictionaryStringFloat();
        [SerializeField] SerializableDictionaryStringString _stringDictionary = new SerializableDictionaryStringString();
        [SerializeField] SerializableDictionaryStringIntArray _intArrayDictionary = new SerializableDictionaryStringIntArray();

        // Unity のSerializeはFieldに対しnullが指定できない。Listの要素数でNull/非Nullを区別する回避策を行う
        [SerializeField] List<SerializableDictionaryStringObject> _recuesiveDictionary = new List<SerializableDictionaryStringObject>();

        public void Add(string key, object value)
        {
            ((IDictionary<string, object>)_innerDictionary).Add(key, value);
        }

        public bool ContainsKey(string key)
        {
            return ((IDictionary<string, object>)_innerDictionary).ContainsKey(key);
        }

        public bool Remove(string key)
        {
            return ((IDictionary<string, object>)_innerDictionary).Remove(key);
        }

        public bool TryGetValue(string key, out object value)
        {
            return ((IDictionary<string, object>)_innerDictionary).TryGetValue(key, out value);
        }

        public object this[string key] { get => ((IDictionary<string, object>)_innerDictionary)[key]; set => ((IDictionary<string, object>)_innerDictionary)[key] = value; }

        public ICollection<string> Keys => ((IDictionary<string, object>)_innerDictionary).Keys;

        public ICollection<object> Values => ((IDictionary<string, object>)_innerDictionary).Values;

        public void Add(KeyValuePair<string, object> item)
        {
            ((ICollection<KeyValuePair<string, object>>)_innerDictionary).Add(item);
        }

        public void Clear()
        {
            ((ICollection<KeyValuePair<string, object>>)_innerDictionary).Clear();
        }

        public bool Contains(KeyValuePair<string, object> item)
        {
            return ((ICollection<KeyValuePair<string, object>>)_innerDictionary).Contains(item);
        }

        public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
        {
            ((ICollection<KeyValuePair<string, object>>)_innerDictionary).CopyTo(array, arrayIndex);
        }

        public bool Remove(KeyValuePair<string, object> item)
        {
            return ((ICollection<KeyValuePair<string, object>>)_innerDictionary).Remove(item);
        }

        public int Count => ((ICollection<KeyValuePair<string, object>>)_innerDictionary).Count;

        public bool IsReadOnly => ((ICollection<KeyValuePair<string, object>>)_innerDictionary).IsReadOnly;

        public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
        {
            return ((IEnumerable<KeyValuePair<string, object>>)_innerDictionary).GetEnumerator();
        }

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

        public void OnBeforeSerialize()
        {
            DictionaryToList();
        }

        public void OnAfterDeserialize()
        {
            ListToDictionary();
        }

        private void DictionaryToList()
        {
            _boolDictionary.Clear();
            _intDictionary.Clear();
            _floatDictionary.Clear();
            _stringDictionary.Clear();
            _intArrayDictionary.Clear();
            _recuesiveDictionary.Clear();

            foreach (var kv in _innerDictionary)
            {
                if (kv.Value == null)
                {
                    continue;
                }
                else if (kv.Value is bool)
                {
                    _boolDictionary.Add(kv.Key, (bool)kv.Value);
                }
                else if (kv.Value is int)
                {
                    _intDictionary.Add(kv.Key, (int)kv.Value);
                }
                else if (kv.Value is float)
                {
                    _floatDictionary.Add(kv.Key, (float)kv.Value);
                }
                else if (kv.Value is string)
                {
                    _stringDictionary.Add(kv.Key, (string)kv.Value);
                }
                else if (kv.Value is int[])
                {
                    _intArrayDictionary.Add(kv.Key, (int[])kv.Value);
                }
                else if (kv.Value is Dictionary<string, System.Object>)
                {
                    if (_recuesiveDictionary.Count == 0)
                    {
                        _recuesiveDictionary.Add(new SerializableDictionaryStringObject());
                    }

                    _recuesiveDictionary[0].DictionaryToList();
                    _recuesiveDictionary[0].Add(kv.Key, (Dictionary<string, System.Object>)kv.Value);
                }
            }
        }

        private void ListToDictionary()
        {
            _innerDictionary.Clear();

            foreach (var kv in _boolDictionary)
            {
                _innerDictionary.Add(kv.Key, kv.Value);
            }
            foreach (var kv in _intDictionary)
            {
                _innerDictionary.Add(kv.Key, kv.Value);
            }
            foreach (var kv in _floatDictionary)
            {
                _innerDictionary.Add(kv.Key, kv.Value);
            }
            foreach (var kv in _stringDictionary)
            {
                _innerDictionary.Add(kv.Key, kv.Value);
            }
            foreach (var kv in _intArrayDictionary)
            {
                _innerDictionary.Add(kv.Key, kv.Value);
            }
            if (_recuesiveDictionary.Count > 0)
            {
                _recuesiveDictionary[0].ListToDictionary();
                foreach (var kv in _recuesiveDictionary[0])
                {
                    _innerDictionary.Add(kv.Key, kv.Value);
                }
            }
        }

        public void ForceSerialize()
        {
            DictionaryToList();
        }
    }
}