using System;

using System.Text;

using System.Linq;

using System.IO;

using System.Collections;

using System.Collections.Generic;

​

//YAML Imports

using YamlDotNet;

using YamlDotNet.Serialization;

​

//JSON Imports.

using Newtonsoft.Json;

using Newtonsoft.Json.Serialization;

​

//XAML Imports.

using System.Xml;

using System.Xml.Serialization;

​

using Webber.Configuration;

​

namespace Webber.Configuration.Tests

{

    public sealed class MainConfig : ConfigFile

    {

        public MainConfig(string path) : base(path, ConfigType.YAML)

        {}

        public string Name { get; set; } = "Carl";

        public int Age { get; set; } = 30;

        public double Height { get; set; } = 5.5;

        public bool IsMale { get; set; } = true;

    }

    public sealed class Program

    {

        public static void Main()

        {   

            MainConfig cfg;

            FileInfo conf = new FileInfo($"{Directory.GetCurrentDirectory()}/Config/webber.cfg");

            conf.Create().Close();

            cfg = new MainConfig(conf.FullName) 

            {

                Name = "Bob",

                Age = 25,

                Height = 6.2,

                IsMale = true

            };

            cfg.Write(true);

            cfg.Close();

            if (!conf.Exists)

            {

                cfg = new MainConfig(conf.FullName);

                cfg.Write(true);

                cfg.Close();

            }

            else

            {

                cfg = ConfigFile.ReadConfig<MainConfig>(conf.FullName, ConfigType.YAML);

                cfg.Write(true);

                cfg.Close();

            }

            Console.WriteLine("{0} a {1} year old {2} is {3} feet.", cfg.Name, cfg.Age, (cfg.IsMale) ? "Male" : "Female", cfg.Height);

        }

    }

}

​

namespace Webber.Configuration

{

    public enum ConfigType

    {

        YAML = 0,

        JSON = 1,

        XML = 2

    }

    public abstract class ConfigFile

    {

        private ISerializationSerializer serializer;

        private FileInfo file;

        private StreamWriter writer;

        protected ConfigFile(string path, ConfigType t)

        {

            try

            {

                //Create the specified serializer based on the ConfigType.

                serializer = (t.Equals(ConfigType.YAML)) ? new YAMLSerializer() : ((t.Equals(ConfigType.JSON)) ? new JSONSerializer() : new XMLSerializer(typeof(ConfigFile)));

                //Handle file and folder creation.

                file = new FileInfo(Path.GetFullPath(path));

                DirectoryInfo parentDir = file.Directory;

                if (!(parentDir.Exists))

                    parentDir.Create();

                if (!(file.Exists))

                    file.Create().Close(); //Create then close the file.

                writer = new StreamWriter(file.FullName);

                //TODO: Register events.

            }

            catch (IOException iox)

            {

                Console.WriteLine("Could not open or create file: \"{0}\" -> {1}!", file.FullName, iox.ToString());

            }

        }

        public void Write(bool save = false)

        {

            var s = GetSerializer();

            using (StreamWriter w = writer)

            {

                if (GetConfigType().Equals(ConfigType.YAML))

                    ((YAMLSerializer)s).GetSerializer().Serialize(w, this);

                else if (GetConfigType().Equals(ConfigType.JSON))

                    ((JSONSerializer)s).GetSerializer().Serialize(w, this);

                else

                    ((XMLSerializer)s).GetSerializer().Serialize(w, this);

                if (save)

                    Save();

            }

        }

        public void Save()

        {

            using (StreamWriter w = writer)

                w.Flush();

        }

        public void Close()

            => writer.Close();

        public ISerializationSerializer GetSerializer() => serializer;

        public ConfigType GetConfigType() => GetSerializer().GetConfigType();

        internal void SetData(ISerializationSerializer serializer, FileInfo file)

        {

            this.serializer = serializer;

            this.file = file;

            writer = new StreamWriter(file.FullName);

        }

        public static T ReadConfig<T>(string path, ConfigType ct) where T: ConfigFile

        {

            //Create dummy instance.

            T t = default(T);

            FileInfo fi = new FileInfo(Path.GetFullPath(path));

            if (!(fi.Exists))

                throw new FileNotFoundException($"The specified file \"{fi.FullName}\" does not exist!");

            StreamReader reader = new StreamReader(fi.FullName);

            ISerializationSerializer serializer = (ct.Equals(ConfigType.YAML)) ? new YAMLSerializer() : ((ct.Equals(ConfigType.JSON)) ? new JSONSerializer() : new XMLSerializer(typeof(T)));

            using (StreamReader r = reader)

            {

                if (serializer.GetConfigType().Equals(ConfigType.YAML))

                    t = (T)((YAMLSerializer)serializer).GetDeserializer().Deserialize(r);

                else if (serializer.GetConfigType().Equals(ConfigType.JSON))

                    t = (T)((JSONSerializer)serializer).GetDeserializer().Deserialize(new JsonTextReader(r));

                else

                    t = (T)((XMLSerializer)serializer).GetDeserializer().Deserialize(r);

            }

            t.SetData(serializer, fi);

            return t;

        }

    }

    public interface ISerializationSerializer

    {

        object GetSerializer();

        object GetDeserializer();

        ConfigType GetConfigType();

    }

    public sealed class XMLSerializer : ISerializationSerializer

    {

        private XmlSerializer serializer;

        public XMLSerializer(Type t)

        {

            serializer = new XmlSerializer(t);

        }

        object ISerializationSerializer.GetSerializer() => GetSerializer();

        object ISerializationSerializer.GetDeserializer() => GetDeserializer();

        public XmlSerializer GetSerializer() => serializer;

        public XmlSerializer GetDeserializer() => GetSerializer();

        public ConfigType GetConfigType() => ConfigType.XML;

    }

    public sealed class JSONSerializer : ISerializationSerializer

    {

        private JsonSerializer serializer;

        public JSONSerializer()

        {

            serializer = JsonSerializer.Create(new JsonSerializerSettings()

            {

                Formatting = Newtonsoft.Json.Formatting.Indented

            });

        }

        object ISerializationSerializer.GetSerializer() => GetSerializer();

        object ISerializationSerializer.GetDeserializer() => GetDeserializer();

        public JsonSerializer GetSerializer() => serializer;

        public JsonSerializer GetDeserializer() => GetSerializer();

        public ConfigType GetConfigType() => ConfigType.JSON;

    }

    public sealed class YAMLSerializer : ISerializationSerializer

    {

        private ISerializer serializer;

        private IDeserializer deserializer;

        public YAMLSerializer()

        {

            serializer = new SerializerBuilder().JsonCompatible().Build();

            deserializer = new DeserializerBuilder().IgnoreUnmatchedProperties().Build();

        }

        object ISerializationSerializer.GetSerializer() => GetSerializer();

        object ISerializationSerializer.GetDeserializer() => GetDeserializer();

        public ISerializer GetSerializer() => serializer;

        public IDeserializer GetDeserializer() => deserializer;

        public ConfigType GetConfigType() => ConfigType.YAML;

    }

}