using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using InABox.Core;

namespace InABox.Configuration
{
    public interface LocalConfigurationSettings : IConfigurationSettings
    {
    }

    public class LocalConfiguration<T> : Configuration<T> where T : LocalConfigurationSettings, new()
    {
        public LocalConfiguration(string section = "") : base(section)
        {
            Folder = GetPath();
        }

        public LocalConfiguration(string folder, string section) : base(section)
        {
            Folder = folder;
        }

        public string Folder { get; set; }

        private string GetPath() => CoreUtils.GetPath();

        public string GetFileName()
        {
            return Path.Combine(
                Folder,
                typeof(T).Name + ".settings"
            );
        }

        private string EnsureFileName()
        {
            if (!Directory.Exists(Folder))
                Directory.CreateDirectory(Folder);

            return GetFileName();
        }

        private Dictionary<string, T> LoadCurrentConfig(string filename)
        {
            Dictionary<string, T>? config = null;
            if (File.Exists(filename))
                config = Serialization.Deserialize<Dictionary<string, T>>(File.ReadAllText(filename));
            return config ?? new Dictionary<string, T>();
        }

        public override T Load()
        {
            var cached = ConfigurationCache.Check<T>(ConfigurationCacheType.Local, Section);
            if (cached != null)
                //Logger.Send(LogType.Information, "", "Local Config: Returning Cached Configuration Data");
                return cached;

            //Logger.Send(LogType.Information, "", "Local Config: Creating "+typeof(T).EntityName().Split('.').Last());

            var result = new T();
            var filename = EnsureFileName();

            //Logger.Send(LogType.Information, "", "Local Config: FileName is ["+filename+"]");

            if (File.Exists(filename))
            {
                //Logger.Send(LogType.Information, "", "Local Config: Deserializing Configuration");

                var config =
                    Serialization.Deserialize<Dictionary<string, T>>(File.ReadAllText(filename)); //Toml.ReadString<T>(File.ReadAllText(FileName));
                if (config != null && config.ContainsKey(Section))
                    //Logger.Send(LogType.Information, "", "Local Config:  Found Section ["+Section+"}");
                    if (config[Section] != null)
                        //Logger.Send(LogType.Information, "", "Local Config: ["+Section+"] is not null");
                        result = config[Section];
            }

            //Logger.Send(LogType.Information, "", "Local Config: Adding Configuration to Cache");
            ConfigurationCache.Add(ConfigurationCacheType.Local, Section, result);

            return result;
        }

        public override Dictionary<string, T> LoadAll()
        {
            return LoadCurrentConfig(EnsureFileName());
        }

        public override void Save(T obj)
        {
            var filename = EnsureFileName();
            var config = LoadCurrentConfig(filename);

            config[Section] = obj;

            var contents = Serialization.Serialize(config, true);

            File.WriteAllText(filename, contents);

            ConfigurationCache.Add(ConfigurationCacheType.Local, Section, obj);
        }

        public override void SaveAll(Dictionary<string, T> objs)
        {
            var filename = EnsureFileName();
            var config = LoadCurrentConfig(filename);

            foreach(var (section, obj) in objs)
            {
                config[section] = obj;
            }

            var contents = Serialization.Serialize(config, true);
            File.WriteAllText(filename, contents);

            foreach(var (section, obj) in objs)
            {
                ConfigurationCache.Add(ConfigurationCacheType.Local, section, obj);
            }
        }

        public override void Delete(Action<Exception?>? callback = null)
        {
            var filename = EnsureFileName();
            var config = LoadCurrentConfig(filename);

            if (config.ContainsKey(Section))
                config.Remove(Section);
            if (config.Any())
            {
                var contents = Serialization.Serialize(config);

                File.WriteAllText(filename, contents);
            }
            else
            {
                if (File.Exists(filename))
                    File.Delete(filename);
            }

            ConfigurationCache.Clear<T>(ConfigurationCacheType.Local, Section);

            callback?.Invoke(null);
        }

        public override string[] Sections()
        {
            if (!Directory.Exists(Folder))
                return new[] { "" };

            var filename = GetFileName();

            if (!File.Exists(filename))
                return new[] { "" };

            var config =
                Serialization.Deserialize<Dictionary<string, T>>(File.ReadAllText(filename)); //Toml.ReadString<T>(File.ReadAllText(FileName));
            if (config == null)
                return new[] { "" };

            return config.Keys.ToArray();
        }
    }
}