using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tango.Logging;
using Tango.Serialization;

namespace Tango.Settings
{
    /// <summary>
    /// Represents a settings manager for loading and saving application settings. 
    /// </summary>
    public static class SettingsManager
    {
        private static LogManager LogManager = LogManager.Default;

        /// <summary>
        /// Gets or sets a value indicating whether the settings manager is initialized.
        /// </summary>
        public static bool IsInitialized { get; private set; }

        /// <summary>
        /// Gets or sets the default settings.
        /// </summary>
        /// <value>
        /// The default.
        /// </value>
        public static SettingsCollection Default { get; private set; }

        /// <summary>
        /// Gets or sets the default file path.
        /// </summary>
        /// <value>
        /// The default file path.
        /// </value>
        public static String DefaultFilePath { get; private set; }

        /// <summary>
        /// Gets or sets the default folder for application settings.
        /// </summary>
        public static String DefaultFolder { get; private set; }

        /// <summary>
        /// Saves application settings to XML file.
        /// </summary>
        /// <param name="filePath">The path to the XML file.</param>
        /// <param name="stCollection">The instance of the SettingsCollection to save.</param>
        public static void SaveToXML(String filePath, SettingsCollection stCollection)
        {
            LogManager.Log("Saving application configuration to " + "'" + filePath + "'");
            XmlDataSerializer serializer = new XmlDataSerializer();
            serializer.SerializeToFile<SettingsCollection>(stCollection, filePath);
        }

        /// <summary>
        /// Loads application settings from XML file.
        /// </summary>
        /// <param name="filePath">The file path.</param>
        /// <returns></returns>
        public static SettingsCollection LoadFromXML(String filePath)
        {
            LogManager.Log("Loading application configuration from " + "'" + filePath + "'");
            XmlDataSerializer serialier = new XmlDataSerializer();
            return serialier.DeserializeFromFile<SettingsCollection>(filePath);
        }

        /// <summary>
        /// Saves the default settings.
        /// </summary>
        public static void SaveDefaultSettings()
        {
            SaveToXML(DefaultFilePath, Default);
        }

        /// <summary>
        /// Restores to default.
        /// </summary>
        public static void RestoreToDefault()
        {
            Default = new SettingsCollection();
            SaveDefaultSettings();
        }

        /// <summary>
        /// Initializes the <see cref="SettingsManager"/> class.
        /// </summary>
        static SettingsManager()
        {
            Initialize();
        }

        /// <summary>
        /// Initializes the settings manager.
        /// </summary>
        private static void Initialize()
        {
            if (IsInitialized) return;

            IsInitialized = true;

            LogManager.Log("Initializing application configuration...");

            DefaultFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Twine", "Tango", "Settings.xml");
            DefaultFolder = Path.GetDirectoryName(DefaultFilePath);

            bool waited = false;

            Retry:

            try
            {
                Default = LoadFromXML(DefaultFilePath);
            }
            catch (Exception ex)
            {
                if (!waited)
                {
                    LogManager.Log(ex, "Could not load application configuration. Retrying in 1 second...");
                    waited = true;
                    Thread.Sleep(1000);
                    goto Retry;
                }
                else
                {
                    LogManager.Log(ex, "Could not load application configuration.");
                }

                try
                {
                    LogManager.Log("Creating application configuration directory structure...");
                    Directory.CreateDirectory(DefaultFolder);
                }
                catch (Exception ex2)
                {
                    LogManager.Log(ex2, "Could not generate directory structure.");
                }
            }

            if (Default == null)
            {
                Default = new SettingsCollection();

                try
                {
                    LogManager.Log("Generating default configuration file.");
                    SaveToXML(DefaultFilePath, Default);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Could not generate default configuration file.");
                }
            }
            else
            {
                LogManager.Log("Application configuration loaded successfully.");
            }
        }
    }
}