/*
    Copyright (c) 2009 Marko Parkkola

    Permission is hereby granted, free of charge, to any person
    obtaining a copy of this software and associated documentation
    files (the "Software"), to deal in the Software without
    restriction, including without limitation the rights to use,
    copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following
    conditions:

    The above copyright notice and this permission notice shall be
    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
    OTHER DEALINGS IN THE SOFTWARE.
 */

using System;
using System.IO;
using System.Reflection;
using System.Linq;
using System.Xml.Linq;
using System.Xml.Serialization;

namespace Weicco.Lib.Configuration
{
    public sealed class ConfigurationManager<TConf> where TConf : ConfigurationBase
    {
        private static readonly ConfigurationBase _config = null;

        static ConfigurationManager()
        {
            _config = Activator.CreateInstance<TConf>();
        }

        public ConfigurationManager()
        {
        }

        /// <summary>
        /// Returns the actual configuration object.
        /// </summary>
        /// <returns>Configuration object.</returns>
        public TConf GetConfiguration()
        {
            return (TConf)_config;
        }

        private string ConfigurationPathBase
        {
            get
            {
                string path = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) +
                    "\\Weicco.Lib.Configuration\\";

                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }

                return path;
            }
        }

        /// <summary>
        /// Full path where configuration file is found.
        /// </summary>
        public string ConfigurationPath
        {
            get
            {
                return ConfigurationPathBase + _config.Name + ".xml";
            }
        }

        /// <summary>
        /// Loads and deserializes configuration object into memory.
        /// </summary>
        public void Load()
        {
            Type type = typeof(TConf);
            var query = from pi in type.GetProperties().OfType<System.Reflection.PropertyInfo>()
                        where pi.CanRead && pi.CanWrite && !pi.PropertyType.IsArray && !pi.PropertyType.IsInterface
                        select pi;

            XDocument config = XDocument.Load(ConfigurationPath);
            foreach (var pi in query)
            {
                XElement element = (from e in config.Descendants()
                                    where e.Attribute("Name") != null && e.Attribute("Name").Value == pi.Name
                                    select e).FirstOrDefault();

                XmlSerializer ser = new XmlSerializer(pi.PropertyType);
                pi.SetValue(_config, ser.Deserialize(element.CreateReader()), null);
            }

            _config.Loading(config.Descendants("values").Single());
        }

        /// <summary>
        /// Serializes and saves configuration object to file.
        /// </summary>
        public void Save()
        {
            Type type = typeof(TConf);
            var query = from pi in type.GetProperties().OfType<System.Reflection.PropertyInfo>()
                        where pi.CanRead && pi.CanWrite && !pi.PropertyType.IsArray && !pi.PropertyType.IsInterface
                        select pi;

            XDocument config = new XDocument(new XElement(XName.Get("configuration"), new XElement("values")));

            if (query.Count() > 0)
            {
                foreach (var pi in query)
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        XmlSerializer ser = new XmlSerializer(pi.PropertyType);
                        ser.Serialize(ms, pi.GetValue(_config, null));

                        ms.Position = 0;
                       
                        XElement e = XElement.Load(ms);
                        e.Add(new XAttribute("Name", pi.Name));

                        config.Descendants("values").Single().Add(e);
                    }
                }
            }

            _config.Saving(config.Descendants("values").Single());

            config.Save(ConfigurationPath);
        }

        /// <summary>
        /// Checks if configuration file exists.
        /// </summary>
        /// <returns>True if file exists, false otherwise.</returns>
        /// <remarks>Validity of configuration file is not checked.</remarks>
        public bool Exists()
        {
            return File.Exists(ConfigurationPath);
        }

        private FileSystemWatcher fileWatcher = null;

        /// <summary>
        /// Waits for change in configuration file.
        /// </summary>
        /// <remarks>Waiting is done synchronously so this method blocks until configuration file is changed.</remarks>
        public void WaitForChange()
        {
            if (fileWatcher == null)
            {
                fileWatcher = new FileSystemWatcher(ConfigurationPathBase);
                fileWatcher.Filter = Path.GetFileName(ConfigurationPath);
            }

            fileWatcher.WaitForChanged(WatcherChangeTypes.All);
        }
    }

    public abstract class ConfigurationBase
    {
        protected ConfigurationBase(string name)
        {
            Name = name;
        }

        /// <summary>
        /// Name of the configuration (and configuration file).
        /// </summary>
        public string Name { get; private set; }

        /// <summary>
        /// Override this for custom deserialization.
        /// </summary>
        /// <param name="baseElement">Base element under which all value elements are found.</param>
        protected internal virtual void Loading(XElement baseElement)
        {
        }

        /// <summary>
        /// Override this for custom serialization.
        /// </summary>
        /// /// <param name="baseElement">Base element under which you can save your own elements.
        /// Take notice not to don't add any elements with Name attribute which already exists in configuration XML.</param>
        protected internal virtual void Saving(XElement baseElement)
        {
        }
    }
}