using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Kreta.DataAccessManual;
using Kreta.Framework;
using Kreta.Framework.Caching;
using Microsoft.Extensions.Configuration;
using Kreta.Client.GlobalApi;
using Kreta.Core.Enum;
using Kreta.Core.FeatureToggle;
using Kreta.Core.FeatureToggle.Configuration;
using System.Configuration;
using Kreta.Core;

namespace Kreta.KretaServer.Caching
{
    public sealed class ConnectionStringCache : GenericCache<object>
    {
        private static readonly string SystemConnectionStringsCache = $"{nameof(Kreta)}_{nameof(SystemConnectionStringsCache)}";

        private static readonly string IntezmenyConnectionStringsCache = $"{nameof(Kreta)}_{nameof(IntezmenyConnectionStringsCache)}";

        public ConnectionStringCache(Framework.Caching.CacheManager cacheManager) : base(cacheManager, nameof(ConnectionStringCache))
        {
        }

        #region Private methods

        private List<string> LoadSystemConnectionStrings()
        {
            var systemConnectionStrings = new List<string>();

            if (!string.IsNullOrWhiteSpace(KretaServer.Instance.Configuration.IntezmenyConnectionStringFile))
            {
                string intezmenyConnectionStringFile = KretaServer.Instance.Configuration.IntezmenyConnectionStringFile;

                try
                {
                    if (File.Exists(intezmenyConnectionStringFile))
                    {
                        var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();
                        builder.AddJsonFile(intezmenyConnectionStringFile);
                        IConfigurationRoot configuration = builder.Build();

                        systemConnectionStrings = configuration.GetSection("config:connectionStrings").GetChildren().Select(x => x.Value).ToList();
                    }
                }
                catch (Exception ex)
                {
                    SDAServer.Instance.Logger.ExceptionThrown(ex);
                }
            }
            else
            {
                systemConnectionStrings = new List<string> { KretaServer.Instance.Configuration.DBConnection };
            }

            AddOrUpdate(SystemConnectionStringsCache, systemConnectionStrings, oldValue => systemConnectionStrings);

            return systemConnectionStrings;
        }

        private Dictionary<string, string> GetIntezmenyConnectionStrings()
        {

            var globalApiFeature = new UseGlobalApiConnectionStringFeature((FeatureConfigurationSection)ConfigurationManager.GetSection(Constants.ConfigurationSectionNames.FeatureConfig));

            var result = (Dictionary<string, string>)Get(IntezmenyConnectionStringsCache) ??
                (globalApiFeature.IsEnabled ? LoadIntezmenyConnectionStringsGlobalApi() : LoadIntezmenyConnectionStrings());

            return result;
        }

        private Dictionary<string, string> LoadIntezmenyConnectionStrings()
        {
            var intezmenyConnectionStrings = new Dictionary<string, string>();

            IEnumerable<string> systemConnectionStrings = GetSystemConnectionStrings();

            if (systemConnectionStrings.Any())
            {
                // intézmény kapcsolati leírók feltöltése (json fájlban megadott rendszer leíró db-kből lekérdezem a DB-khez tartozó intézményeket)
                foreach (var connectionString in systemConnectionStrings)
                {
                    intezmenyConnectionStrings = Dal.ServiceSystemConnection.Run(connectionString, h =>
                    {
                        return intezmenyConnectionStrings.Concat(
                                                            h.IntezmenyDal().GetOsszesIntezmeny()
                                                                .Select(intezmeny => new { key = intezmeny.ToLower(), value = connectionString })
                                                                .ToDictionary(k => k.key, v => v.value)
                                                          ).ToDictionary(k => k.Key, v => v.Value);
                    });
                }
            }

            AddOrUpdate(IntezmenyConnectionStringsCache, intezmenyConnectionStrings, oldValue => intezmenyConnectionStrings);

            return intezmenyConnectionStrings;
        }

        private Dictionary<string, string> LoadIntezmenyConnectionStringsGlobalApi()
        {
            var systemType = KretaServer.Instance.Configuration.SystemType;

            var intezmenyConnectionStrings = new Dictionary<string, string>();
            var globalDbConnection = KretaServer.Instance.Configuration.GlobalDbConnection;
            var globalApiClient = GlobalApiClientFactory.Build();
            var token = globalApiClient.GetPrivateToken();
            var dbConnectionList = globalApiClient.GetKretaAdatbaziselerhetosegek(token.AccessToken, systemType);

            foreach (var dbConnenction in dbConnectionList)
            {
                intezmenyConnectionStrings.Add(dbConnenction.IntezmenyAzonosito.ToLower(), string.Format(globalDbConnection, dbConnenction.SqlInstanceName, dbConnenction.DatabaseName));
            }

            AddOrUpdate(IntezmenyConnectionStringsCache, intezmenyConnectionStrings, oldValue => intezmenyConnectionStrings);
            return intezmenyConnectionStrings;
        }

        private string GetIntezmenyiFelhasznalo(string intezmenyAzonosito)
        {
            return $"KR_{intezmenyAzonosito}_user";
        }

        #endregion

        #region Public methods

        public IEnumerable<string> GetOsszesIntezmeny()
        {
            return GetIntezmenyConnectionStrings().Keys;
        }

        public IEnumerable<string> GetSystemConnectionStrings()
        {
            var result = (IList<string>)Get(SystemConnectionStringsCache) ?? LoadSystemConnectionStrings();
            return result;
        }

        public string GetSystemConnectionString(string intezmenyAzonosito)
        {
            intezmenyAzonosito = intezmenyAzonosito.ToLower();
            Dictionary<string, string> intezmenyConnectionStrings = GetIntezmenyConnectionStrings();

            return intezmenyConnectionStrings.TryGetValue(intezmenyAzonosito, out string value)
                ? value
                : KretaServer.Instance.Configuration.DBConnection;
        }

        public string GetIntezmenyConnectionString(string intezmenyAzonosito)
        {
            intezmenyAzonosito = intezmenyAzonosito.ToLower();
            string connectionString = GetSystemConnectionString(intezmenyAzonosito);
            Dictionary<string, string> intezmenyConnectionStrings = GetIntezmenyConnectionStrings();

            if (intezmenyConnectionStrings.ContainsKey(intezmenyAzonosito))
            {
                var builder = new System.Data.SqlClient.SqlConnectionStringBuilder(connectionString)
                {
                    UserID = GetIntezmenyiFelhasznalo(intezmenyAzonosito),
                };

                return builder.ToString();
            }

            return connectionString;
        }

        public void FillCache()
        {
            _ = GetSystemConnectionStrings();
            _ = GetIntezmenyConnectionStrings();
        }

        public void ResetCache()
        {
            _ = LoadSystemConnectionStrings();
            _ = LoadIntezmenyConnectionStrings();
        }

        #endregion
    }
}