using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Xml;
using System.Xml.Linq;

namespace OpenTap
{
    class ComponentSettingsContext
    {
        static readonly TraceSource log = Log.CreateSource("Settings");

        readonly Memorizer<Type, ComponentSettings> objectCache;
        readonly Dictionary<string, string> groupDir = new Dictionary<string, string>();
        readonly Queue<TapSerializer> flushQueues = new Queue<TapSerializer>();

        public bool readOnlyContext = false;

        public ComponentSettingsContext()
        {
            objectCache = new Memorizer<Type, ComponentSettings>(Load);
        }

        string settingsDirectoryRoot = Path.Combine(ExecutorClient.ExeDir, "Settings");

        void Invalidate(IList<ComponentSettings> setting)
        {
            // Settings can be co-dependent. Example: Connections and Instruments.
            // So we need to invalidate all the settings,  invoke the event afterwards.
            foreach (var componentSetting in setting)
                objectCache.Invalidate(componentSetting.GetType());
            foreach (var componentSetting in setting)
                componentSetting.InvokeInvalidate();
        }

        public void InvalidateAllSettings()
        {
            var cachedComponentSettings = objectCache.GetResults()
                .Where(x => x != null)
                .ToArray();
            Invalidate(cachedComponentSettings);
        }

        public void SaveAllCurrentSettings()
        {
            foreach (var cacheType in xmlCache.Keys.ToArray())
                GetCurrent(cacheType);
            foreach (var comp in objectCache.GetResults().Where(x => x != null))
                Save(comp);
        }

        public event EventHandler CacheInvalidated;


        /// <summary> Directory root for platform settings. </summary>    
        public string SettingsDirectoryRoot
        {
            get => settingsDirectoryRoot;
            set
            {
                settingsDirectoryRoot = value;
                InvalidateAllSettings();
            }
        }

        public void Reload() => CacheInvalidated?.Invoke(this, new EventArgs());

        public void Invalidate(Type t) => Invalidate(ComponentSettings.GetCurrent(t).AsSingle());

        public string GetSaveFilePath(Type type)
        {
            if (type == null)
                throw new ArgumentNullException(nameof(type));
            if (type.DescendsTo(typeof(ComponentSettings)) == false)
                throw new ArgumentException(
                    "Type must inherit from ComponentSettings, otherwise it does not have a settings file.",
                    nameof(type));
            var settingsGroup = type.GetAttribute<SettingsGroupAttribute>();

            bool isProfile = settingsGroup?.Profile ?? false;
            string groupName = settingsGroup == null ? "" : settingsGroup.GroupName;

            // DisplayAttribute.GetFullName() joins the groups with ' \ ', but adding this space makes the save path invalid.
            var disp = type.GetDisplayAttribute();
            var groups = disp.Group.Length == 0 ? new[] { disp.Name } : disp.Group.Append(disp.Name);
            string fullName = string.Join("\\", groups);

            return Path.Combine(GetSettingsDirectory(groupName, isProfile),
                fullName + ".xml");
        }

        public void Save(ComponentSettings setting)
        {
            if (readOnlyContext) throw new Exception("Cannot save a read-only component settings context");
            EnsureSettingsDirectoryExists(setting.GroupName, setting.profile);

            string path = GetSaveFilePath(setting.GetType());
            string dir = Path.GetDirectoryName(path);
            if (dir != "" && !Directory.Exists(dir))
                Directory.CreateDirectory(dir);
            var sw = Stopwatch.StartNew();

            using (var str = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
            {
                using (var xmlWriter =
                    System.Xml.XmlWriter.Create(str, new System.Xml.XmlWriterSettings { Indent = true }))
                    new TapSerializer().Serialize(xmlWriter, setting);
            }

            log.Debug(sw, "Saved {0} to {1}", setting.GetType().Name, path);
        }

        public void EnsureSettingsDirectoryExists(string groupName, bool isProfile = true)
        {
            if (!Directory.Exists(SettingsDirectoryRoot))
                Directory.CreateDirectory(SettingsDirectoryRoot);
            if (!Directory.Exists(GetSettingsDirectory(groupName, isProfile)))
                Directory.CreateDirectory(GetSettingsDirectory(groupName, isProfile));
        }

        /// <summary>
        /// The directory where the settings are loaded from / saved to.
        /// </summary>
        /// <param name="groupName">Name of the settings group.</param>
        /// <param name="isProfile">If the settings group uses profiles, we load the default profile.</param>
        /// <returns></returns>
        public string GetSettingsDirectory(string groupName, bool isProfile = true)
        {
            if (groupName == null)
                throw new ArgumentNullException(nameof(groupName));
            if (isProfile == false)
                return Path.Combine(SettingsDirectoryRoot, groupName);
            if (!groupDir.ContainsKey(groupName))
            {
                var file = Path.Combine(SettingsDirectoryRoot, groupName, "CurrentProfile");

                if (File.Exists(file))
                    groupDir[groupName] = File.ReadAllText(file);
                else
                    groupDir[groupName] = "Default";
            }


            return Path.Combine(SettingsDirectoryRoot, groupName, groupDir[groupName]);
        }

        public ComponentSettings GetCurrent(Type settingsType)
        {
            lock (flushQueues)
            {
                if (flushQueues.Count == 0)
                {
                    var result = objectCache.Invoke(settingsType);
                    while (flushQueues.Count > 0)
                        flushQueues.Dequeue().Flush();
                    return result;
                }
            }

            return objectCache.Invoke(settingsType);
        }

        public void SetCurrent(Stream xmlFileStream, out IEnumerable<XmlError> errors)
        {
            xmlFileStream.Position = 0;
            using (var mem = new MemoryStream())
            {
                xmlFileStream.CopyTo(mem);
                mem.Position = 0;
                try
                {
                    var doc = XDocument.Load(mem, LoadOptions.SetLineInfo);
                    if (doc.Root.Attribute("type") is null)
                    {
                        errors = new[]
                        {
                            new XmlError(doc.Root,
                                "Stream does not contain valid ComponentSettings. Unable to determine ComponentSettings type from root attribute.")
                        };
                        return;
                    }

                    ITypeData typedata = TypeData.GetTypeData(doc.Root.Attribute(TapSerializer.typeName).Value);
                    xmlCache[typedata.AsTypeData().Type] = mem.ToArray();
                    Invalidate(typedata.AsTypeData().Type);
                    errors = ComponentSettings.GetCurrent(typedata)?.loadErrors ?? Array.Empty<XmlError>();
                }
                catch (XmlException ex)
                {
                    errors = new[] { new XmlError(null, ex.Message, ex) };
                }
            }
        }

        public void SetCurrent(Stream xmlFileStream)
        {
            xmlFileStream.Position = 0;
            using (var mem = new MemoryStream())
            {
                xmlFileStream.CopyTo(mem);
                mem.Position = 0;
                try
                {
                    var doc = XDocument.Load(mem);
                    if (doc.Root.Attribute("type") is null)
                    {
                        mem.Position = 0;
                        throw new InvalidDataException($"Stream does not contain valid ComponentSettings. Unable to determine ComponentSettings type from root attribute. Content: {Encoding.UTF8.GetString(mem.ToArray())}");
                    }
                    ITypeData typedata = TypeData.GetTypeData(doc.Root.Attribute(TapSerializer.typeName).Value);
                    xmlCache[typedata.AsTypeData().Type] = mem.ToArray();
                    Invalidate(typedata.AsTypeData().Type);
                }
                catch (XmlException ex)
                {
                    mem.Position = 0;
                    throw new InvalidDataException($"Stream does not contain valid ComponentSettings. Unable to parse XML. Content: {Encoding.UTF8.GetString(mem.ToArray())}", ex);
                }
            }
        }

        public ComponentSettings GetCurrentFromCache(Type settingsType) =>
            objectCache.GetCached(settingsType);

        /// <summary>
        /// Loads a new instance of the settings for a given component.
        /// </summary>
        /// <param name="settingsType">The type of the component settings to load (this type must be a descendant of <see cref="ComponentSettings"/>).</param>
        /// <returns>Returns the settings.</returns>
        public ComponentSettings Load(Type settingsType)
        {
            xmlCache.TryGetValue(settingsType, out byte[] cachedXml);

            string path = GetSaveFilePath(settingsType);
            Stopwatch timer = Stopwatch.StartNew();

            ComponentSettings settings = null;
            if (cachedXml != null || File.Exists(path))
            {
                try
                {
                    Stream reader;
                    if (cachedXml != null)
                        reader = new MemoryStream(cachedXml);
                    else reader = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);

                    using (var str = reader)
                    {
                        var serializer = new TapSerializer();
                        lock (flushQueues)
                            flushQueues.Enqueue(serializer);
                        settings = (ComponentSettings)serializer.Deserialize(str, false,
                            TypeData.FromType(settingsType), path: path);
                        settings.loadErrors = serializer.XmlErrors?.ToArray();
                    }
                }
                catch (Exception ex) when (ex.InnerException is System.ComponentModel.LicenseException lex)
                {
                    log.Warning("Unable to load '{0}'. {1}", settingsType.GetDisplayAttribute().GetFullName(),
                        lex.Message);
                }
                catch (Exception ex)
                {
                    if (ex.InnerException != null)
                    {
                        if (ex.InnerException.Message.StartsWith("The specified type was not recognized"))
                            log.Warning("Error loading settings file for {0}. {1}.", settingsType.Name,
                                ex.InnerException.Message);
                        else
                            log.Warning(
                                "Error loading settings file for {0}. Is it an old version? A new file will be created with default values.",
                                settingsType.Name);
                    }

                    log.Debug(ex);
                }

                log.Debug(timer, "{0} loaded from {1}", settingsType.Name, path);
            }

            if (settings == null)
            {
                try
                {
                    settings = (ComponentSettings)Activator.CreateInstance(settingsType);
                }
                catch (TargetInvocationException ex)
                {
                    log.Error("Could not create '{0}': {1}", settingsType.GetDisplayAttribute().Name,
                        ex.InnerException.Message);
                    log.Debug(ex);
                    return null;
                }
                catch (Exception e)
                {
                    log.Error("Caught exception while creating instance of '{0}'", settingsType.FullName);
                    log.Debug(e);
                    return null;
                }

                settings.Initialize();

                log.Debug(timer,
                    "No settings file exists for {0}. A new instance with default values has been created.",
                    settingsType.Name);
            }

            return settings;
        }

        public void SetSettingsProfile(string groupName, string profileName)
        {
            if (groupName == null)
                throw new ArgumentNullException(nameof(groupName));
            if (profileName == null)
                throw new ArgumentNullException(nameof(profileName));

            if (GetSettingsDirectory(groupName) == profileName)
                return;

            if (ComponentSettings.PersistSettingGroups)
            {
                try
                {
                    EnsureSettingsDirectoryExists(groupName);
                }
                catch
                {
                }

                var currentSettingsFile = Path.Combine(SettingsDirectoryRoot, groupName, "CurrentProfile");
                if (File.Exists(currentSettingsFile))
                    File.SetAttributes(currentSettingsFile, FileAttributes.Normal);
                File.WriteAllText(currentSettingsFile,
                    FileSystemHelper.GetRelativePath(Path.GetFullPath(Path.Combine(SettingsDirectoryRoot, groupName)),
                        Path.GetFullPath(profileName)));
                File.SetAttributes(currentSettingsFile, FileAttributes.Hidden);
            }

            groupDir[groupName] = profileName;
            InvalidateAllSettings();
        }

        readonly Dictionary<Type, byte[]> xmlCache = new Dictionary<Type, byte[]>();

        public ComponentSettingsContext Clone()
        {
            var session = new ComponentSettingsContext
            {
                SettingsDirectoryRoot = settingsDirectoryRoot,
            };
            var loadedSettings = objectCache.GetResults().Where(x => x != null).ToArray();
            var serializer = new TapSerializer();
            var mem = new MemoryStream();
            foreach (var setting in loadedSettings)
            {
                mem.Seek(0, SeekOrigin.Begin);
                mem.SetLength(0);

                serializer.Serialize(mem, setting);
                session.xmlCache[setting.GetType()] = mem.ToArray();
            }

            return session;
        }
    }
}