using System.Collections.Generic;

namespace Ubisoft
{
    /// <summary>
    /// It holds preferences only locally in memory. They are NOT persisted.
    /// </summary>
    public class HtPlayerPrefs_Memory : HtPlayerPrefs
    {
        private Dictionary<string, IHtPlayerPrefs.EType> StoredKeys { get; set; }

        private Dictionary<string, bool> BoolValues { get; set; }
        private Dictionary<string, float> FloatValues { get; set; }
        private Dictionary<string, int> IntValues { get; set; }
        private Dictionary<string, long> LongValues { get; set; }
        private Dictionary<string, string> StringValues { get; set; }

        /// <summary>
        /// Create an <c>HtPlayerPrefs_Memory</c> object to store data in memory for the channel passed in. These data are NOT persisted.
        /// </summary>
        /// <param name="channel">Name of the channel to use to store data saved through this object.</param>
        /// <param name="logger">An <c>HtLogger.Channel</c> object to use to log data to.
        ///                      If no object is passed in then a default one called 'HT_PlayerPrefs('channel')' is created. </param>
        /// <param name="isVerbose">When <c>true</c> logs are printed out. Use it only for debug purposes.
        ///                       Make sure that Trace is the minimum log level set in your Logger configuration.</param>
        public HtPlayerPrefs_Memory(string channel, HtLogger.Channel logger = null, bool isVerbose = false) : base(channel, logger, isVerbose)
        {
            StoredKeys = new Dictionary<string, IHtPlayerPrefs.EType>();
            BoolValues = new Dictionary<string, bool>();
            FloatValues = new Dictionary<string, float>();
            IntValues = new Dictionary<string, int>();
            LongValues = new Dictionary<string, long>();
            StringValues = new Dictionary<string, string>();
        }

        #region HtPlayerPrefs

        public override bool GetBool(string key, bool defaultValue = false)
        {
            _ = BoolValues.TryGetValue(key, out defaultValue);
            return defaultValue;
        }

        public override float GetFloat(string key, float defaultValue = 0f)
        {
            _ = FloatValues.TryGetValue(key, out defaultValue);
            return defaultValue;
        }

        public override int GetInt(string key, int defaultValue = 0)
        {
            _ = IntValues.TryGetValue(key, out defaultValue);
            return defaultValue;
        }

        public override long GetLong(string key, long defaultValue = 0)
        {
            _ = LongValues.TryGetValue(key, out defaultValue);
            return defaultValue;
        }

        public override string GetString(string key, string defaultValue = "")
        {
            _ = StringValues.TryGetValue(key, out defaultValue);
            return defaultValue;
        }

        public override IHtPlayerPrefs.EType GetType(string key)
        {
            return StoredKeys.ContainsKey(key) ? StoredKeys[key] : IHtPlayerPrefs.EType.None;
        }

        public override bool HasKey(string key)
        {
            return StoredKeys.ContainsKey(key);
        }

        protected override void ExtendedDeleteAll()
        {
            StoredKeys.Clear();
            UpdateRawStoredKeys();

            BoolValues.Clear();
            FloatValues.Clear();
            IntValues.Clear();
            LongValues.Clear();
            StringValues.Clear();
        }

        protected override void ExtendedDeleteKey(string key)
        {
            if (StoredKeys.ContainsKey(key))
            {
                IHtPlayerPrefs.EType type = StoredKeys[key];
                switch (type)
                {
                    case IHtPlayerPrefs.EType.Bool:
                        if (BoolValues.ContainsKey(key))
                        {
                            _ = BoolValues.Remove(key);
                        }
                        break;

                    case IHtPlayerPrefs.EType.Float:
                        if (FloatValues.ContainsKey(key))
                        {
                            _ = FloatValues.Remove(key);
                        }
                        break;

                    case IHtPlayerPrefs.EType.Int:
                        if (IntValues.ContainsKey(key))
                        {
                            _ = IntValues.Remove(key);
                        }
                        break;

                    case IHtPlayerPrefs.EType.Long:
                        if (LongValues.ContainsKey(key))
                        {
                            _ = LongValues.Remove(key);
                        }
                        break;

                    case IHtPlayerPrefs.EType.String:
                        if (StringValues.ContainsKey(key))
                        {
                            _ = StringValues.Remove(key);
                        }
                        break;
                }

                _ = StoredKeys.Remove(key);
                UpdateRawStoredKeys();
            }
        }

        protected override void ExtendedSave()
        {
            // Nothing since data only need to be stored im memory
        }

        protected override void ExtendedSetBool(string key, bool value)
        {
            if (BoolValues.ContainsKey(key))
            {
                BoolValues[key] = value;
            }
            else
            {
                BoolValues.Add(key, value);
                AddStoredKey(key, IHtPlayerPrefs.EType.Bool);
            }
        }

        protected override void ExtendedSetFloat(string key, float value)
        {
            if (FloatValues.ContainsKey(key))
            {
                FloatValues[key] = value;
            }
            else
            {
                FloatValues.Add(key, value);
                AddStoredKey(key, IHtPlayerPrefs.EType.Float);
            }
        }

        protected override void ExtendedSetInt(string key, int value)
        {
            if (IntValues.ContainsKey(key))
            {
                IntValues[key] = value;
            }
            else
            {
                IntValues.Add(key, value);
                AddStoredKey(key, IHtPlayerPrefs.EType.Int);
            }
        }

        protected override void ExtendedSetLong(string key, long value)
        {
            if (LongValues.ContainsKey(key))
            {
                LongValues[key] = value;
            }
            else
            {
                LongValues.Add(key, value);
                AddStoredKey(key, IHtPlayerPrefs.EType.Long);
            }
        }

        protected override void ExtendedSetString(string key, string value)
        {
            if (StringValues.ContainsKey(key))
            {
                StringValues[key] = value;
            }
            else
            {
                StringValues.Add(key, value);
                AddStoredKey(key, IHtPlayerPrefs.EType.String);
            }
        }

        public override string ToString()
        {
            return $"StoredKeys: {RawStoredKeys}\nContent: {ContentAsString()}";
        }

        #endregion

        #region Private Methods

        private string ContentAsString()
        {
            string returnValue = "";

            string valueAsString;
            foreach (KeyValuePair<string, IHtPlayerPrefs.EType> pair in StoredKeys)
            {
                if (HasKey(pair.Key))
                {
                    if (pair.Value != IHtPlayerPrefs.EType.None)
                    {
                        valueAsString = null;

                        switch (pair.Value)
                        {
                            case IHtPlayerPrefs.EType.Bool:
                                valueAsString = GetBool(pair.Key).ToString();
                                break;

                            case IHtPlayerPrefs.EType.Int:
                                valueAsString = GetInt(pair.Key).ToString();
                                break;

                            case IHtPlayerPrefs.EType.Long:
                                valueAsString = GetLong(pair.Key).ToString();
                                break;

                            case IHtPlayerPrefs.EType.Float:
                                valueAsString = GetFloat(pair.Key).ToString();
                                break;

                            case IHtPlayerPrefs.EType.String:
                                valueAsString = GetString(pair.Key);
                                break;
                        }

                        if (valueAsString != null)
                        {
                            if (!string.IsNullOrEmpty(returnValue))
                            {
                                returnValue += $",";
                            }

                            returnValue += $"{pair.Key}:{valueAsString}";
                        }
                    }
                }
            }

            return returnValue;
        }

        private void AddStoredKey(string key, IHtPlayerPrefs.EType type)
        {
            if (!StoredKeys.ContainsKey(key) && type != IHtPlayerPrefs.EType.None)
            {
                StoredKeys.Add(key, type);
                RawStoredKeys = AddRawStoredKey(key, type, RawStoredKeys);
            }
        }

        private string RawStoredKeys { get; set; }

        private void UpdateRawStoredKeys()
        {
            string value = "";
            foreach (KeyValuePair<string, IHtPlayerPrefs.EType> pair in StoredKeys)
            {

                value = AddRawStoredKey(pair.Key, pair.Value, value);
            }

            RawStoredKeys = value;
        }

        #endregion
    }
}