using System.Collections.Generic;

using UnityEngine;

namespace Ubisoft
{
    /// <summary>
    /// Class responsible for managing all <c>IHtPlayerPrefs</c> objects.
    /// 
    /// In order to keep preferences from getting accidentally overriden consumers are allowed to have only one <c>IHtPlayerPrefs</c> object
    /// per channel. This can be guaranteed by allowing consumers to get an <c>IHtPlayerPrefs</c> instance only via this class.
    ///
    /// Please, call Destroy() once you are done with this class, typically right before restarting your app, in order to make sure that
    /// all <c>IHtPlayerPrefs</c> are saved and destroyed properly so you can restart your app clean.
    /// </summary>
    public class HtPlayerPrefsService : HtSingletonHolder.IConsumer
    {
        public enum EError
        {
            None,
            PlayerPrefsForChannelAlreadyExist
        }

        public delegate void OnCreateDelegate(string channel, EError error, IHtPlayerPrefs playerPrefs);

        private HtPlayerPrefsFactory Factory { get; set; }
        private List<IHtPlayerPrefs> Catalog { get; }

        private HtPlayerPrefsMonoBehaviour MonoBehaviour { get; set; }

        public HtPlayerPrefsService(HtPlayerPrefsFactory factory)
        {
            Factory = factory;
            Catalog = new List<IHtPlayerPrefs>();

            // MonoBehaviour is created to take care of key Unity events.
            MonoBehaviour = HtSingletonHolder.AddMainComponent<HtPlayerPrefsMonoBehaviour>(this);
            MonoBehaviour.Init(this);
        }

        ~HtPlayerPrefsService()
        {
            InternalDestroy(false);
        }

        /// <summary>
        /// Save and destroy all <c>IHtPlayePrefs</c> objects. Please, call this method right before restarting your app.
        /// </summary>
        public void Destroy()
        {
            InternalDestroy(true);
        }

        private void InternalDestroy(bool destroyMonoBehaviour)
        {
            if (MonoBehaviour != null)
            {
                HtSingletonHolder.RemoveMainComponent<MonoBehaviour>(destroyMonoBehaviour);
                MonoBehaviour = null;
            }

            if (Catalog != null)
            {
                int count = Catalog.Count;
                for (int i = 0; i < count; ++i)
                {
                    // Save it before destroying it
                    if (Catalog[i].NeedsToSave)
                    {
                        Catalog[i].Save();
                    }
                }

                Catalog.Clear();
            }

            Factory = null;
        }

        /// <summary>
        /// Create an <c>IHtPlayerPrefs></c> instance by using the config associated to the requested channel.
        /// This task is asynchronous as some <c>IHtPlayerPrefs</c> implementations may need to communicate with Server.
        /// </summary>
        /// <param name="channel">PlayePrefs channel to save preferences to.</param>
        /// <param name="onCreateDelegate">Delegate to call once the object is ready.</param>
        public void CreatePlayerPrefs(string channel, OnCreateDelegate onCreateDelegate)
        {
            EError error = EError.None;
            IHtPlayerPrefs returnValue = null;

            // Only an instance per channel is allowed to keep this channel preferences from getting accidentally overriden.
            if (GetPlayerPrefs(channel) == null)
            {
                returnValue = Factory.Create(channel);
                Catalog.Add(returnValue);
            }
            else
            {
                error = EError.PlayerPrefsForChannelAlreadyExist;
                Factory.Logger.LogError($"An instance for channel {Debug.FormatTextInUserContext(channel)} already exists.");
            }

            onCreateDelegate?.Invoke(channel, error, returnValue);
        }

        /// <summary>
        /// Destroy the instance used for the channel passed in, if it exists.
        /// </summary>
        /// <param name="channel">PlayePrefs channel to destroy.</param>
        public void DestroyPlayerPrefs(string channel)
        {
            IHtPlayerPrefs prefs = GetPlayerPrefs(channel);
            if (prefs != null)
            {
                // Save it before destroying it
                if (prefs.NeedsToSave)
                {
                    prefs.Save();
                }

                _ = Catalog.Remove(prefs);
            }
        }

        /// <summary>
        /// Retrieve the <c>IHtPlayerPrefs</c> object used for the channel passed in, if it exists.
        /// You need to have called <c>CreatePlayerPrefs()</c>  before calling this method.
        /// </summary>
        /// <param name="channel">PlayerPrefs channel to retrieve.</param>
        /// <returns>The instance of <c>IHtPlayerPrefs</c></returns> responsible for saving this channel preferences, if it exists", otherwise <c>null</c>.</returns>
        public IHtPlayerPrefs GetPlayerPrefs(string channel)
        {
            IHtPlayerPrefs returnValue = null;

            int count = Catalog.Count;
            for (int i = 0; i < count && returnValue == null; ++i)
            {
                if (Catalog[i].Channel.Equals(channel))
                {
                    returnValue = Catalog[i];
                }
            }

            return returnValue;
        }

        /// <summary>
        /// Delete preferences for all channels that are currently in memory.
        /// </summary>
        public void DeleteAllPlayerPrefs()
        {
            int count = Catalog.Count;
            for (int i = 0; i < count; ++i)
            {
                Catalog[i].DeleteAll();
            }
        }

        /// <summary>
        /// Save all channel preferences that are currently in memory.
        /// </summary>
        public void SaveAllPlayerPrefs()
        {
            InternalSave(true);
        }

        /// <summary>
        /// Callbak called when HtSingletonHolder is destroyed.
        /// 
        /// Consumers shouldn't call this method.
        /// </summary>
        /// <param name="singleton">Component that is about to be destroyed.</param>
        public void DestroySingleton(Component singleton)
        {
            if (singleton == MonoBehaviour)
            {
                MonoBehaviour = null;
            }
        }

        internal void Update()
        {
            InternalSave(false);
        }

        private void InternalSave(bool force)
        {
            // Make sure that all IHtPlayerPref objects save their preferences if AutomaticSave is enabled.
            int count = Catalog.Count;
            for (int i = 0; i < count; ++i)
            {
                Catalog[i].Update();

                if ((force || Catalog[i].AutomaticSave) && Catalog[i].NeedsToSave)
                {
                    Catalog[i].Save();
                }
            }
        }
    }
}