using MP.Data;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Runtime.CompilerServices;

namespace MP.IOC.Services
{

    /// <summary>
    /// Classe base per i servizi che fornisce funzionalità comuni come
    /// - connessione a Redis
    /// - configurazione
    /// - gestione dei messaggi
    /// - strategie di caching.
    ///
    /// Questa classe agisce come modello per altri servizi derivati.
    /// </summary>
    public class BaseServ
    {
        #region Public Constructors

        /// <summary>
        /// Inizializza una nuova istanza della classe BaseServ.
        /// Configura la connessione Redis, carica le impostazioni di configurazione e inizializza il serializzatore JSON.
        /// </summary>
        /// <param name="Configuration">Oggetto di configurazione per recuperare le impostazioni dell'applicazione.</param>
        /// <param name="RedisConn">Multiplexer di connessione Redis per operazioni sul database.</param>
        public BaseServ(IConfiguration Configuration, IConnectionMultiplexer RedisConn)
        {
            _config = Configuration;
            _redisConn = RedisConn;
            _redisDb = _redisConn.GetDatabase();
            // configuro la base key x la cache Redis, con verifica contenga Cache finale
            _redisBaseKey = _config.GetValue<string>("ServerConf:RedisBaseKey") ?? "Lux:Cache";
            // aggiungo cache se non finisse per ":cache"
            if (!_redisBaseKey.EndsWith(":Cache"))
            {
                _redisBaseKey += ":Cache";
            }

            // Configurazione serializzatore JSON per risolvere errore di loop circolare
            JSSettings = new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            };
        }

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// Pipe dei messaggi per la comunicazione riguardo update calcolo BOM
        /// </summary>
        public MessagePipe PipeBom { get; set; } = null!;

        /// <summary>
        /// Pipe dei messaggi per ritorno HwList da Engine di calcolo verso interfaccia utente.
        /// I messaggi vengono inviati sul canale Redis definito da ChannelHwList.
        /// </summary>
        public MessagePipe PipeHwList { get; set; } = null!;

        /// <summary>
        /// Pipe dei messaggi per ritorno HwOptions calcolate da Engine di calcolo verso interfaccia utente.
        /// I messaggi vengono inviati sul canale Redis definito da ChannelHwOpt.
        /// </summary>
        public MessagePipe PipeHwOpt { get; set; } = null!;

        /// <summary>
        /// Pipe dei messaggi per ritorno PNG calcolati da Engine di calcolo verso interfaccia utente.
        /// I messaggi vengono inviati sul canale Redis definito da ChannelPng.
        /// </summary>
        public MessagePipe PipePng { get; set; } = null!;

        /// <summary>
        /// Canale informazioni relativo ad attività relative alla gesitone PROD:
        /// - carico macchine
        /// - scheduling
        /// </summary>
        public MessagePipe PipeProd { get; set; } = null!;

        /// <summary>
        /// Pipe dei messaggi per ritorno info elementi del profile
        /// </summary>
        public MessagePipe PipeProfElement { get; set; } = null!;

        /// <summary>
        /// Pipe dei messaggi per ritorno ProfileListAsync calcolate da Engine di calcolo verso interfaccia utente.
        /// I messaggi vengono inviati sul canale Redis definito da ChannelProfList.
        /// </summary>
        public MessagePipe PipeProfList { get; set; } = null!;

        /// <summary>
        /// Pipe dei messaggi per ritorno Shape calcolate da Engine di calcolo verso interfaccia utente.
        /// I messaggi vengono inviati sul canale Redis definito da ChannelShape.
        /// </summary>
        public MessagePipe PipeShape { get; set; } = null!;

        /// <summary>
        /// Pipe dei messaggi per ritorno SVG calcolati da Engine di calcolo verso interfaccia utente.
        /// I messaggi vengono inviati sul canale Redis definito da ChannelSvg.
        /// </summary>
        public MessagePipe PipeSvg { get; set; } = null!;

        /// <summary>
        /// Pipe dei messaggi per la comunicazione riguardo update generico UI
        /// </summary>
        public MessagePipe PipeUpdate { get; set; } = null!;

        #endregion Public Properties

        #region Protected Fields

        /// <summary>
        /// Oggetto per collezione dati Activity (span in Uptrace)
        /// </summary>
        protected static readonly ActivitySource ActivitySource = new ActivitySource("Lux.DATA");

        /// <summary>
        /// Oggetto logger utilizzato per registrare eventi e errori a livello di classe.
        /// Utile per il monitoraggio del comportamento dell'applicazione e la risoluzione di problemi.
        /// </summary>
        protected static Logger Log = LogManager.GetCurrentClassLogger();

        /// <summary>
        /// Oggetto di configurazione statico per accedere alle impostazioni dell'applicazione (es. stringhe di connessione).
        /// Condiviso tra tutte le istanze di BaseServ.
        /// </summary>
        protected readonly IConfiguration _config = null!;

        /// <summary>
        /// Path base chiavi REDIS
        /// </summary>
        protected readonly string _redisBaseKey = "Lux:Cache";

        /// <summary>
        /// Oggetto per la connessione a Redis utilizzato per operazioni di lettura/scrittura.
        /// </summary>
        protected readonly IConnectionMultiplexer _redisConn = null!;

        /// <summary>
        /// Database Redis utilizzato per le operazioni di lettura/scrittura
        /// nb: ottenuto tramite _redisConn.GetDatabase()
        /// </summary>
        protected readonly IDatabase _redisDb = null!;

        /// <summary>
        /// Abilitazione operazioni tracing generiche
        /// </summary>
        protected readonly bool _traceEnabled = false;

        /// <summary>
        /// Impostazioni del serializzatore JSON utilizzato per gestire oggetti con riferimenti circolari
        /// (es. oggetti che si fanno riferimento reciprocamente).
        /// </summary>
        protected JsonSerializerSettings? JSSettings;

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// Durata della cache breve (circa 1 minuto + variazione del +/-10%)
        /// </summary>
        protected TimeSpan FastCache
        {
            get => TimeSpan.FromSeconds(cacheTtlShort * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata della cache lunga (+ variazione del +/-10%)
        /// </summary>
        protected TimeSpan LongCache
        {
            get => TimeSpan.FromSeconds(cacheTtlLong * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata della cache molto breve (circa 10 secondi + variazione del +/-10%)
        /// </summary>
        protected TimeSpan UltraFastCache
        {
            get => TimeSpan.FromSeconds(cacheTtlShort / 6 * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata della cache molto lunga (+ variazione del +/-10%)
        /// </summary>
        protected TimeSpan UltraLongCache
        {
            get => TimeSpan.FromSeconds(cacheTtlLong * 10 * rnd.Next(900, 1100) / 1000);
        }

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Helper avvio attività per la funzione tracciata
        /// </summary>
        /// <param name="methodName"></param>
        /// <returns></returns>
        protected static Activity? StartActivity([CallerMemberName] string? methodName = null)
        {
            var activity = ActivitySource.StartActivity(methodName ?? "UNDEF");
            activity?.SetTag("host.name", Environment.MachineName);
            return activity;
        }

        /// <summary>
        /// Invalida una o più chiavi/pattern in Redis
        /// </summary>
        protected async Task ClearCacheAsync(params string[] patterns)
        {
            foreach (var pattern in patterns)
            {
                // Chiamata al tuo metodo esistente
                await ExecFlushRedisPatternAsync((RedisValue)pattern);
            }
        }

        /// <summary>
        /// Metodo di flush dati cache Redis
        /// </summary>
        /// <param name="pattern"></param>
        /// <returns></returns>
        protected async Task ExecFlushRedisPatternAsync(RedisValue pattern)
        {
            // Qui inserisci la tua logica attuale (es. via Lua script o Keys/Scan)
            // Esempio rapido via server scan:
            var endpoints = _redisConn.GetEndPoints();
            foreach (var endpoint in endpoints)
            {
                var server = _redisConn.GetServer(endpoint);
                await foreach (var key in server.KeysAsync(_redisDb.Database, pattern))
                {
                    await _redisDb.KeyDeleteAsync(key);
                }
            }
        }

        /// <summary>
        /// Helper generale di lettura da cache o da funzione (DB) con caching successivo
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="factory"></param>
        /// <param name="expiration"></param>
        /// <returns></returns>
        protected async Task<T> GetOrSetCacheAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiration = null, [CallerMemberName] string? caller = null)
        {
            using var activity = StartActivity();
            string source = "DB";

            // 1. Provo Redis
            var cached = await _redisDb.StringGetAsync(key);
            if (cached.HasValue)
            {
                source = "REDIS";
                var cachedResult = JsonConvert.DeserializeObject<T>(cached!)!;

                activity?.SetTag("data.source", source);
                LogTrace($"{source} | trace: {activity?.TraceId} | {activity?.Duration.TotalMilliseconds}ms", NLog.LogLevel.Trace, caller);

                return cachedResult;
            }

            // 2. Chiamo il factory (DB)
            T result = await factory();

            if (result != null)
            {
                // 3. Salva in Redis per la prossima volta
                var serialized = JsonConvert.SerializeObject(result, JSSettings);
                await _redisDb.StringSetAsync(key, serialized, expiration ?? LongCache);
            }

            // sistemo activity tracking data
            activity?.SetTag("data.source", source);
            activity?.Stop();

            // log in console
            LogTrace($"GetOrSetCacheAsync | {source} | trace: {activity?.TraceId} | {activity?.Duration.TotalMilliseconds:N3}ms", NLog.LogLevel.Trace, caller);

            return result!;
        }

        /// <summary>
        /// Helper trace messaggio log (SE abilitato)
        /// </summary>
        /// <param name="traceMsg"></param>
        /// <param name="reqLevel"></param>
        /// <param name="methodName"></param>
        protected void LogTrace(string traceMsg, NLog.LogLevel? reqLevel = null, [CallerMemberName] string? methodName = null)
        {
            if (!_traceEnabled)
                return;

            reqLevel ??= NLog.LogLevel.Debug;

            // Loggo!
            Log.Log(reqLevel, $"{methodName} | {traceMsg}");
        }

        /// <summary>
        /// Helper generale per la telemetria e gestione eccezioni
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="name"></param>
        /// <param name="body"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        protected async Task<T> TraceAsync<T>(string name, Func<Activity?, Task<T>> body, object? parameters = null)
        {
            using var activity = ActivitySource.StartActivity(name);
            try
            {
                if (parameters != null)
                {
                    activity?.SetTag("params", JsonConvert.SerializeObject(parameters));
                }
                var result = await body(activity);
                activity?.SetStatus(ActivityStatusCode.Ok);
                activity?.Stop();
                LogTrace($"TraceAsync | trace: {activity?.TraceId} | {activity?.Duration.TotalMilliseconds}ms", methodName: name);
                return result;
            }
            catch (Exception ex)
            {
                activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
                //Log.Error(ex, "Errore in {MethodName}", name);
                LogTrace($"Errore in {name}", NLog.LogLevel.Error, name);
                throw; // Riesponi l'eccezione per il tracking globale
            }
        }

        #endregion Protected Methods

        #region Private Fields

        private static readonly ConcurrentDictionary<string, SemaphoreSlim> _locks = new();

        /// <summary>
        /// Durata della cache lunga in secondi (predefinito: 5 minuti)
        /// Utilizzato nella proprietà LongCache per definire quanto a lungo i dati devono essere memorizzati in cache.
        /// </summary>
        private int cacheTtlLong = 60 * 5;

        /// <summary>
        /// Durata della cache breve in secondi (predefinito: 1 minuto)
        /// Utilizzato nelle proprietà FastCache e UltraFastCache per definire la durata della cache breve.
        /// </summary>
        private int cacheTtlShort = 60 * 1;


        /// <summary>
        /// Generatore di numeri casuali utilizzato per introdurre variabilità dinamica nelle durate della cache
        /// (simula variazioni reali nella freschezza dei dati e nei tempi di scadenza).
        /// </summary>
        private Random rnd = new Random();

        #endregion Private Fields

        #region Private Methods


        #endregion Private Methods
    }
}